Roll IDL to multivm@1316

core/inspector/CodeGeneratorInspectorStrings.py

Index: core/inspector/CodeGeneratorInspectorStrings.py
diff --git a/core/inspector/CodeGeneratorInspectorStrings.py b/core/inspector/CodeGeneratorInspectorStrings.py
index 6c3fe05a1f087c9cde2e101d1808da175b533a5a..8759b2fe9ad806f133e2f9871ee95ab46812c63f 100644
--- a/core/inspector/CodeGeneratorInspectorStrings.py
+++ b/core/inspector/CodeGeneratorInspectorStrings.py
@@ -44,52 +44,66 @@ ${frontendDomainMethodDeclarations}        void setInspectorFrontendChannel(Insp
 """)
 
 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 {
 
@@ -123,8 +137,8 @@ backend_h = (
 namespace WebCore {
 
 class InspectorAgent;
-class InspectorObject;
-class InspectorArray;
+class JSONObject;
+class JSONArray;
 class InspectorFrontendChannel;
 
 typedef String ErrorString;
@@ -144,7 +158,7 @@ public:
         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; }
@@ -172,7 +186,7 @@ $virtualSetters
     };
 
     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);
 
@@ -197,12 +211,12 @@ 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 {
 
@@ -220,10 +234,10 @@ $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
@@ -234,16 +248,16 @@ $methodDeclarations
 $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);
 
 };
 
@@ -258,7 +272,7 @@ PassRefPtr<InspectorBackendDispatcher> InspectorBackendDispatcher::create(Inspec
 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;
@@ -272,19 +286,19 @@ $messageHandlers
             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;
@@ -295,7 +309,7 @@ $messageHandlers
         return;
     }
 
-    RefPtr<InspectorValue> methodValue = messageObject->get("method");
+    RefPtr<JSONValue> methodValue = messageObject->get("method");
     if (!methodValue) {
         reportProtocolError(&callId, InvalidRequest, "'method' property wasn't found");
         return;
@@ -316,24 +330,24 @@ $messageHandlers
     ((*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)
@@ -342,10 +356,10 @@ void InspectorBackendDispatcherImpl::sendResponse(long callId, PassRefPtr<Inspec
 
 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()) {
@@ -359,24 +373,24 @@ void InspectorBackendDispatcherImpl::reportProtocolError(const long* const callI
     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);
 
@@ -393,8 +407,8 @@ R InspectorBackendDispatcherImpl::getPropertyValueImpl(InspectorObject* object,
         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)
@@ -411,51 +425,51 @@ R InspectorBackendDispatcherImpl::getPropertyValueImpl(InspectorObject* object,
 }
 
 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;
 
@@ -473,7 +487,7 @@ 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()
@@ -481,11 +495,11 @@ 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;
 }
 
@@ -499,13 +513,12 @@ frontend_cpp = (
 """
 
 #include "config.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/inspector/InspectorFrontendChannel.h"
+#include "core/platform/JSONValues.h"
+#include "wtf/text/CString.h"
+#include "wtf/text/WTFString.h"
 
 namespace WebCore {
 
@@ -524,10 +537,9 @@ 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 {
 
@@ -586,13 +598,13 @@ 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
 };
 
@@ -605,13 +617,13 @@ struct ArrayItemHelper {
 };
 
 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:
@@ -630,22 +642,22 @@ public:
         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++)
@@ -656,14 +668,14 @@ public:
 };
 
 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
@@ -672,15 +684,15 @@ struct StructItemTraits {
 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
     };
@@ -689,14 +701,14 @@ struct ArrayItemHelper<String> {
 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
@@ -706,15 +718,15 @@ struct ArrayItemHelper<int> {
 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
     };
@@ -723,31 +735,31 @@ struct ArrayItemHelper<double> {
 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
@@ -755,34 +767,34 @@ struct ArrayItemHelper<InspectorValue> {
 };
 
 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
     };
@@ -791,14 +803,14 @@ struct ArrayItemHelper<InspectorArray> {
 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
@@ -825,8 +837,7 @@ typebuilder_cpp = (
 #include "config.h"
 
 #include "InspectorTypeBuilder.h"
-
-#include <wtf/text/CString.h>
+#include "wtf/text/CString.h"
 
 namespace WebCore {
 
@@ -845,13 +856,13 @@ $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);
@@ -868,9 +879,9 @@ $validatorCode
 """)
 
 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 = (
@@ -880,14 +891,14 @@ class_binding_builder_part_1 = (
     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;
@@ -909,7 +920,7 @@ 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);
         }
 
@@ -924,6 +935,6 @@ class_binding_builder_part_3 = ("""
 class_binding_builder_part_4 = (
 """    static Builder<NoFieldsSet> create()
     {
-        return Builder<NoFieldsSet>(InspectorObject::create());
+        return Builder<NoFieldsSet>(JSONObject::create());
     }
 """)