DevTools: introduce protocol::Value, baseline for hierarchical data in remote debugging protocol.

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"
 #include "platform/PlatformExport.h"
+#include "platform/inspector_protocol/Values.h"
 #include "wtf/Assertions.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 namespace protocol {
 
 template<typename T>
@@ skipping 70 matching lines @@
     PassRefPtr<T> fromMaybe(const PassRefPtr<T> defaultValue) const { return m_value || defaultValue; }
     bool isJust() const { return !!m_value; }
     PassRefPtr<T> takeJust() { return m_value; }
 
 protected:
     RefPtr<T> m_value;
 };
 
 template<typename T> class Array;
 
-PLATFORM_EXPORT PassRefPtr<JSONValue> toValue(int value);
-PLATFORM_EXPORT PassRefPtr<JSONValue> toValue(double value);
-PLATFORM_EXPORT PassRefPtr<JSONValue> toValue(bool value);
-PLATFORM_EXPORT PassRefPtr<JSONValue> toValue(const String& param);
-template<typename T> PassRefPtr<JSONValue> toValue(PassRefPtr<T> param) { return param; }
-template<typename T> PassRefPtr<JSONValue> toValue(const RefPtr<T>& param) { return param; }
-template<typename T> PassRefPtr<JSONValue> toValue(T* param) { return param->serialize(); }
-template<typename T> PassRefPtr<JSONValue> toValue(PassOwnPtr<T> param) { return param->serialize(); }
-template<typename T> PassRefPtr<JSONValue> toValue(const OwnPtr<T>& param) { return param->serialize(); }
+PLATFORM_EXPORT PassRefPtr<protocol::Value> toValue(int value);
+PLATFORM_EXPORT PassRefPtr<protocol::Value> toValue(double value);
+PLATFORM_EXPORT PassRefPtr<protocol::Value> toValue(bool value);
+PLATFORM_EXPORT PassRefPtr<protocol::Value> toValue(const String& param);
+template<typename T> PassRefPtr<protocol::Value> toValue(PassRefPtr<T> param) { return param; }
+template<typename T> PassRefPtr<protocol::Value> toValue(const RefPtr<T>& param) { return param; }
+template<typename T> PassRefPtr<protocol::Value> toValue(T* param) { return param->serialize(); }
+template<typename T> PassRefPtr<protocol::Value> toValue(PassOwnPtr<T> param) { return param->serialize(); }
+template<typename T> PassRefPtr<protocol::Value> toValue(const OwnPtr<T>& param) { return param->serialize(); }
 
 class PLATFORM_EXPORT ErrorSupport {
 public:
     ErrorSupport();
     ErrorSupport(String* errorString);
     ~ErrorSupport();
 
     void push();
     void setName(const String& name);
     void pop();
     void addError(const String& error);
     bool hasErrors();
     String errors();
 
 private:
     Vector<String> m_path;
     Vector<String> m_errors;
     String* m_errorString;
 };
 
 template<typename T>
 struct FromValue
 {
-    static PassOwnPtr<T> parse(PassRefPtr<JSONValue> value, ErrorSupport* errors)
+    static PassOwnPtr<T> parse(PassRefPtr<protocol::Value> value, ErrorSupport* errors)
     {
         return T::parse(value, errors);
     }
 };
 
 template<>
 struct FromValue<bool>
 {
-    static bool parse(PassRefPtr<JSONValue> value, ErrorSupport* errors)
+    static bool parse(PassRefPtr<protocol::Value> value, ErrorSupport* errors)
     {
         bool result = false;
         bool success = value ? value->asBoolean(&result) : false;
         if (!success)
             errors->addError("boolean value expected");
         return result;
     }
 };
 
 template<>
 struct FromValue<int>
 {
-    static int parse(PassRefPtr<JSONValue> value, ErrorSupport* errors)
+    static int parse(PassRefPtr<protocol::Value> value, ErrorSupport* errors)
     {
         int result = 0;
         bool success = value ? value->asNumber(&result) : false;
         if (!success)
             errors->addError("integer value expected");
         return result;
     }
 };
 
 template<>
 struct FromValue<double>
 {
-    static double parse(PassRefPtr<JSONValue> value, ErrorSupport* errors)
+    static double parse(PassRefPtr<protocol::Value> value, ErrorSupport* errors)
     {
         double result = 0;
         bool success = value ? value->asNumber(&result) : false;
         if (!success)
             errors->addError("double value expected");
         return result;
     }
 };
 
 template<>
 struct FromValue<String>
 {
-    static String parse(PassRefPtr<JSONValue> value, ErrorSupport* errors)
+    static String parse(PassRefPtr<protocol::Value> value, ErrorSupport* errors)
     {
         String result;
         bool success = value ? value->asString(&result) : false;
         if (!success)
             errors->addError("string value expected");
         return result;
     }
 };
 
 template<typename T>
 struct FromValue<RefPtr<T>>
 {
-    static PassRefPtr<T> parse(PassRefPtr<JSONValue> value, ErrorSupport* errors)
+    static PassRefPtr<T> parse(PassRefPtr<protocol::Value> value, ErrorSupport* errors)
     {
         if (!value)
             errors->addError("value expected");
         return value;
     }
 };
 
 template<>
-struct FromValue<RefPtr<JSONObject>>
+struct FromValue<RefPtr<protocol::DictionaryValue>>
 {
-    static PassRefPtr<JSONObject> parse(PassRefPtr<JSONValue> value, ErrorSupport* errors)
+    static PassRefPtr<protocol::DictionaryValue> parse(PassRefPtr<protocol::Value> value, ErrorSupport* errors)
     {
-        if (value && value->type() == JSONValue::TypeObject)
-            return JSONObject::cast(value);
+        if (value && value->type() == protocol::Value::TypeObject)
+            return DictionaryValue::cast(value);
         errors->addError("object expected");
         return nullptr;
     }
 };
 
 template<typename T>
 struct FromValue<protocol::Array<T>>
 {
-    static PassOwnPtr<protocol::Array<T>> parse(PassRefPtr<JSONValue> value, ErrorSupport* errors)
+    static PassOwnPtr<protocol::Array<T>> parse(PassRefPtr<protocol::Value> value, ErrorSupport* errors)
     {
         return protocol::Array<T>::parse(value, errors);
     }
 };
 
 template<typename T>
 class ArrayBase {
 public:
     static PassOwnPtr<Array<T>> create()
     {
         return adoptPtr(new Array<T>());
     }
 
-    static PassOwnPtr<Array<T>> parse(PassRefPtr<JSONValue> value, ErrorSupport* errors)
+    static PassOwnPtr<Array<T>> parse(PassRefPtr<protocol::Value> value, ErrorSupport* errors)
     {
-        RefPtr<JSONArray> array = JSONArray::cast(value);
+        RefPtr<protocol::ListValue> array = ListValue::cast(value);
         if (!array) {
             errors->addError("array expected");
             return nullptr;
         }
         errors->push();
         OwnPtr<Array<T>> result = adoptPtr(new Array<T>());
         for (size_t i = 0; i < array->length(); ++i) {
             errors->setName("[" + String::number(i) + "]");
             T item = FromValue<T>::parse(array->get(i), errors);
             result->m_vector.append(item);
@@ skipping 12 matching lines @@
     size_t length()
     {
         return m_vector.size();
     }
 
     T get(size_t index)
     {
         return m_vector[index];
     }
 
-    PassRefPtr<JSONArray> serialize()
+    PassRefPtr<protocol::ListValue> serialize()
     {
-        RefPtr<JSONArray> result = JSONArray::create();
+        RefPtr<protocol::ListValue> result = ListValue::create();
         for (auto& item : m_vector)
             result->pushValue(toValue(item));
         return result.release();
     }
 
 private:
     Vector<T> m_vector;
 };
 
 template<> class Array<String> : public ArrayBase<String> {};
 template<> class Array<int> : public ArrayBase<int> {};
 template<> class Array<double> : public ArrayBase<double> {};
 template<> class Array<bool> : public ArrayBase<bool> {};
 template<typename T> class Array<RefPtr<T>> : public ArrayBase<RefPtr<T>> {};
 
 template<typename T>
 class Array {
 public:
     static PassOwnPtr<Array<T>> create()
     {
         return adoptPtr(new Array<T>());
     }
 
-    static PassOwnPtr<Array<T>> parse(PassRefPtr<JSONValue> value, ErrorSupport* errors)
+    static PassOwnPtr<Array<T>> parse(PassRefPtr<protocol::Value> value, ErrorSupport* errors)
     {
-        RefPtr<JSONArray> array = JSONArray::cast(value);
+        RefPtr<protocol::ListValue> array = ListValue::cast(value);
         if (!array) {
             errors->addError("array expected");
             return nullptr;
         }
         OwnPtr<Array<T>> result = adoptPtr(new Array<T>());
         errors->push();
         for (size_t i = 0; i < array->length(); ++i) {
             errors->setName("[" + String::number(i) + "]");
             OwnPtr<T> item = FromValue<T>::parse(array->get(i), errors);
             result->m_vector.append(item.release());
@@ skipping 10 matching lines @@
     size_t length()
     {
         return m_vector.size();
     }
 
     T* get(size_t index)
     {
         return m_vector[index].get();
     }
 
-    PassRefPtr<JSONArray> serialize()
+    PassRefPtr<protocol::ListValue> serialize()
     {
-        RefPtr<JSONArray> result = JSONArray::create();
+        RefPtr<protocol::ListValue> result = ListValue::create();
         for (auto& item : m_vector)
             result->pushValue(toValue(item));
         return result.release();
     }
 
 private:
     Vector<OwnPtr<T>> m_vector;
 };
 
 class PLATFORM_EXPORT Object {
 public:
-    static PassOwnPtr<Object> parse(PassRefPtr<JSONValue> value, ErrorSupport* errors);
+    static PassOwnPtr<Object> parse(PassRefPtr<protocol::Value> value, ErrorSupport* errors);
     ~Object();
 
-    PassRefPtr<JSONObject> serialize() const;
+    PassRefPtr<protocol::DictionaryValue> serialize() const;
     PassOwnPtr<Object> clone() const;
 private:
-    Object(PassRefPtr<JSONObject> object);
-    RefPtr<JSONObject> m_object;
+    Object(PassRefPtr<protocol::DictionaryValue> object);
+    RefPtr<protocol::DictionaryValue> m_object;
 };
 
 {% for domain in api.domains %}
 
 // ------------- Forward declarations and typedefs.
 
 namespace {{domain.domain}} {
   {% for type in domain.types %}
     {% if type.type == "object" %}
       {% if "properties" in type %}
@@ skipping 51 matching lines @@
 {% for domain in api.domains %}
 
 namespace {{domain.domain}} {
   {% for type in domain.types %}
     {% if not (type.type == "object") or not ("properties" in type) %}{% continue %}{% endif %}
     {% set type_def = type_definition(domain.domain + "." + type.id)%}
 
 // {{type.description}}
 class PLATFORM_EXPORT {{type.id}} {
 public:
-    static PassOwnPtr<{{type.id}}> parse(PassRefPtr<JSONValue> value, ErrorSupport* errors);
+    static PassOwnPtr<{{type.id}}> parse(PassRefPtr<protocol::Value> value, ErrorSupport* errors);
 
     ~{{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 %}
         static const char* {{ literal | dash_to_camelcase}};
         {% endfor %}
     }; // {{property.name | to_title_case}}Enum
       {% endif %}
 
       {% if property.optional %}
     bool has{{property.name | to_title_case}}() { return m_{{property.name}}.isJust(); }
     {{resolve_type(property).raw_return_type}} get{{property.name | to_title_case}}({{resolve_type(property).raw_pass_type}} defaultValue) { return m_{{property.name}}.isJust() ? m_{{property.name}}.fromJust() : defaultValue; }
       {% else %}
     {{resolve_type(property).raw_return_type}} get{{property.name | to_title_case}}() { return {{resolve_type(property).to_raw_type % ("m_" + property.name)}}; }
       {% endif %}
     void set{{property.name | to_title_case}}({{resolve_type(property).pass_type}} value) { m_{{property.name}} = value; }
     {% endfor %}
 
-    PassRefPtr<JSONObject> serialize() const;
+    PassRefPtr<protocol::DictionaryValue> serialize() const;
     PassOwnPtr<{{type.id}}> clone() const;
 
     template<int STATE>
     class {{type.id}}Builder {
     public:
         enum {
             NoFieldsSet = 0,
     {% set count = 0 %}
     {% for property in type.properties %}
       {% if not(property.optional) %}
@@ skipping 61 matching lines @@
 
   {% endfor %}
 
 } // {{domain.domain}}
 {% endfor %}
 
 } // namespace protocol
 } // namespace blink
 
 #endif // !defined({{class_name}}_h)