| # Copyright (c) 2013 Google Inc. All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions are |
| # met: |
| # |
| # * Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # * Redistributions in binary form must reproduce the above |
| # copyright notice, this list of conditions and the following disclaimer |
| # in the documentation and/or other materials provided with the |
| # distribution. |
| # * Neither the name of Google Inc. nor the names of its |
| # contributors may be used to endorse or promote products derived from |
| # this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| # THis file contains string resources for CodeGeneratorInspector. |
| # Its syntax is a Python syntax subset, suitable for manual parsing. |
| |
| frontend_domain_class = ( |
| """ class $domainClassName { |
| public: |
| $domainClassName(InspectorFrontendChannel* inspectorFrontendChannel) : m_inspectorFrontendChannel(inspectorFrontendChannel) { } |
| ${frontendDomainMethodDeclarations} |
| void flush() { m_inspectorFrontendChannel->flush(); } |
| private: |
| InspectorFrontendChannel* m_inspectorFrontendChannel; |
| }; |
| |
| $domainClassName* $domainFieldName() { return &m_$domainFieldName; } |
| |
| """) |
| |
| backend_method = ( |
| """void InspectorBackendDispatcherImpl::${domainName}_$methodName(long callId, JSONObject*$requestMessageObject, JSONArray* protocolErrors) |
| { |
| if (!$agentField) |
| protocolErrors->pushString("${domainName} handler is not available."); |
| $methodCode |
| if (protocolErrors->length()) { |
| reportProtocolError(&callId, InvalidParams, String::format(InvalidParamsFormatString, commandName($commandNameIndex)), protocolErrors); |
| return; |
| } |
| $agentCallParamsDeclaration |
| $agentField->$methodName($agentCallParams); |
| $responseCook |
| sendResponse(callId, $sendResponseCallParams); |
| } |
| """) |
| |
| frontend_method = ("""void InspectorFrontend::$domainName::$eventName($parameters) |
| { |
| RefPtr<JSONObject> jsonMessage = JSONObject::create(); |
| jsonMessage->setString("method", "$domainName.$eventName"); |
| $code if (m_inspectorFrontendChannel) |
| m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage.release()); |
| } |
| """) |
| |
| callback_main_methods = ( |
| """InspectorBackendDispatcher::$agentName::$callbackName::$callbackName(PassRefPtrWillBeRawPtr<InspectorBackendDispatcherImpl> backendImpl, int id) : CallbackBase(backendImpl, id) {} |
| |
| void InspectorBackendDispatcher::$agentName::$callbackName::sendSuccess($parameters) |
| { |
| RefPtr<JSONObject> jsonMessage = JSONObject::create(); |
| $code sendIfActive(jsonMessage, ErrorString(), PassRefPtr<JSONValue>()); |
| } |
| """) |
| |
| callback_failure_method = ( |
| """void InspectorBackendDispatcher::$agentName::$callbackName::sendFailure(const ErrorString& error, $parameter) |
| { |
| ASSERT(error.length()); |
| RefPtr<JSONValue> errorDataValue; |
| if (error) { |
| errorDataValue = $argument; |
| } |
| sendIfActive(nullptr, error, errorDataValue.release()); |
| } |
| """) |
| |
| |
| frontend_h = ( |
| """#ifndef InspectorFrontend_h |
| #define InspectorFrontend_h |
| |
| #include "InspectorTypeBuilder.h" |
| #include "core/inspector/InspectorFrontendChannel.h" |
| #include "platform/JSONValues.h" |
| #include "wtf/PassRefPtr.h" |
| #include "wtf/text/WTFString.h" |
| |
| namespace blink { |
| |
| typedef String ErrorString; |
| |
| class InspectorFrontend { |
| public: |
| InspectorFrontend(InspectorFrontendChannel*); |
| InspectorFrontendChannel* channel() { return m_inspectorFrontendChannel; } |
| |
| $domainClassList |
| private: |
| InspectorFrontendChannel* m_inspectorFrontendChannel; |
| ${fieldDeclarations}}; |
| |
| } // namespace blink |
| #endif // !defined(InspectorFrontend_h) |
| """) |
| |
| backend_h = ( |
| """#ifndef InspectorBackendDispatcher_h |
| #define InspectorBackendDispatcher_h |
| |
| #include "InspectorTypeBuilder.h" |
| |
| #include "platform/heap/Handle.h" |
| #include "wtf/PassRefPtr.h" |
| #include "wtf/RefCounted.h" |
| #include "wtf/text/WTFString.h" |
| |
| namespace blink { |
| |
| class JSONObject; |
| class JSONArray; |
| class InspectorFrontendChannel; |
| |
| typedef String ErrorString; |
| |
| class InspectorBackendDispatcherImpl; |
| |
| class InspectorBackendDispatcher: public RefCountedWillBeGarbageCollectedFinalized<InspectorBackendDispatcher> { |
| public: |
| static PassRefPtrWillBeRawPtr<InspectorBackendDispatcher> create(InspectorFrontendChannel* inspectorFrontendChannel); |
| virtual ~InspectorBackendDispatcher() { } |
| virtual void trace(Visitor*) { } |
| |
| class CallbackBase: public RefCountedWillBeGarbageCollectedFinalized<CallbackBase> { |
| public: |
| CallbackBase(PassRefPtrWillBeRawPtr<InspectorBackendDispatcherImpl> backendImpl, int id); |
| virtual ~CallbackBase(); |
| virtual void trace(Visitor*); |
| void sendFailure(const ErrorString&); |
| bool isActive(); |
| |
| protected: |
| void sendIfActive(PassRefPtr<JSONObject> partialMessage, const ErrorString& invocationError, PassRefPtr<JSONValue> errorData); |
| |
| private: |
| void disable() { m_alreadySent = true; } |
| |
| RefPtrWillBeMember<InspectorBackendDispatcherImpl> m_backendImpl; |
| int m_id; |
| bool m_alreadySent; |
| |
| friend class InspectorBackendDispatcherImpl; |
| }; |
| |
| $agentInterfaces |
| $virtualSetters |
| |
| virtual void clearFrontend() = 0; |
| |
| enum CommonErrorCode { |
| ParseError = 0, |
| InvalidRequest, |
| MethodNotFound, |
| InvalidParams, |
| InternalError, |
| ServerError, |
| LastEntry, |
| }; |
| |
| void reportProtocolError(const long* const callId, CommonErrorCode, const String& errorMessage) const; |
| virtual void reportProtocolError(const long* const callId, CommonErrorCode, const String& errorMessage, PassRefPtr<JSONValue> data) const = 0; |
| virtual void dispatch(const String& message) = 0; |
| static bool getCommandName(const String& message, String* result); |
| |
| enum MethodNames { |
| $methodNamesEnumContent |
| |
| kMethodNamesEnumSize |
| }; |
| |
| static const char* commandName(MethodNames); |
| |
| private: |
| static const char commandNames[]; |
| static const size_t commandNamesIndex[]; |
| }; |
| |
| } // namespace blink |
| #endif // !defined(InspectorBackendDispatcher_h) |
| |
| |
| """) |
| |
| backend_cpp = ( |
| """ |
| |
| #include "config.h" |
| #include "InspectorBackendDispatcher.h" |
| |
| #include "core/inspector/InspectorFrontendChannel.h" |
| #include "core/inspector/JSONParser.h" |
| #include "platform/JSONValues.h" |
| #include "wtf/text/CString.h" |
| #include "wtf/text/WTFString.h" |
| |
| namespace blink { |
| |
| const char InspectorBackendDispatcher::commandNames[] = { |
| $methodNameDeclarations |
| }; |
| |
| const size_t InspectorBackendDispatcher::commandNamesIndex[] = { |
| $methodNameDeclarationsIndex |
| }; |
| |
| const char* InspectorBackendDispatcher::commandName(MethodNames index) { |
| COMPILE_ASSERT(static_cast<int>(kMethodNamesEnumSize) == WTF_ARRAY_LENGTH(commandNamesIndex), command_name_array_problem); |
| return commandNames + commandNamesIndex[index]; |
| } |
| |
| class InspectorBackendDispatcherImpl : public InspectorBackendDispatcher { |
| public: |
| InspectorBackendDispatcherImpl(InspectorFrontendChannel* inspectorFrontendChannel) |
| : m_inspectorFrontendChannel(inspectorFrontendChannel) |
| $constructorInit |
| { } |
| |
| virtual void clearFrontend() { m_inspectorFrontendChannel = 0; } |
| virtual void dispatch(const String& message); |
| virtual void reportProtocolError(const long* const callId, CommonErrorCode, const String& errorMessage, PassRefPtr<JSONValue> data) const; |
| using InspectorBackendDispatcher::reportProtocolError; |
| |
| void sendResponse(long callId, const ErrorString& invocationError, PassRefPtr<JSONValue> errorData, PassRefPtr<JSONObject> result); |
| bool isActive() { return m_inspectorFrontendChannel; } |
| |
| $setters |
| private: |
| $methodDeclarations |
| |
| InspectorFrontendChannel* m_inspectorFrontendChannel; |
| $fieldDeclarations |
| |
| template<typename R, typename V, typename V0> |
| static R getPropertyValueImpl(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors, V0 initial_value, bool (*as_method)(JSONValue*, V*), const char* type_name); |
| |
| static int getInt(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors); |
| static double getDouble(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors); |
| static String getString(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors); |
| static bool getBoolean(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors); |
| static PassRefPtr<JSONObject> getObject(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors); |
| static PassRefPtr<JSONArray> getArray(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors); |
| |
| void sendResponse(long callId, ErrorString invocationError, PassRefPtr<JSONObject> result) |
| { |
| sendResponse(callId, invocationError, RefPtr<JSONValue>(), result); |
| } |
| void sendResponse(long callId, ErrorString invocationError) |
| { |
| sendResponse(callId, invocationError, RefPtr<JSONValue>(), JSONObject::create()); |
| } |
| static const char InvalidParamsFormatString[]; |
| }; |
| |
| const char InspectorBackendDispatcherImpl::InvalidParamsFormatString[] = "Some arguments of method '%s' can't be processed"; |
| |
| $methods |
| |
| PassRefPtrWillBeRawPtr<InspectorBackendDispatcher> InspectorBackendDispatcher::create(InspectorFrontendChannel* inspectorFrontendChannel) |
| { |
| return adoptRefWillBeNoop(new InspectorBackendDispatcherImpl(inspectorFrontendChannel)); |
| } |
| |
| |
| void InspectorBackendDispatcherImpl::dispatch(const String& message) |
| { |
| RefPtrWillBeRawPtr<InspectorBackendDispatcher> protect(this); |
| typedef void (InspectorBackendDispatcherImpl::*CallHandler)(long callId, JSONObject* messageObject, JSONArray* protocolErrors); |
| typedef HashMap<String, CallHandler> DispatchMap; |
| DEFINE_STATIC_LOCAL(DispatchMap, dispatchMap, ); |
| long callId = 0; |
| |
| if (dispatchMap.isEmpty()) { |
| static const CallHandler handlers[] = { |
| $messageHandlers |
| }; |
| for (size_t i = 0; i < kMethodNamesEnumSize; ++i) |
| dispatchMap.add(commandName(static_cast<MethodNames>(i)), handlers[i]); |
| } |
| |
| RefPtr<JSONValue> parsedMessage = parseJSON(message); |
| if (!parsedMessage) { |
| reportProtocolError(0, ParseError, "Message must be in JSON format"); |
| return; |
| } |
| |
| RefPtr<JSONObject> messageObject = parsedMessage->asObject(); |
| if (!messageObject) { |
| reportProtocolError(0, InvalidRequest, "Message must be a JSONified object"); |
| return; |
| } |
| |
| RefPtr<JSONValue> callIdValue = messageObject->get("id"); |
| if (!callIdValue) { |
| reportProtocolError(0, InvalidRequest, "'id' property was not found"); |
| return; |
| } |
| |
| if (!callIdValue->asNumber(&callId)) { |
| reportProtocolError(0, InvalidRequest, "The type of 'id' property must be number"); |
| return; |
| } |
| |
| RefPtr<JSONValue> methodValue = messageObject->get("method"); |
| if (!methodValue) { |
| reportProtocolError(&callId, InvalidRequest, "'method' property wasn't found"); |
| return; |
| } |
| |
| String method; |
| if (!methodValue->asString(&method)) { |
| reportProtocolError(&callId, InvalidRequest, "The type of 'method' property must be string"); |
| return; |
| } |
| |
| HashMap<String, CallHandler>::iterator it = dispatchMap.find(method); |
| if (it == dispatchMap.end()) { |
| reportProtocolError(&callId, MethodNotFound, "'" + method + "' wasn't found"); |
| return; |
| } |
| |
| RefPtr<JSONArray> protocolErrors = JSONArray::create(); |
| ((*this).*it->value)(callId, messageObject.get(), protocolErrors.get()); |
| } |
| |
| void InspectorBackendDispatcherImpl::sendResponse(long callId, const ErrorString& invocationError, PassRefPtr<JSONValue> errorData, PassRefPtr<JSONObject> result) |
| { |
| if (invocationError.length()) { |
| reportProtocolError(&callId, ServerError, invocationError, errorData); |
| return; |
| } |
| |
| RefPtr<JSONObject> responseMessage = JSONObject::create(); |
| responseMessage->setNumber("id", callId); |
| responseMessage->setObject("result", result); |
| if (m_inspectorFrontendChannel) |
| m_inspectorFrontendChannel->sendMessageToFrontend(responseMessage.release()); |
| } |
| |
| void InspectorBackendDispatcher::reportProtocolError(const long* const callId, CommonErrorCode code, const String& errorMessage) const |
| { |
| reportProtocolError(callId, code, errorMessage, PassRefPtr<JSONValue>()); |
| } |
| |
| void InspectorBackendDispatcherImpl::reportProtocolError(const long* const callId, CommonErrorCode code, const String& errorMessage, PassRefPtr<JSONValue> data) const |
| { |
| DEFINE_STATIC_LOCAL(Vector<int>,s_commonErrors,); |
| if (!s_commonErrors.size()) { |
| s_commonErrors.insert(ParseError, -32700); |
| s_commonErrors.insert(InvalidRequest, -32600); |
| s_commonErrors.insert(MethodNotFound, -32601); |
| s_commonErrors.insert(InvalidParams, -32602); |
| s_commonErrors.insert(InternalError, -32603); |
| s_commonErrors.insert(ServerError, -32000); |
| } |
| ASSERT(code >=0); |
| ASSERT((unsigned)code < s_commonErrors.size()); |
| ASSERT(s_commonErrors[code]); |
| RefPtr<JSONObject> error = JSONObject::create(); |
| error->setNumber("code", s_commonErrors[code]); |
| error->setString("message", errorMessage); |
| ASSERT(error); |
| if (data) |
| error->setValue("data", data); |
| RefPtr<JSONObject> message = JSONObject::create(); |
| message->setObject("error", error); |
| if (callId) |
| message->setNumber("id", *callId); |
| else |
| message->setValue("id", JSONValue::null()); |
| if (m_inspectorFrontendChannel) |
| m_inspectorFrontendChannel->sendMessageToFrontend(message.release()); |
| } |
| |
| template<typename R, typename V, typename V0> |
| R InspectorBackendDispatcherImpl::getPropertyValueImpl(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors, V0 initial_value, bool (*as_method)(JSONValue*, V*), const char* type_name) |
| { |
| ASSERT(protocolErrors); |
| |
| if (valueFound) |
| *valueFound = false; |
| |
| V value = initial_value; |
| |
| if (!object) { |
| if (!valueFound) { |
| // Required parameter in missing params container. |
| protocolErrors->pushString(String::format("'params' object must contain required parameter '%s' with type '%s'.", name, type_name)); |
| } |
| return value; |
| } |
| |
| JSONObject::const_iterator end = object->end(); |
| JSONObject::const_iterator valueIterator = object->find(name); |
| |
| if (valueIterator == end) { |
| if (!valueFound) |
| protocolErrors->pushString(String::format("Parameter '%s' with type '%s' was not found.", name, type_name)); |
| return value; |
| } |
| |
| if (!as_method(valueIterator->value.get(), &value)) |
| protocolErrors->pushString(String::format("Parameter '%s' has wrong type. It must be '%s'.", name, type_name)); |
| else |
| if (valueFound) |
| *valueFound = true; |
| return value; |
| } |
| |
| struct AsMethodBridges { |
| static bool asInt(JSONValue* value, int* output) { return value->asNumber(output); } |
| static bool asDouble(JSONValue* value, double* output) { return value->asNumber(output); } |
| static bool asString(JSONValue* value, String* output) { return value->asString(output); } |
| static bool asBoolean(JSONValue* value, bool* output) { return value->asBoolean(output); } |
| static bool asObject(JSONValue* value, RefPtr<JSONObject>* output) { return value->asObject(output); } |
| static bool asArray(JSONValue* value, RefPtr<JSONArray>* output) { return value->asArray(output); } |
| }; |
| |
| int InspectorBackendDispatcherImpl::getInt(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors) |
| { |
| return getPropertyValueImpl<int, int, int>(object, name, valueFound, protocolErrors, 0, AsMethodBridges::asInt, "Number"); |
| } |
| |
| double InspectorBackendDispatcherImpl::getDouble(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors) |
| { |
| return getPropertyValueImpl<double, double, double>(object, name, valueFound, protocolErrors, 0, AsMethodBridges::asDouble, "Number"); |
| } |
| |
| String InspectorBackendDispatcherImpl::getString(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors) |
| { |
| return getPropertyValueImpl<String, String, String>(object, name, valueFound, protocolErrors, "", AsMethodBridges::asString, "String"); |
| } |
| |
| bool InspectorBackendDispatcherImpl::getBoolean(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors) |
| { |
| return getPropertyValueImpl<bool, bool, bool>(object, name, valueFound, protocolErrors, false, AsMethodBridges::asBoolean, "Boolean"); |
| } |
| |
| PassRefPtr<JSONObject> InspectorBackendDispatcherImpl::getObject(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors) |
| { |
| return getPropertyValueImpl<PassRefPtr<JSONObject>, RefPtr<JSONObject>, JSONObject*>(object, name, valueFound, protocolErrors, 0, AsMethodBridges::asObject, "Object"); |
| } |
| |
| PassRefPtr<JSONArray> InspectorBackendDispatcherImpl::getArray(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors) |
| { |
| return getPropertyValueImpl<PassRefPtr<JSONArray>, RefPtr<JSONArray>, JSONArray*>(object, name, valueFound, protocolErrors, 0, AsMethodBridges::asArray, "Array"); |
| } |
| |
| bool InspectorBackendDispatcher::getCommandName(const String& message, String* result) |
| { |
| RefPtr<JSONValue> value = parseJSON(message); |
| if (!value) |
| return false; |
| |
| RefPtr<JSONObject> object = value->asObject(); |
| if (!object) |
| return false; |
| |
| if (!object->getString("method", result)) |
| return false; |
| |
| return true; |
| } |
| |
| InspectorBackendDispatcher::CallbackBase::CallbackBase(PassRefPtrWillBeRawPtr<InspectorBackendDispatcherImpl> backendImpl, int id) |
| : m_backendImpl(backendImpl), m_id(id), m_alreadySent(false) {} |
| |
| InspectorBackendDispatcher::CallbackBase::~CallbackBase() {} |
| |
| void InspectorBackendDispatcher::CallbackBase::trace(Visitor* visitor) |
| { |
| visitor->trace(m_backendImpl); |
| } |
| |
| void InspectorBackendDispatcher::CallbackBase::sendFailure(const ErrorString& error) |
| { |
| ASSERT(error.length()); |
| sendIfActive(nullptr, error, PassRefPtr<JSONValue>()); |
| } |
| |
| bool InspectorBackendDispatcher::CallbackBase::isActive() |
| { |
| return !m_alreadySent && m_backendImpl->isActive(); |
| } |
| |
| void InspectorBackendDispatcher::CallbackBase::sendIfActive(PassRefPtr<JSONObject> partialMessage, const ErrorString& invocationError, PassRefPtr<JSONValue> errorData) |
| { |
| if (m_alreadySent) |
| return; |
| m_backendImpl->sendResponse(m_id, invocationError, errorData, partialMessage); |
| m_alreadySent = true; |
| } |
| |
| } // namespace blink |
| |
| """) |
| |
| frontend_cpp = ( |
| """ |
| |
| #include "config.h" |
| #include "InspectorFrontend.h" |
| |
| #include "core/inspector/InspectorFrontendChannel.h" |
| #include "platform/JSONValues.h" |
| #include "wtf/text/CString.h" |
| #include "wtf/text/WTFString.h" |
| |
| namespace blink { |
| |
| InspectorFrontend::InspectorFrontend(InspectorFrontendChannel* inspectorFrontendChannel) |
| : m_inspectorFrontendChannel(inspectorFrontendChannel) |
| , $constructorInit |
| { |
| } |
| |
| $methods |
| |
| } // namespace blink |
| |
| """) |
| |
| typebuilder_h = ( |
| """ |
| #ifndef InspectorTypeBuilder_h |
| #define InspectorTypeBuilder_h |
| |
| #include "platform/JSONValues.h" |
| #include "wtf/Assertions.h" |
| #include "wtf/PassRefPtr.h" |
| |
| namespace blink { |
| |
| namespace TypeBuilder { |
| |
| template<typename T> |
| class OptOutput { |
| public: |
| OptOutput() : m_assigned(false) { } |
| |
| void operator=(T value) |
| { |
| m_value = value; |
| m_assigned = true; |
| } |
| |
| bool isAssigned() { return m_assigned; } |
| |
| T getValue() |
| { |
| ASSERT(isAssigned()); |
| return m_value; |
| } |
| |
| private: |
| T m_value; |
| bool m_assigned; |
| |
| WTF_MAKE_NONCOPYABLE(OptOutput); |
| }; |
| |
| class RuntimeCastHelper { |
| public: |
| #if $validatorIfdefName |
| template<JSONValue::Type TYPE> |
| static void assertType(JSONValue* value) |
| { |
| ASSERT(value->type() == TYPE); |
| } |
| static void assertAny(JSONValue*); |
| static void assertInt(JSONValue* value); |
| #endif |
| }; |
| |
| |
| // This class provides "Traits" type for the input type T. It is programmed using C++ template specialization |
| // technique. By default it simply takes "ItemTraits" type from T, but it doesn't work with the base types. |
| template<typename T> |
| struct ArrayItemHelper { |
| typedef typename T::ItemTraits Traits; |
| }; |
| |
| template<typename T> |
| class Array : public JSONArrayBase { |
| private: |
| Array() { } |
| |
| JSONArray* openAccessors() { |
| COMPILE_ASSERT(sizeof(JSONArray) == sizeof(Array<T>), cannot_cast); |
| return static_cast<JSONArray*>(static_cast<JSONArrayBase*>(this)); |
| } |
| |
| public: |
| void addItem(PassRefPtr<T> value) |
| { |
| ArrayItemHelper<T>::Traits::pushRefPtr(this->openAccessors(), value); |
| } |
| |
| void addItem(T value) |
| { |
| ArrayItemHelper<T>::Traits::pushRaw(this->openAccessors(), value); |
| } |
| |
| static PassRefPtr<Array<T> > create() |
| { |
| return adoptRef(new Array<T>()); |
| } |
| |
| static PassRefPtr<Array<T> > runtimeCast(PassRefPtr<JSONValue> value) |
| { |
| RefPtr<JSONArray> array; |
| bool castRes = value->asArray(&array); |
| ASSERT_UNUSED(castRes, castRes); |
| #if $validatorIfdefName |
| assertCorrectValue(array.get()); |
| #endif // $validatorIfdefName |
| COMPILE_ASSERT(sizeof(Array<T>) == sizeof(JSONArray), type_cast_problem); |
| return static_cast<Array<T>*>(static_cast<JSONArrayBase*>(array.get())); |
| } |
| |
| void concat(PassRefPtr<Array<T> > array) |
| { |
| return ArrayItemHelper<T>::Traits::concat(this->openAccessors(), array->openAccessors()); |
| } |
| |
| #if $validatorIfdefName |
| static void assertCorrectValue(JSONValue* value) |
| { |
| RefPtr<JSONArray> array; |
| bool castRes = value->asArray(&array); |
| ASSERT_UNUSED(castRes, castRes); |
| for (unsigned i = 0; i < array->length(); i++) |
| ArrayItemHelper<T>::Traits::template assertCorrectValue<T>(array->get(i).get()); |
| } |
| |
| #endif // $validatorIfdefName |
| }; |
| |
| struct StructItemTraits { |
| static void pushRefPtr(JSONArray* array, PassRefPtr<JSONValue> value) |
| { |
| array->pushValue(value); |
| } |
| |
| static void concat(JSONArray* array, JSONArray* anotherArray) |
| { |
| for (JSONArray::iterator it = anotherArray->begin(); it != anotherArray->end(); ++it) |
| array->pushValue(*it); |
| } |
| |
| #if $validatorIfdefName |
| template<typename T> |
| static void assertCorrectValue(JSONValue* value) { |
| T::assertCorrectValue(value); |
| } |
| #endif // $validatorIfdefName |
| }; |
| |
| template<> |
| struct ArrayItemHelper<String> { |
| struct Traits { |
| static void pushRaw(JSONArray* array, const String& value) |
| { |
| array->pushString(value); |
| } |
| |
| #if $validatorIfdefName |
| template<typename T> |
| static void assertCorrectValue(JSONValue* value) { |
| RuntimeCastHelper::assertType<JSONValue::TypeString>(value); |
| } |
| #endif // $validatorIfdefName |
| }; |
| }; |
| |
| template<> |
| struct ArrayItemHelper<int> { |
| struct Traits { |
| static void pushRaw(JSONArray* array, int value) |
| { |
| array->pushInt(value); |
| } |
| |
| #if $validatorIfdefName |
| template<typename T> |
| static void assertCorrectValue(JSONValue* value) { |
| RuntimeCastHelper::assertInt(value); |
| } |
| #endif // $validatorIfdefName |
| }; |
| }; |
| |
| template<> |
| struct ArrayItemHelper<double> { |
| struct Traits { |
| static void pushRaw(JSONArray* array, double value) |
| { |
| array->pushNumber(value); |
| } |
| |
| #if $validatorIfdefName |
| template<typename T> |
| static void assertCorrectValue(JSONValue* value) { |
| RuntimeCastHelper::assertType<JSONValue::TypeNumber>(value); |
| } |
| #endif // $validatorIfdefName |
| }; |
| }; |
| |
| template<> |
| struct ArrayItemHelper<bool> { |
| struct Traits { |
| static void pushRaw(JSONArray* array, bool value) |
| { |
| array->pushBoolean(value); |
| } |
| |
| #if $validatorIfdefName |
| template<typename T> |
| static void assertCorrectValue(JSONValue* value) { |
| RuntimeCastHelper::assertType<JSONValue::TypeBoolean>(value); |
| } |
| #endif // $validatorIfdefName |
| }; |
| }; |
| |
| template<> |
| struct ArrayItemHelper<JSONValue> { |
| struct Traits { |
| static void pushRefPtr(JSONArray* array, PassRefPtr<JSONValue> value) |
| { |
| array->pushValue(value); |
| } |
| |
| #if $validatorIfdefName |
| template<typename T> |
| static void assertCorrectValue(JSONValue* value) { |
| RuntimeCastHelper::assertAny(value); |
| } |
| #endif // $validatorIfdefName |
| }; |
| }; |
| |
| template<> |
| struct ArrayItemHelper<JSONObject> { |
| struct Traits { |
| static void pushRefPtr(JSONArray* array, PassRefPtr<JSONValue> value) |
| { |
| array->pushValue(value); |
| } |
| |
| #if $validatorIfdefName |
| template<typename T> |
| static void assertCorrectValue(JSONValue* value) { |
| RuntimeCastHelper::assertType<JSONValue::TypeObject>(value); |
| } |
| #endif // $validatorIfdefName |
| }; |
| }; |
| |
| template<> |
| struct ArrayItemHelper<JSONArray> { |
| struct Traits { |
| static void pushRefPtr(JSONArray* array, PassRefPtr<JSONArray> value) |
| { |
| array->pushArray(value); |
| } |
| |
| #if $validatorIfdefName |
| template<typename T> |
| static void assertCorrectValue(JSONValue* value) { |
| RuntimeCastHelper::assertType<JSONValue::TypeArray>(value); |
| } |
| #endif // $validatorIfdefName |
| }; |
| }; |
| |
| template<typename T> |
| struct ArrayItemHelper<TypeBuilder::Array<T> > { |
| struct Traits { |
| static void pushRefPtr(JSONArray* array, PassRefPtr<TypeBuilder::Array<T> > value) |
| { |
| array->pushValue(value); |
| } |
| |
| #if $validatorIfdefName |
| template<typename S> |
| static void assertCorrectValue(JSONValue* value) { |
| S::assertCorrectValue(value); |
| } |
| #endif // $validatorIfdefName |
| }; |
| }; |
| |
| ${forwards} |
| |
| String getEnumConstantValue(int code); |
| |
| ${typeBuilders} |
| } // namespace TypeBuilder |
| |
| |
| } // namespace blink |
| |
| #endif // !defined(InspectorTypeBuilder_h) |
| |
| """) |
| |
| typebuilder_cpp = ( |
| """ |
| |
| #include "config.h" |
| |
| #include "InspectorTypeBuilder.h" |
| #include "wtf/text/CString.h" |
| |
| namespace blink { |
| |
| namespace TypeBuilder { |
| |
| const char* const enum_constant_values[] = { |
| $enumConstantValues}; |
| |
| String getEnumConstantValue(int code) { |
| return enum_constant_values[code]; |
| } |
| |
| } // namespace TypeBuilder |
| |
| $implCode |
| |
| #if $validatorIfdefName |
| |
| void TypeBuilder::RuntimeCastHelper::assertAny(JSONValue*) |
| { |
| // No-op. |
| } |
| |
| |
| void TypeBuilder::RuntimeCastHelper::assertInt(JSONValue* value) |
| { |
| double v; |
| bool castRes = value->asNumber(&v); |
| ASSERT_UNUSED(castRes, castRes); |
| ASSERT(static_cast<double>(static_cast<int>(v)) == v); |
| } |
| |
| $validatorCode |
| |
| #endif // $validatorIfdefName |
| |
| } // namespace blink |
| |
| """) |
| |
| param_container_access_code = """ |
| RefPtr<JSONObject> paramsContainer = requestMessageObject->getObject("params"); |
| JSONObject* paramsContainerPtr = paramsContainer.get(); |
| """ |
| |
| class_binding_builder_part_1 = ( |
| """ AllFieldsSet = %s |
| }; |
| |
| template<int STATE> |
| class Builder { |
| private: |
| RefPtr<JSONObject> m_result; |
| |
| template<int STEP> Builder<STATE | STEP>& castState() |
| { |
| return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| } |
| |
| Builder(PassRefPtr</*%s*/JSONObject> 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("%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(JSONObject), 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>(JSONObject::create()); |
| } |
| """) |