CodeGeneratorInspectorStrings.py [plain text]
frontend_domain_class = (
"""class ${exportMacro} ${domainClassName} {
public:
${domainClassName}(InspectorFrontendChannel* inspectorFrontendChannel) : m_inspectorFrontendChannel(inspectorFrontendChannel) { }
${frontendDomainMethodDeclarations}private:
InspectorFrontendChannel* m_inspectorFrontendChannel;
};
""")
backend_dispatcher_constructor = (
"""PassRefPtr<${dispatcherName}> ${dispatcherName}::create(InspectorBackendDispatcher* backendDispatcher, ${agentName}* agent)
{
return adoptRef(new ${dispatcherName}(backendDispatcher, agent));
}
${dispatcherName}::${dispatcherName}(InspectorBackendDispatcher* backendDispatcher, ${agentName}* agent)
: InspectorSupplementalBackendDispatcher(backendDispatcher)
, m_agent(agent)
{
m_backendDispatcher->registerDispatcherForDomain(ASCIILiteral("${domainName}"), this);
}
""")
backend_dispatcher_dispatch_method_simple = (
"""void ${dispatcherName}::dispatch(long callId, const String& method, PassRefPtr<InspectorObject> message)
{
Ref<${dispatcherName}> protect(*this);
${ifChain}
else
m_backendDispatcher->reportProtocolError(&callId, InspectorBackendDispatcher::MethodNotFound, String("'") + "${domainName}" + '.' + method + "' was not found");
}
""")
backend_dispatcher_dispatch_method = (
"""void ${dispatcherName}::dispatch(long callId, const String& method, PassRefPtr<InspectorObject> message)
{
Ref<${dispatcherName}> protect(*this);
typedef void (${dispatcherName}::*CallHandler)(long callId, const Inspector::InspectorObject& message);
typedef HashMap<String, CallHandler> DispatchMap;
DEPRECATED_DEFINE_STATIC_LOCAL(DispatchMap, dispatchMap, ());
if (dispatchMap.isEmpty()) {
static const struct MethodTable {
const char* name;
CallHandler handler;
} commands[] = {
${dispatcherCommands}
};
size_t length = WTF_ARRAY_LENGTH(commands);
for (size_t i = 0; i < length; ++i)
dispatchMap.add(commands[i].name, commands[i].handler);
}
HashMap<String, CallHandler>::iterator it = dispatchMap.find(method);
if (it == dispatchMap.end()) {
m_backendDispatcher->reportProtocolError(&callId, InspectorBackendDispatcher::MethodNotFound, String("'") + "${domainName}" + '.' + method + "' was not found");
return;
}
((*this).*it->value)(callId, *message.get());
}
""")
backend_method = (
"""void ${dispatcherName}::${methodName}(long callId, const InspectorObject&${requestMessageObject})
{
${methodInParametersHandling}${methodDispatchHandling}${methodOutParametersHandling}${methodEndingHandling}
}
""")
frontend_method = ("""void Inspector${domainName}FrontendDispatcher::${eventName}(${parameters})
{
RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
jsonMessage->setString(ASCIILiteral("method"), ASCIILiteral("${domainName}.${eventName}"));
${code}
m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
}
""")
callback_method = (
"""${handlerName}::${callbackName}::${callbackName}(PassRefPtr<InspectorBackendDispatcher> backendDispatcher, int id) : Inspector::InspectorBackendDispatcher::CallbackBase(backendDispatcher, id) { }
void ${handlerName}::${callbackName}::sendSuccess(${parameters})
{
RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
${code} sendIfActive(jsonMessage, ErrorString());
}
""")
frontend_h = (
"""#ifndef Inspector${outputFileNamePrefix}FrontendDispatchers_h
#define Inspector${outputFileNamePrefix}FrontendDispatchers_h
#include "Inspector${outputFileNamePrefix}TypeBuilders.h"
#include <inspector/InspectorFrontendChannel.h>
#include <inspector/InspectorValues.h>
#include <wtf/PassRefPtr.h>
#include <wtf/text/WTFString.h>
namespace Inspector {
#if ENABLE(INSPECTOR)
${domainClassList}
#endif // ENABLE(INSPECTOR)
} // namespace Inspector
#endif // !defined(Inspector${outputFileNamePrefix}FrontendDispatchers_h)
""")
backend_h = (
"""#ifndef Inspector${outputFileNamePrefix}BackendDispatchers_h
#define Inspector${outputFileNamePrefix}BackendDispatchers_h
#if ENABLE(INSPECTOR)
#include "Inspector${outputFileNamePrefix}TypeBuilders.h"
#include <inspector/InspectorBackendDispatcher.h>
#include <wtf/PassRefPtr.h>
#include <wtf/text/WTFString.h>
namespace Inspector {
typedef String ErrorString;
${handlerInterfaces}
${dispatcherInterfaces}
} // namespace Inspector
#endif // ENABLE(INSPECTOR)
#endif // !defined(Inspector${outputFileNamePrefix}BackendDispatchers_h)
""")
backend_cpp = (
"""
#include "config.h"
#if ENABLE(INSPECTOR)
#include "Inspector${outputFileNamePrefix}BackendDispatchers.h"
#include <inspector/InspectorFrontendChannel.h>
#include <inspector/InspectorValues.h>
#include <wtf/text/CString.h>
#include <wtf/text/WTFString.h>
namespace Inspector {
${handlerImplementations}
${methods}
} // namespace Inspector
#endif // ENABLE(INSPECTOR)
""")
frontend_cpp = (
"""
#include "config.h"
#if ENABLE(INSPECTOR)
#include "Inspector${outputFileNamePrefix}FrontendDispatchers.h"
#include <wtf/text/CString.h>
#include <wtf/text/WTFString.h>
namespace Inspector {
${methods}
} // namespace Inspector
#endif // ENABLE(INSPECTOR)
""")
typebuilder_h = (
"""
#ifndef Inspector${outputFileNamePrefix}TypeBuilders_h
#define Inspector${outputFileNamePrefix}TypeBuilders_h
#if ENABLE(INSPECTOR)
#include <inspector/InspectorTypeBuilder.h>
${typeBuilderDependencies}
#include <wtf/Assertions.h>
#include <wtf/PassRefPtr.h>
namespace Inspector {
namespace TypeBuilder {
${forwards}
${exportMacro} String get${outputFileNamePrefix}EnumConstantValue(int code);
${typeBuilders}
} // namespace TypeBuilder
} // namespace Inspector
#endif // ENABLE(INSPECTOR)
#endif // !defined(Inspector${outputFileNamePrefix}TypeBuilders_h)
""")
typebuilder_cpp = (
"""
#include "config.h"
#include "Inspector${outputFileNamePrefix}TypeBuilders.h"
#if ENABLE(INSPECTOR)
#include <wtf/text/CString.h>
namespace Inspector {
namespace TypeBuilder {
static const char* const enum_constant_values[] = {
${enumConstantValues}};
String get${outputFileNamePrefix}EnumConstantValue(int code) {
return enum_constant_values[code];
}
} // namespace TypeBuilder
${implCode}
#if ${validatorIfdefName}
${validatorCode}
#endif // ${validatorIfdefName}
} // namespace Inspector
#endif // ENABLE(INSPECTOR)
""")
backend_js = (
"""
${domainInitializers}
""")
param_container_access_code = """
RefPtr<InspectorObject> paramsContainer = message.getObject("params");
InspectorObject* paramsContainerPtr = paramsContainer.get();
InspectorArray* protocolErrorsPtr = protocolErrors.get();
"""
class_binding_builder_part_1 = (
""" AllFieldsSet = %s
};
template<int STATE>
class Builder {
private:
RefPtr<Inspector::InspectorObject> m_result;
template<int STEP> Builder<STATE | STEP>& castState()
{
return *reinterpret_cast<Builder<STATE | STEP>*>(this);
}
Builder(PassRefPtr</*%s*/Inspector::InspectorObject> ptr)
{
COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
m_result = ptr;
}
friend class %s;
public:
""")
class_binding_builder_part_2 = ("""
Builder<STATE | %s>& set%s(%s value)
{
COMPILE_ASSERT(!(STATE & %s), property_%s_already_set);
m_result->set%s(ASCIILiteral("%s"), %s);
return castState<%s>();
}
""")
class_binding_builder_part_3 = ("""
operator RefPtr<%s>& ()
{
COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
COMPILE_ASSERT(sizeof(%s) == sizeof(Inspector::InspectorObject), cannot_cast);
return *reinterpret_cast<RefPtr<%s>*>(&m_result);
}
PassRefPtr<%s> release()
{
return RefPtr<%s>(*this).release();
}
};
""")
class_binding_builder_part_4 = (
""" static Builder<NoFieldsSet> create()
{
return Builder<NoFieldsSet>(Inspector::InspectorObject::create());
}
""")