1# Copyright (c) 2013 Google Inc. All rights reserved. 2# Copyright (c) 2013 Apple Inc. All Rights Reserved. 3# 4# Redistribution and use in source and binary forms, with or without 5# modification, are permitted provided that the following conditions are 6# met: 7# 8# * Redistributions of source code must retain the above copyright 9# notice, this list of conditions and the following disclaimer. 10# * Redistributions in binary form must reproduce the above 11# copyright notice, this list of conditions and the following disclaimer 12# in the documentation and/or other materials provided with the 13# distribution. 14# * Neither the name of Google Inc. nor the names of its 15# contributors may be used to endorse or promote products derived from 16# this software without specific prior written permission. 17# 18# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 30# This file contains string resources for CodeGeneratorInspector. 31# Its syntax is a Python syntax subset, suitable for manual parsing. 32 33frontend_domain_class = ( 34"""class ${exportMacro} ${domainClassName} { 35public: 36 ${domainClassName}(InspectorFrontendChannel* inspectorFrontendChannel) : m_inspectorFrontendChannel(inspectorFrontendChannel) { } 37${frontendDomainMethodDeclarations}private: 38 InspectorFrontendChannel* m_inspectorFrontendChannel; 39}; 40 41""") 42 43backend_dispatcher_constructor = ( 44"""PassRefPtr<${dispatcherName}> ${dispatcherName}::create(InspectorBackendDispatcher* backendDispatcher, ${agentName}* agent) 45{ 46 return adoptRef(new ${dispatcherName}(backendDispatcher, agent)); 47} 48 49${dispatcherName}::${dispatcherName}(InspectorBackendDispatcher* backendDispatcher, ${agentName}* agent) 50 : InspectorSupplementalBackendDispatcher(backendDispatcher) 51 , m_agent(agent) 52{ 53 m_backendDispatcher->registerDispatcherForDomain(ASCIILiteral("${domainName}"), this); 54} 55""") 56 57backend_dispatcher_dispatch_method_simple = ( 58"""void ${dispatcherName}::dispatch(long callId, const String& method, PassRefPtr<InspectorObject> message) 59{ 60 Ref<${dispatcherName}> protect(*this); 61 62${ifChain} 63 else 64 m_backendDispatcher->reportProtocolError(&callId, InspectorBackendDispatcher::MethodNotFound, String("'") + "${domainName}" + '.' + method + "' was not found"); 65} 66""") 67 68backend_dispatcher_dispatch_method = ( 69"""void ${dispatcherName}::dispatch(long callId, const String& method, PassRefPtr<InspectorObject> message) 70{ 71 Ref<${dispatcherName}> protect(*this); 72 73 typedef void (${dispatcherName}::*CallHandler)(long callId, const Inspector::InspectorObject& message); 74 typedef HashMap<String, CallHandler> DispatchMap; 75 DEPRECATED_DEFINE_STATIC_LOCAL(DispatchMap, dispatchMap, ()); 76 if (dispatchMap.isEmpty()) { 77 static const struct MethodTable { 78 const char* name; 79 CallHandler handler; 80 } commands[] = { 81${dispatcherCommands} 82 }; 83 size_t length = WTF_ARRAY_LENGTH(commands); 84 for (size_t i = 0; i < length; ++i) 85 dispatchMap.add(commands[i].name, commands[i].handler); 86 } 87 88 HashMap<String, CallHandler>::iterator it = dispatchMap.find(method); 89 if (it == dispatchMap.end()) { 90 m_backendDispatcher->reportProtocolError(&callId, InspectorBackendDispatcher::MethodNotFound, String("'") + "${domainName}" + '.' + method + "' was not found"); 91 return; 92 } 93 94 ((*this).*it->value)(callId, *message.get()); 95} 96""") 97 98backend_method = ( 99"""void ${dispatcherName}::${methodName}(long callId, const InspectorObject&${requestMessageObject}) 100{ 101${methodInParametersHandling}${methodDispatchHandling}${methodOutParametersHandling}${methodEndingHandling} 102} 103""") 104 105frontend_method = ("""void Inspector${domainName}FrontendDispatcher::${eventName}(${parameters}) 106{ 107 RefPtr<InspectorObject> jsonMessage = InspectorObject::create(); 108 jsonMessage->setString(ASCIILiteral("method"), ASCIILiteral("${domainName}.${eventName}")); 109${code} 110 m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage->toJSONString()); 111} 112""") 113 114callback_method = ( 115"""${handlerName}::${callbackName}::${callbackName}(PassRefPtr<InspectorBackendDispatcher> backendDispatcher, int id) : Inspector::InspectorBackendDispatcher::CallbackBase(backendDispatcher, id) { } 116 117void ${handlerName}::${callbackName}::sendSuccess(${parameters}) 118{ 119 RefPtr<InspectorObject> jsonMessage = InspectorObject::create(); 120${code} sendIfActive(jsonMessage, ErrorString()); 121} 122""") 123 124frontend_h = ( 125"""#ifndef Inspector${outputFileNamePrefix}FrontendDispatchers_h 126#define Inspector${outputFileNamePrefix}FrontendDispatchers_h 127 128#include "Inspector${outputFileNamePrefix}TypeBuilders.h" 129#include <inspector/InspectorFrontendChannel.h> 130#include <inspector/InspectorValues.h> 131#include <wtf/PassRefPtr.h> 132#include <wtf/text/WTFString.h> 133 134namespace Inspector { 135 136#if ENABLE(INSPECTOR) 137 138${domainClassList} 139 140#endif // ENABLE(INSPECTOR) 141 142} // namespace Inspector 143 144#endif // !defined(Inspector${outputFileNamePrefix}FrontendDispatchers_h) 145""") 146 147backend_h = ( 148"""#ifndef Inspector${outputFileNamePrefix}BackendDispatchers_h 149#define Inspector${outputFileNamePrefix}BackendDispatchers_h 150 151#if ENABLE(INSPECTOR) 152 153#include "Inspector${outputFileNamePrefix}TypeBuilders.h" 154#include <inspector/InspectorBackendDispatcher.h> 155#include <wtf/PassRefPtr.h> 156#include <wtf/text/WTFString.h> 157 158namespace Inspector { 159 160typedef String ErrorString; 161 162${handlerInterfaces} 163 164${dispatcherInterfaces} 165} // namespace Inspector 166 167#endif // ENABLE(INSPECTOR) 168 169#endif // !defined(Inspector${outputFileNamePrefix}BackendDispatchers_h) 170""") 171 172backend_cpp = ( 173""" 174#include "config.h" 175 176#if ENABLE(INSPECTOR) 177 178#include "Inspector${outputFileNamePrefix}BackendDispatchers.h" 179 180#include <inspector/InspectorFrontendChannel.h> 181#include <inspector/InspectorValues.h> 182#include <wtf/text/CString.h> 183#include <wtf/text/WTFString.h> 184 185namespace Inspector { 186 187${handlerImplementations} 188 189${methods} 190} // namespace Inspector 191 192#endif // ENABLE(INSPECTOR) 193""") 194 195frontend_cpp = ( 196""" 197 198#include "config.h" 199 200#if ENABLE(INSPECTOR) 201 202#include "Inspector${outputFileNamePrefix}FrontendDispatchers.h" 203 204#include <wtf/text/CString.h> 205#include <wtf/text/WTFString.h> 206 207namespace Inspector { 208 209${methods} 210 211} // namespace Inspector 212 213#endif // ENABLE(INSPECTOR) 214""") 215 216typebuilder_h = ( 217""" 218#ifndef Inspector${outputFileNamePrefix}TypeBuilders_h 219#define Inspector${outputFileNamePrefix}TypeBuilders_h 220 221#if ENABLE(INSPECTOR) 222 223#include <inspector/InspectorTypeBuilder.h> 224${typeBuilderDependencies} 225#include <wtf/Assertions.h> 226#include <wtf/PassRefPtr.h> 227 228namespace Inspector { 229 230namespace TypeBuilder { 231 232${forwards} 233 234${exportMacro} String get${outputFileNamePrefix}EnumConstantValue(int code); 235 236${typeBuilders} 237} // namespace TypeBuilder 238 239} // namespace Inspector 240 241#endif // ENABLE(INSPECTOR) 242 243#endif // !defined(Inspector${outputFileNamePrefix}TypeBuilders_h) 244 245""") 246 247typebuilder_cpp = ( 248""" 249 250#include "config.h" 251#include "Inspector${outputFileNamePrefix}TypeBuilders.h" 252 253#if ENABLE(INSPECTOR) 254 255#include <wtf/text/CString.h> 256 257namespace Inspector { 258 259namespace TypeBuilder { 260 261static const char* const enum_constant_values[] = { 262${enumConstantValues}}; 263 264String get${outputFileNamePrefix}EnumConstantValue(int code) { 265 return enum_constant_values[code]; 266} 267 268} // namespace TypeBuilder 269 270${implCode} 271 272#if ${validatorIfdefName} 273 274${validatorCode} 275 276#endif // ${validatorIfdefName} 277 278} // namespace Inspector 279 280#endif // ENABLE(INSPECTOR) 281""") 282 283backend_js = ( 284""" 285 286${domainInitializers} 287""") 288 289param_container_access_code = """ 290 RefPtr<InspectorObject> paramsContainer = message.getObject("params"); 291 InspectorObject* paramsContainerPtr = paramsContainer.get(); 292 InspectorArray* protocolErrorsPtr = protocolErrors.get(); 293""" 294 295class_binding_builder_part_1 = ( 296""" AllFieldsSet = %s 297 }; 298 299 template<int STATE> 300 class Builder { 301 private: 302 RefPtr<Inspector::InspectorObject> m_result; 303 304 template<int STEP> Builder<STATE | STEP>& castState() 305 { 306 return *reinterpret_cast<Builder<STATE | STEP>*>(this); 307 } 308 309 Builder(PassRefPtr</*%s*/Inspector::InspectorObject> ptr) 310 { 311 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); 312 m_result = ptr; 313 } 314 friend class %s; 315 public: 316""") 317 318class_binding_builder_part_2 = (""" 319 Builder<STATE | %s>& set%s(%s value) 320 { 321 COMPILE_ASSERT(!(STATE & %s), property_%s_already_set); 322 m_result->set%s(ASCIILiteral("%s"), %s); 323 return castState<%s>(); 324 } 325""") 326 327class_binding_builder_part_3 = (""" 328 operator RefPtr<%s>& () 329 { 330 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); 331 COMPILE_ASSERT(sizeof(%s) == sizeof(Inspector::InspectorObject), cannot_cast); 332 return *reinterpret_cast<RefPtr<%s>*>(&m_result); 333 } 334 335 PassRefPtr<%s> release() 336 { 337 return RefPtr<%s>(*this).release(); 338 } 339 }; 340 341""") 342 343class_binding_builder_part_4 = ( 344""" static Builder<NoFieldsSet> create() 345 { 346 return Builder<NoFieldsSet>(Inspector::InspectorObject::create()); 347 } 348""") 349