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

third_party/WebKit/Source/platform/inspector_protocol/TypeBuilder_h.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.
 
 #ifndef {{class_name}}_h
 #define {{class_name}}_h
 
 #include "platform/JSONValues.h"
@@ skipping 95 matching lines @@
 PassRefPtr<JSONValue> toValue(PassOwnPtr<T> param)
 {
     return param->asValue();
 }
 
 template<typename T>
 struct FromValue
 {
     static PassOwnPtr<T> convert(RefPtr<JSONValue> value)
     {
-        return T::runtimeCast(JSONObject::cast(value.release()));
+        if (!value)
+            return nullptr;
+        RefPtr<JSONObject> object;
+        bool success = value->asObject(&object);
+        ASSERT_UNUSED(success, success);
+        return T::runtimeCast(object.release());
     }
 };
 
 template<>
 struct FromValue<bool>
 {
     static bool convert(RefPtr<JSONValue> value)
     {
         bool result;
         bool success = value->asBoolean(&result);
@@ skipping 45 matching lines @@
     {
         return value.release();
     }
 };
 
 template<typename T>
 struct FromValue<protocol::Array<T>>
 {
     static PassOwnPtr<protocol::Array<T>> convert(RefPtr<JSONValue> value)
     {
-        return protocol::Array<T>::runtimeCast(JSONArray::cast(value));
+        RefPtr<JSONArray> array = value->asArray();
+        ASSERT_UNUSED(array, array);
+        return protocol::Array<T>::runtimeCast(array);
     }
 };
 
 template<typename T>
 class ArrayBase {
 public:
     static PassOwnPtr<Array<T>> create()
     {
         OwnPtr<Array<T>> result = adoptPtr(new Array<T>());
         result->m_array = JSONArray::create();
         return result.release();
     }
 
-    static PassOwnPtr<Array<T>> runtimeCast(PassRefPtr<JSONValue> array)
+    static PassOwnPtr<Array<T>> runtimeCast(PassRefPtr<JSONArray> array)
     {
-        if (!array || array->type() != JSONValue::TypeArray)
+        if (!array)
             return nullptr;
         OwnPtr<Array<T>> result = adoptPtr(new Array<T>());
-        result->m_array = JSONArray::cast(array);
+        result->m_array = array;
         return result.release();
     }
 
     void addItem(const T& value)
     {
         m_array->pushValue(toValue(value));
     }
 
     size_t length() { return m_array->length(); }
 
@@ skipping 13 matching lines @@
 template<typename T>
 class Array {
 public:
     static PassOwnPtr<Array<T>> create()
     {
         OwnPtr<Array<T>> result = adoptPtr(new Array<T>());
         result->m_array = JSONArray::create();
         return result.release();
     }
 
-    static PassOwnPtr<Array<T>> runtimeCast(PassRefPtr<JSONValue> array)
+    static PassOwnPtr<Array<T>> runtimeCast(PassRefPtr<JSONArray> array)
     {
-        if (!array || array->type() != JSONValue::TypeArray)
+        if (!array)
             return nullptr;
         OwnPtr<Array<T>> result = adoptPtr(new Array<T>());
-        result->m_array = JSONArray::cast(array);
+        result->m_array = array;
         return result.release();
     }
 
     void addItem(PassOwnPtr<T> value)
     {
         m_array->pushValue(toValue(value));
     }
 
     size_t length() { return m_array->length(); }
 
@@ skipping 61 matching lines @@
 {% for domain in api.domains %}
 
 namespace {{domain.domain}} {
   {% for type in domain.types %}
     {% if type.type == "object" %}
       {% set type_def = type_definition(domain.domain + "." + type.id)%}
 
 // {{type.description}}
 class PLATFORM_EXPORT {{type.id}} {
 public:
-    static PassOwnPtr<{{type.id}}> runtimeCast(PassRefPtr<JSONValue> value)
+    static PassOwnPtr<{{type.id}}> runtimeCast(PassRefPtr<JSONObject> object)
     {
-        if (!value || value->type() != JSONValue::TypeObject)
-            return nullptr;
-        return adoptPtr(new {{type.id}}(JSONObject::cast(value)));
+        return adoptPtr(new {{type.id}}(object));
     }
 
     {{type.id}}() : m_object(JSONObject::create()) { }
 
     ~{{type.id}}() { }
       {% for property in type.properties %}
 
         {% if "enum" in property %}
     struct PLATFORM_EXPORT {{property.name | to_title_case}}Enum {
           {% for literal in property.enum %}
@@ skipping 112 matching lines @@
     {% endif %}
   {% endfor %}
 
 } // {{domain.domain}}
 {% endfor %}
 
 } // namespace protocol
 } // namespace blink
 
 #endif // !defined({{class_name}}_h)