DevTools: simplify JSONValues API, prepare to the OwnPtr migration.

third_party/WebKit/Source/platform/inspector_protocol/Dispatcher_cpp.template

 // This file is generated
 
 // Copyright (c) 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/inspector_protocol/{{class_name}}.h"
 
 #include "platform/JSONParser.h"
 #include "platform/inspector_protocol/FrontendChannel.h"
@@ skipping 53 matching lines @@
   {% endfor %}
 {% endfor %}
 
     FrontendChannel* m_frontendChannel;
 
 {% for domain in api.domains %}
     {{domain.domain}}CommandHandler* m_{{domain.domain | lower}}Agent;
 {% endfor %}
 
     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 R getPropertyValueImpl(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors, V0 initial_value, bool (*as_method)(PassRefPtr<JSONValue>, V*), const char* type_name);
 
     static Maybe<int> getInteger(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors);
     static Maybe<double> getNumber(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors);
     static Maybe<String> getString(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors);
     static Maybe<bool> getBoolean(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors);
     static PassRefPtr<JSONObject> getObject(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors);
     static PassRefPtr<JSONArray> getArray(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors);
 
     void sendResponse(int sessionId, int callId, ErrorString invocationError, PassRefPtr<JSONObject> result)
     {
@@ skipping 120 matching lines @@
 {
     return adoptRef(new DispatcherImpl(frontendChannel));
 }
 
 void DispatcherImpl::dispatch(int sessionId, const String& message)
 {
     RefPtr<Dispatcher> protect(this);
     int callId = 0;
     RefPtr<JSONValue> parsedMessage = parseJSON(message);
     ASSERT(parsedMessage);
-    RefPtr<JSONObject> messageObject = parsedMessage->asObject();
+    RefPtr<JSONObject> messageObject = JSONObject::cast(parsedMessage.release());
     ASSERT(messageObject);
 
     RefPtr<JSONValue> callIdValue = messageObject->get("id");
     bool success = callIdValue->asNumber(&callId);
     ASSERT_UNUSED(success, success);
 
     RefPtr<JSONValue> methodValue = messageObject->get("method");
     String method;
     success = methodValue && methodValue->asString(&method);
     ASSERT_UNUSED(success, success);
@@ skipping 39 matching lines @@
     if (data)
         error->setValue("data", data);
     RefPtr<JSONObject> message = JSONObject::create();
     message->setObject("error", error);
     message->setNumber("id", callId);
     if (m_frontendChannel)
         m_frontendChannel->sendProtocolResponse(sessionId, callId, message.release());
 }
 
 template<typename R, typename V, typename V0>
-R DispatcherImpl::getPropertyValueImpl(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors, V0 initial_value, bool (*as_method)(JSONValue*, V*), const char* type_name)
+R DispatcherImpl::getPropertyValueImpl(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors, V0 initial_value, bool (*as_method)(PassRefPtr<JSONValue>, V*), const char* type_name)
 {
     ASSERT(protocolErrors);
 
     if (valueFound)
         *valueFound = false;
 
     V value = initial_value;
 
     if (!object) {
         if (!valueFound) {
@@ skipping 14 matching lines @@
 
     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 asInteger(JSONValue* value, int* output) { return value->asNumber(output); }
-    static bool asNumber(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); }
+    static bool asInteger(PassRefPtr<JSONValue> value, int* output) { return value->asNumber(output); }
+    static bool asNumber(PassRefPtr<JSONValue> value, double* output) { return value->asNumber(output); }
+    static bool asString(PassRefPtr<JSONValue> value, String* output) { return value->asString(output); }
+    static bool asBoolean(PassRefPtr<JSONValue> value, bool* output) { return value->asBoolean(output); }
+    static bool asObject(PassRefPtr<JSONValue> value, RefPtr<JSONObject>* output) { *output = JSONObject::cast(value); return *output; }
+    static bool asArray(PassRefPtr<JSONValue> value, RefPtr<JSONArray>* output) { *output = JSONArray::cast(value); return *output; }
 };
 
 Maybe<int> DispatcherImpl::getInteger(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors)
 {
     bool valueFound = false;
     int result = getPropertyValueImpl<int, int, int>(object, name, isOptional ? &valueFound : 0, protocolErrors, 0, AsMethodBridges::asInteger, "Number");
     return valueFound || !isOptional ? Maybe<int>(result) : Maybe<int>();
 }
 
 Maybe<double> DispatcherImpl::getNumber(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors)
@@ skipping 28 matching lines @@
     bool valueFound = false;
     return getPropertyValueImpl<PassRefPtr<JSONArray>, RefPtr<JSONArray>, JSONArray*>(object, name, isOptional ? &valueFound : 0, protocolErrors, 0, AsMethodBridges::asArray, "Array");
 }
 
 bool Dispatcher::getCommandName(const String& message, String* result)
 {
     RefPtr<JSONValue> value = parseJSON(message);
     if (!value)
         return false;
 
-    RefPtr<JSONObject> object = value->asObject();
+    RefPtr<JSONObject> object = JSONObject::cast(value.release());
     if (!object)
         return false;
 
     if (!object->getString("method", result))
         return false;
 
     return true;
 }
 
 Dispatcher::CallbackBase::CallbackBase(PassRefPtr<DispatcherImpl> backendImpl, int sessionId, int id)
@@ skipping 15 matching lines @@
 void Dispatcher::CallbackBase::sendIfActive(PassRefPtr<JSONObject> partialMessage, const ErrorString& invocationError, PassRefPtr<JSONValue> errorData)
 {
     if (m_alreadySent)
         return;
     m_backendImpl->sendResponse(m_sessionId, m_id, invocationError, errorData, partialMessage);
     m_alreadySent = true;
 }
 
 } // namespace protocol
 } // namespace blink