Roll IDL to multivm@1316

core/inspector/CodeGeneratorInspectorStrings.py

 # 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
@@ skipping 26 matching lines @@
         InspectorFrontendChannel* getInspectorFrontendChannel() { return m_inspectorFrontendChannel; }
     private:
         InspectorFrontendChannel* m_inspectorFrontendChannel;
     };
 
     $domainClassName* $domainFieldName() { return &m_$domainFieldName; }
 
 """)
 
 backend_method = (
-"""void InspectorBackendDispatcherImpl::${domainName}_$methodName(long callId, InspectorObject*$requestMessageObject)
+"""void InspectorBackendDispatcherImpl::${domainName}_$methodName(long callId, JSONObject*$requestMessageObject)
 {
-    RefPtr<InspectorArray> protocolErrors = InspectorArray::create();
+    RefPtr<JSONArray> protocolErrors = JSONArray::create();
 
     if (!$agentField)
         protocolErrors->pushString("${domainName} handler is not available.");
 $methodOutCode
 $methodInCode
-    RefPtr<InspectorObject> result = InspectorObject::create();
+    RefPtr<JSONObject> result = JSONObject::create();
+    RefPtr<JSONValue> resultErrorData;
     ErrorString error;
     if (!protocolErrors->length()) {
         $agentField->$methodName(&error$agentCallParams);
 
-${responseCook}
+$errorCook${responseCook}
     }
-    sendResponse(callId, result, commandNames[$commandNameIndex], protocolErrors, error);
+    sendResponse(callId, result, commandNames[$commandNameIndex], protocolErrors, error, resultErrorData);
 }
 """)
 
 frontend_method = ("""void InspectorFrontend::$domainName::$eventName($parameters)
 {
-    RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
+    RefPtr<JSONObject> jsonMessage = JSONObject::create();
     jsonMessage->setString("method", "$domainName.$eventName");
 $code    if (m_inspectorFrontendChannel)
         m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage->toJSONString());
 }
 """)
 
-callback_method = (
+callback_main_methods = (
 """InspectorBackendDispatcher::$agentName::$callbackName::$callbackName(PassRefPtr<InspectorBackendDispatcherImpl> backendImpl, int id) : CallbackBase(backendImpl, id) {}
 
 void InspectorBackendDispatcher::$agentName::$callbackName::sendSuccess($parameters)
 {
-    RefPtr<InspectorObject> jsonMessage = InspectorObject::create();
-$code    sendIfActive(jsonMessage, ErrorString());
+    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(0, error, errorDataValue.release());
+}
+""")
+
+
 frontend_h = (
 """#ifndef InspectorFrontend_h
 #define InspectorFrontend_h
 
 #include "InspectorTypeBuilder.h"
-#include "core/inspector/InspectorValues.h"
-#include <wtf/PassRefPtr.h>
-#include <wtf/text/WTFString.h>
+#include "core/platform/JSONValues.h"
+#include "wtf/PassRefPtr.h"
+#include "wtf/text/WTFString.h"
 
 namespace WebCore {
 
 class InspectorFrontendChannel;
 
 typedef String ErrorString;
 
 class InspectorFrontend {
 public:
     InspectorFrontend(InspectorFrontendChannel*);
@@ skipping 13 matching lines @@
 
 #include "InspectorTypeBuilder.h"
 
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefCounted.h>
 #include <wtf/text/WTFString.h>
 
 namespace WebCore {
 
 class InspectorAgent;
-class InspectorObject;
-class InspectorArray;
+class JSONObject;
+class JSONArray;
 class InspectorFrontendChannel;
 
 typedef String ErrorString;
 
 class InspectorBackendDispatcherImpl;
 
 class InspectorBackendDispatcher: public RefCounted<InspectorBackendDispatcher> {
 public:
     static PassRefPtr<InspectorBackendDispatcher> create(InspectorFrontendChannel* inspectorFrontendChannel);
     virtual ~InspectorBackendDispatcher() { }
 
     class CallbackBase: public RefCounted<CallbackBase> {
     public:
         CallbackBase(PassRefPtr<InspectorBackendDispatcherImpl> backendImpl, int id);
         virtual ~CallbackBase();
         void sendFailure(const ErrorString&);
         bool isActive();
 
     protected:
-        void sendIfActive(PassRefPtr<InspectorObject> partialMessage, const ErrorString& invocationError);
+        void sendIfActive(PassRefPtr<JSONObject> partialMessage, const ErrorString& invocationError, PassRefPtr<JSONValue> errorData);
 
     private:
         void disable() { m_alreadySent = true; }
 
         RefPtr<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<InspectorArray> data) const = 0;
+    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* commandNames[];
 };
 
 } // namespace WebCore
 #endif // !defined(InspectorBackendDispatcher_h)
 
 
 """)
 
 backend_cpp = (
 """
 
 #include "config.h"
 #include "InspectorBackendDispatcher.h"
 
-
 #include "core/inspector/InspectorAgent.h"
 #include "core/inspector/InspectorFrontendChannel.h"
-#include "core/inspector/InspectorValues.h"
-#include <wtf/text/CString.h>
-#include <wtf/text/WTFString.h>
+#include "core/inspector/JSONParser.h"
+#include "core/platform/JSONValues.h"
+#include "wtf/text/CString.h"
+#include "wtf/text/WTFString.h"
 
 namespace WebCore {
 
 const char* InspectorBackendDispatcher::commandNames[] = {
 $methodNameDeclarations
 };
 
 
 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<InspectorArray> data) const;
+    virtual void reportProtocolError(const long* const callId, CommonErrorCode, const String& errorMessage, PassRefPtr<JSONValue> data) const;
     using InspectorBackendDispatcher::reportProtocolError;
 
-    void sendResponse(long callId, PassRefPtr<InspectorObject> result, const ErrorString& invocationError);
+    void sendResponse(long callId, PassRefPtr<JSONObject> result, const ErrorString&invocationError, PassRefPtr<JSONValue> errorData);
     bool isActive() { return m_inspectorFrontendChannel; }
 
 $setters
 private:
 $methodDeclarations
 
     InspectorFrontendChannel* m_inspectorFrontendChannel;
 $fieldDeclarations
 
     template<typename R, typename V, typename V0>
-    static R getPropertyValueImpl(InspectorObject* object, const String& name, bool* valueFound, InspectorArray* protocolErrors, V0 initial_value, bool (*as_method)(InspectorValue*, V*), const char* type_name);
+    static R getPropertyValueImpl(JSONObject* object, const String& name, bool* valueFound, JSONArray* protocolErrors, V0 initial_value, bool (*as_method)(JSONValue*, V*), const char* type_name);
 
-    static int getInt(InspectorObject* object, const String& name, bool* valueFound, InspectorArray* protocolErrors);
-    static double getDouble(InspectorObject* object, const String& name, bool* valueFound, InspectorArray* protocolErrors);
-    static String getString(InspectorObject* object, const String& name, bool* valueFound, InspectorArray* protocolErrors);
-    static bool getBoolean(InspectorObject* object, const String& name, bool* valueFound, InspectorArray* protocolErrors);
-    static PassRefPtr<InspectorObject> getObject(InspectorObject* object, const String& name, bool* valueFound, InspectorArray* protocolErrors);
-    static PassRefPtr<InspectorArray> getArray(InspectorObject* object, const String& name, bool* valueFound, InspectorArray* protocolErrors);
+    static int getInt(JSONObject* object, const String& name, bool* valueFound, JSONArray* protocolErrors);
+    static double getDouble(JSONObject* object, const String& name, bool* valueFound, JSONArray* protocolErrors);
+    static String getString(JSONObject* object, const String& name, bool* valueFound, JSONArray* protocolErrors);
+    static bool getBoolean(JSONObject* object, const String& name, bool* valueFound, JSONArray* protocolErrors);
+    static PassRefPtr<JSONObject> getObject(JSONObject* object, const String& name, bool* valueFound, JSONArray* protocolErrors);
+    static PassRefPtr<JSONArray> getArray(JSONObject* object, const String& name, bool* valueFound, JSONArray* protocolErrors);
 
-    void sendResponse(long callId, PassRefPtr<InspectorObject> result, const char* commandName, PassRefPtr<InspectorArray> protocolErrors, ErrorString invocationError);
+    void sendResponse(long callId, PassRefPtr<JSONObject> result, const char* commandName, PassRefPtr<JSONArray> protocolErrors, ErrorString invocationError, PassRefPtr<JSONValue> errorData);
 
 };
 
 $methods
 
 PassRefPtr<InspectorBackendDispatcher> InspectorBackendDispatcher::create(InspectorFrontendChannel* inspectorFrontendChannel)
 {
     return adoptRef(new InspectorBackendDispatcherImpl(inspectorFrontendChannel));
 }
 
 
 void InspectorBackendDispatcherImpl::dispatch(const String& message)
 {
     RefPtr<InspectorBackendDispatcher> protect = this;
-    typedef void (InspectorBackendDispatcherImpl::*CallHandler)(long callId, InspectorObject* messageObject);
+    typedef void (InspectorBackendDispatcherImpl::*CallHandler)(long callId, JSONObject* messageObject);
     typedef HashMap<String, CallHandler> DispatchMap;
     DEFINE_STATIC_LOCAL(DispatchMap, dispatchMap, );
     long callId = 0;
 
     if (dispatchMap.isEmpty()) {
         static CallHandler handlers[] = {
 $messageHandlers
         };
         size_t length = WTF_ARRAY_LENGTH(commandNames);
         for (size_t i = 0; i < length; ++i)
             dispatchMap.add(commandNames[i], handlers[i]);
     }
 
-    RefPtr<InspectorValue> parsedMessage = InspectorValue::parseJSON(message);
+    RefPtr<JSONValue> parsedMessage = parseJSON(message);
     if (!parsedMessage) {
         reportProtocolError(0, ParseError, "Message must be in JSON format");
         return;
     }
 
-    RefPtr<InspectorObject> messageObject = parsedMessage->asObject();
+    RefPtr<JSONObject> messageObject = parsedMessage->asObject();
     if (!messageObject) {
         reportProtocolError(0, InvalidRequest, "Message must be a JSONified object");
         return;
     }
 
-    RefPtr<InspectorValue> callIdValue = messageObject->get("id");
+    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<InspectorValue> methodValue = messageObject->get("method");
+    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;
     }
 
     ((*this).*it->value)(callId, messageObject.get());
 }
 
-void InspectorBackendDispatcherImpl::sendResponse(long callId, PassRefPtr<InspectorObject> result, const char* commandName, PassRefPtr<InspectorArray> protocolErrors, ErrorString invocationError)
+void InspectorBackendDispatcherImpl::sendResponse(long callId, PassRefPtr<JSONObject> result, const char* commandName, PassRefPtr<JSONArray> protocolErrors, ErrorString invocationError, PassRefPtr<JSONValue> errorData)
 {
     if (protocolErrors->length()) {
         String errorMessage = String::format("Some arguments of method '%s' can't be processed", commandName);
         reportProtocolError(&callId, InvalidParams, errorMessage, protocolErrors);
         return;
     }
-    sendResponse(callId, result, invocationError);
+    sendResponse(callId, result, invocationError, errorData);
 }
 
-void InspectorBackendDispatcherImpl::sendResponse(long callId, PassRefPtr<InspectorObject> result, const ErrorString& invocationError)
+void InspectorBackendDispatcherImpl::sendResponse(long callId, PassRefPtr<JSONObject> result, const ErrorString& invocationError, PassRefPtr<JSONValue> errorData)
 {
     if (invocationError.length()) {
-        reportProtocolError(&callId, ServerError, invocationError);
+        reportProtocolError(&callId, ServerError, invocationError, errorData);
         return;
     }
 
-    RefPtr<InspectorObject> responseMessage = InspectorObject::create();
+    RefPtr<JSONObject> responseMessage = JSONObject::create();
     responseMessage->setObject("result", result);
     responseMessage->setNumber("id", callId);
     if (m_inspectorFrontendChannel)
         m_inspectorFrontendChannel->sendMessageToFrontend(responseMessage->toJSONString());
 }
 
 void InspectorBackendDispatcher::reportProtocolError(const long* const callId, CommonErrorCode code, const String& errorMessage) const
 {
-    reportProtocolError(callId, code, errorMessage, 0);
+    reportProtocolError(callId, code, errorMessage, PassRefPtr<JSONValue>());
 }
 
-void InspectorBackendDispatcherImpl::reportProtocolError(const long* const callId, CommonErrorCode code, const String& errorMessage, PassRefPtr<InspectorArray> data) const
+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<InspectorObject> error = InspectorObject::create();
+    RefPtr<JSONObject> error = JSONObject::create();
     error->setNumber("code", s_commonErrors[code]);
     error->setString("message", errorMessage);
     ASSERT(error);
     if (data)
-        error->setArray("data", data);
-    RefPtr<InspectorObject> message = InspectorObject::create();
+        error->setValue("data", data);
+    RefPtr<JSONObject> message = JSONObject::create();
     message->setObject("error", error);
     if (callId)
         message->setNumber("id", *callId);
     else
-        message->setValue("id", InspectorValue::null());
+        message->setValue("id", JSONValue::null());
     if (m_inspectorFrontendChannel)
         m_inspectorFrontendChannel->sendMessageToFrontend(message->toJSONString());
 }
 
 template<typename R, typename V, typename V0>
-R InspectorBackendDispatcherImpl::getPropertyValueImpl(InspectorObject* object, const String& name, bool* valueFound, InspectorArray* protocolErrors, V0 initial_value, bool (*as_method)(InspectorValue*, V*), const char* type_name)
+R InspectorBackendDispatcherImpl::getPropertyValueImpl(JSONObject* object, const String& 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.utf8().data(), type_name));
         }
         return value;
     }
 
-    InspectorObject::const_iterator end = object->end();
-    InspectorObject::const_iterator valueIterator = object->find(name);
+    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.utf8().data(), 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.utf8().data(), type_name));
     else
         if (valueFound)
             *valueFound = true;
     return value;
 }
 
 struct AsMethodBridges {
-    static bool asInt(InspectorValue* value, int* output) { return value->asNumber(output); }
-    static bool asDouble(InspectorValue* value, double* output) { return value->asNumber(output); }
-    static bool asString(InspectorValue* value, String* output) { return value->asString(output); }
-    static bool asBoolean(InspectorValue* value, bool* output) { return value->asBoolean(output); }
-    static bool asObject(InspectorValue* value, RefPtr<InspectorObject>* output) { return value->asObject(output); }
-    static bool asArray(InspectorValue* value, RefPtr<InspectorArray>* output) { return value->asArray(output); }
+    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(InspectorObject* object, const String& name, bool* valueFound, InspectorArray* protocolErrors)
+int InspectorBackendDispatcherImpl::getInt(JSONObject* object, const String& name, bool* valueFound, JSONArray* protocolErrors)
 {
     return getPropertyValueImpl<int, int, int>(object, name, valueFound, protocolErrors, 0, AsMethodBridges::asInt, "Number");
 }
 
-double InspectorBackendDispatcherImpl::getDouble(InspectorObject* object, const String& name, bool* valueFound, InspectorArray* protocolErrors)
+double InspectorBackendDispatcherImpl::getDouble(JSONObject* object, const String& name, bool* valueFound, JSONArray* protocolErrors)
 {
     return getPropertyValueImpl<double, double, double>(object, name, valueFound, protocolErrors, 0, AsMethodBridges::asDouble, "Number");
 }
 
-String InspectorBackendDispatcherImpl::getString(InspectorObject* object, const String& name, bool* valueFound, InspectorArray* protocolErrors)
+String InspectorBackendDispatcherImpl::getString(JSONObject* object, const String& name, bool* valueFound, JSONArray* protocolErrors)
 {
     return getPropertyValueImpl<String, String, String>(object, name, valueFound, protocolErrors, "", AsMethodBridges::asString, "String");
 }
 
-bool InspectorBackendDispatcherImpl::getBoolean(InspectorObject* object, const String& name, bool* valueFound, InspectorArray* protocolErrors)
+bool InspectorBackendDispatcherImpl::getBoolean(JSONObject* object, const String& name, bool* valueFound, JSONArray* protocolErrors)
 {
     return getPropertyValueImpl<bool, bool, bool>(object, name, valueFound, protocolErrors, false, AsMethodBridges::asBoolean, "Boolean");
 }
 
-PassRefPtr<InspectorObject> InspectorBackendDispatcherImpl::getObject(InspectorObject* object, const String& name, bool* valueFound, InspectorArray* protocolErrors)
+PassRefPtr<JSONObject> InspectorBackendDispatcherImpl::getObject(JSONObject* object, const String& name, bool* valueFound, JSONArray* protocolErrors)
 {
-    return getPropertyValueImpl<PassRefPtr<InspectorObject>, RefPtr<InspectorObject>, InspectorObject*>(object, name, valueFound, protocolErrors, 0, AsMethodBridges::asObject, "Object");
+    return getPropertyValueImpl<PassRefPtr<JSONObject>, RefPtr<JSONObject>, JSONObject*>(object, name, valueFound, protocolErrors, 0, AsMethodBridges::asObject, "Object");
 }
 
-PassRefPtr<InspectorArray> InspectorBackendDispatcherImpl::getArray(InspectorObject* object, const String& name, bool* valueFound, InspectorArray* protocolErrors)
+PassRefPtr<JSONArray> InspectorBackendDispatcherImpl::getArray(JSONObject* object, const String& name, bool* valueFound, JSONArray* protocolErrors)
 {
-    return getPropertyValueImpl<PassRefPtr<InspectorArray>, RefPtr<InspectorArray>, InspectorArray*>(object, name, valueFound, protocolErrors, 0, AsMethodBridges::asArray, "Array");
+    return getPropertyValueImpl<PassRefPtr<JSONArray>, RefPtr<JSONArray>, JSONArray*>(object, name, valueFound, protocolErrors, 0, AsMethodBridges::asArray, "Array");
 }
 
 bool InspectorBackendDispatcher::getCommandName(const String& message, String* result)
 {
-    RefPtr<InspectorValue> value = InspectorValue::parseJSON(message);
+    RefPtr<JSONValue> value = parseJSON(message);
     if (!value)
         return false;
 
-    RefPtr<InspectorObject> object = value->asObject();
+    RefPtr<JSONObject> object = value->asObject();
     if (!object)
         return false;
 
     if (!object->getString("method", result))
         return false;
 
     return true;
 }
 
 InspectorBackendDispatcher::CallbackBase::CallbackBase(PassRefPtr<InspectorBackendDispatcherImpl> backendImpl, int id)
     : m_backendImpl(backendImpl), m_id(id), m_alreadySent(false) {}
 
 InspectorBackendDispatcher::CallbackBase::~CallbackBase() {}
 
 void InspectorBackendDispatcher::CallbackBase::sendFailure(const ErrorString& error)
 {
     ASSERT(error.length());
-    sendIfActive(0, error);
+    sendIfActive(0, error, PassRefPtr<JSONValue>());
 }
 
 bool InspectorBackendDispatcher::CallbackBase::isActive()
 {
     return !m_alreadySent && m_backendImpl->isActive();
 }
 
-void InspectorBackendDispatcher::CallbackBase::sendIfActive(PassRefPtr<InspectorObject> partialMessage, const ErrorString& invocationError)
+void InspectorBackendDispatcher::CallbackBase::sendIfActive(PassRefPtr<JSONObject> partialMessage, const ErrorString& invocationError, PassRefPtr<JSONValue> errorData)
 {
     if (m_alreadySent)
         return;
-    m_backendImpl->sendResponse(m_id, partialMessage, invocationError);
+    m_backendImpl->sendResponse(m_id, partialMessage, invocationError, errorData);
     m_alreadySent = true;
 }
 
 COMPILE_ASSERT(static_cast<int>(InspectorBackendDispatcher::kMethodNamesEnumSize) == WTF_ARRAY_LENGTH(InspectorBackendDispatcher::commandNames), command_name_array_problem);
 
 } // namespace WebCore
 
 """)
 
 frontend_cpp = (
 """
 
 #include "config.h"
+#include "InspectorFrontend.h"
 
-#include "InspectorFrontend.h"
 #include "core/inspector/InspectorFrontendChannel.h"
-#include "core/inspector/InspectorValues.h"
-
-#include <wtf/text/CString.h>
-#include <wtf/text/WTFString.h>
+#include "core/platform/JSONValues.h"
+#include "wtf/text/CString.h"
+#include "wtf/text/WTFString.h"
 
 namespace WebCore {
 
 InspectorFrontend::InspectorFrontend(InspectorFrontendChannel* inspectorFrontendChannel)
     : $constructorInit{
 }
 
 $methods
 
 } // namespace WebCore
 
 """)
 
 typebuilder_h = (
 """
 #ifndef InspectorTypeBuilder_h
 #define InspectorTypeBuilder_h
 
-#include "core/inspector/InspectorValues.h"
-
-#include <wtf/Assertions.h>
-#include <wtf/PassRefPtr.h>
+#include "core/platform/JSONValues.h"
+#include "wtf/Assertions.h"
+#include "wtf/PassRefPtr.h"
 
 namespace WebCore {
 
 namespace TypeBuilder {
 
 template<typename T>
 class OptOutput {
 public:
     OptOutput() : m_assigned(false) { }
 
@@ skipping 38 matching lines @@
 
 template<>
 inline int ExactlyInt::cast_to_int<int>(int i) { return i; }
 
 template<>
 inline int ExactlyInt::cast_to_int<unsigned int>(unsigned int i) { return i; }
 
 class RuntimeCastHelper {
 public:
 #if $validatorIfdefName
-    template<InspectorValue::Type TYPE>
-    static void assertType(InspectorValue* value)
+    template<JSONValue::Type TYPE>
+    static void assertType(JSONValue* value)
     {
         ASSERT(value->type() == TYPE);
     }
-    static void assertAny(InspectorValue*);
-    static void assertInt(InspectorValue* value);
+    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 InspectorArrayBase {
+class Array : public JSONArrayBase {
 private:
     Array() { }
 
-    InspectorArray* openAccessors() {
-        COMPILE_ASSERT(sizeof(InspectorArray) == sizeof(Array<T>), cannot_cast);
-        return static_cast<InspectorArray*>(static_cast<InspectorArrayBase*>(this));
+    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<InspectorValue> value)
+    static PassRefPtr<Array<T> > runtimeCast(PassRefPtr<JSONValue> value)
     {
-        RefPtr<InspectorArray> array;
+        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(InspectorArray), type_cast_problem);
-        return static_cast<Array<T>*>(static_cast<InspectorArrayBase*>(array.get()));
+        COMPILE_ASSERT(sizeof(Array<T>) == sizeof(JSONArray), type_cast_problem);
+        return static_cast<Array<T>*>(static_cast<JSONArrayBase*>(array.get()));
     }
 
 #if $validatorIfdefName
-    static void assertCorrectValue(InspectorValue* value)
+    static void assertCorrectValue(JSONValue* value)
     {
-        RefPtr<InspectorArray> array;
+        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(InspectorArray* array, PassRefPtr<InspectorValue> value)
+    static void pushRefPtr(JSONArray* array, PassRefPtr<JSONValue> value)
     {
         array->pushValue(value);
     }
 
 #if $validatorIfdefName
     template<typename T>
-    static void assertCorrectValue(InspectorValue* value) {
+    static void assertCorrectValue(JSONValue* value) {
         T::assertCorrectValue(value);
     }
 #endif  // $validatorIfdefName
 };
 
 template<>
 struct ArrayItemHelper<String> {
     struct Traits {
-        static void pushRaw(InspectorArray* array, const String& value)
+        static void pushRaw(JSONArray* array, const String& value)
         {
             array->pushString(value);
         }
 
 #if $validatorIfdefName
         template<typename T>
-        static void assertCorrectValue(InspectorValue* value) {
-            RuntimeCastHelper::assertType<InspectorValue::TypeString>(value);
+        static void assertCorrectValue(JSONValue* value) {
+            RuntimeCastHelper::assertType<JSONValue::TypeString>(value);
         }
 #endif  // $validatorIfdefName
     };
 };
 
 template<>
 struct ArrayItemHelper<int> {
     struct Traits {
-        static void pushRaw(InspectorArray* array, int value)
+        static void pushRaw(JSONArray* array, int value)
         {
             array->pushInt(value);
         }
 
 #if $validatorIfdefName
         template<typename T>
-        static void assertCorrectValue(InspectorValue* value) {
+        static void assertCorrectValue(JSONValue* value) {
             RuntimeCastHelper::assertInt(value);
         }
 #endif  // $validatorIfdefName
     };
 };
 
 template<>
 struct ArrayItemHelper<double> {
     struct Traits {
-        static void pushRaw(InspectorArray* array, double value)
+        static void pushRaw(JSONArray* array, double value)
         {
             array->pushNumber(value);
         }
 
 #if $validatorIfdefName
         template<typename T>
-        static void assertCorrectValue(InspectorValue* value) {
-            RuntimeCastHelper::assertType<InspectorValue::TypeNumber>(value);
+        static void assertCorrectValue(JSONValue* value) {
+            RuntimeCastHelper::assertType<JSONValue::TypeNumber>(value);
         }
 #endif  // $validatorIfdefName
     };
 };
 
 template<>
 struct ArrayItemHelper<bool> {
     struct Traits {
-        static void pushRaw(InspectorArray* array, bool value)
+        static void pushRaw(JSONArray* array, bool value)
         {
             array->pushBoolean(value);
         }
 
 #if $validatorIfdefName
         template<typename T>
-        static void assertCorrectValue(InspectorValue* value) {
-            RuntimeCastHelper::assertType<InspectorValue::TypeBoolean>(value);
+        static void assertCorrectValue(JSONValue* value) {
+            RuntimeCastHelper::assertType<JSONValue::TypeBoolean>(value);
         }
 #endif  // $validatorIfdefName
     };
 };
 
 template<>
-struct ArrayItemHelper<InspectorValue> {
+struct ArrayItemHelper<JSONValue> {
     struct Traits {
-        static void pushRefPtr(InspectorArray* array, PassRefPtr<InspectorValue> value)
+        static void pushRefPtr(JSONArray* array, PassRefPtr<JSONValue> value)
         {
             array->pushValue(value);
         }
 
 #if $validatorIfdefName
         template<typename T>
-        static void assertCorrectValue(InspectorValue* value) {
+        static void assertCorrectValue(JSONValue* value) {
             RuntimeCastHelper::assertAny(value);
         }
 #endif  // $validatorIfdefName
     };
 };
 
 template<>
-struct ArrayItemHelper<InspectorObject> {
+struct ArrayItemHelper<JSONObject> {
     struct Traits {
-        static void pushRefPtr(InspectorArray* array, PassRefPtr<InspectorValue> value)
+        static void pushRefPtr(JSONArray* array, PassRefPtr<JSONValue> value)
         {
             array->pushValue(value);
         }
 
 #if $validatorIfdefName
         template<typename T>
-        static void assertCorrectValue(InspectorValue* value) {
-            RuntimeCastHelper::assertType<InspectorValue::TypeObject>(value);
+        static void assertCorrectValue(JSONValue* value) {
+            RuntimeCastHelper::assertType<JSONValue::TypeObject>(value);
         }
 #endif  // $validatorIfdefName
     };
 };
 
 template<>
-struct ArrayItemHelper<InspectorArray> {
+struct ArrayItemHelper<JSONArray> {
     struct Traits {
-        static void pushRefPtr(InspectorArray* array, PassRefPtr<InspectorArray> value)
+        static void pushRefPtr(JSONArray* array, PassRefPtr<JSONArray> value)
         {
             array->pushArray(value);
         }
 
 #if $validatorIfdefName
         template<typename T>
-        static void assertCorrectValue(InspectorValue* value) {
-            RuntimeCastHelper::assertType<InspectorValue::TypeArray>(value);
+        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(InspectorArray* array, PassRefPtr<TypeBuilder::Array<T> > value)
+        static void pushRefPtr(JSONArray* array, PassRefPtr<TypeBuilder::Array<T> > value)
         {
             array->pushValue(value);
         }
 
 #if $validatorIfdefName
         template<typename S>
-        static void assertCorrectValue(InspectorValue* value) {
+        static void assertCorrectValue(JSONValue* value) {
             S::assertCorrectValue(value);
         }
 #endif  // $validatorIfdefName
     };
 };
 
 ${forwards}
 
 String getEnumConstantValue(int code);
 
 ${typeBuilders}
 } // namespace TypeBuilder
 
 
 } // namespace WebCore
 
 #endif // !defined(InspectorTypeBuilder_h)
 
 """)
 
 typebuilder_cpp = (
 """
 
 #include "config.h"
 
 #include "InspectorTypeBuilder.h"
-
-#include <wtf/text/CString.h>
+#include "wtf/text/CString.h"
 
 namespace WebCore {
 
 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(InspectorValue*)
+void TypeBuilder::RuntimeCastHelper::assertAny(JSONValue*)
 {
     // No-op.
 }
 
 
-void TypeBuilder::RuntimeCastHelper::assertInt(InspectorValue* value)
+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 WebCore
 
 """)
 
 param_container_access_code = """
-    RefPtr<InspectorObject> paramsContainer = requestMessageObject->getObject("params");
-    InspectorObject* paramsContainerPtr = paramsContainer.get();
-    InspectorArray* protocolErrorsPtr = protocolErrors.get();
+    RefPtr<JSONObject> paramsContainer = requestMessageObject->getObject("params");
+    JSONObject* paramsContainerPtr = paramsContainer.get();
+    JSONArray* protocolErrorsPtr = protocolErrors.get();
 """
 
 class_binding_builder_part_1 = (
 """        AllFieldsSet = %s
     };
 
     template<int STATE>
     class Builder {
     private:
-        RefPtr<InspectorObject> m_result;
+        RefPtr<JSONObject> m_result;
 
         template<int STEP> Builder<STATE | STEP>& castState()
         {
             return *reinterpret_cast<Builder<STATE | STEP>*>(this);
         }
 
-        Builder(PassRefPtr</*%s*/InspectorObject> ptr)
+        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(InspectorObject), cannot_cast);
+            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>(InspectorObject::create());
+        return Builder<NoFieldsSet>(JSONObject::create());
     }
 """)