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

third_party/WebKit/Source/platform/inspector_protocol/TypeBuilder_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"
 
 namespace blink {
 namespace protocol {
@@ skipping 44 matching lines @@
 {
     StringBuilder builder;
     for (size_t i = 0; i < m_errors.size(); ++i) {
         if (i)
             builder.append("; ");
         builder.append(m_errors[i]);
     }
     return builder.toString();
 }
 
-PassOwnPtr<Object> Object::parse(PassRefPtr<JSONValue> value, ErrorSupport* errors)
+PassOwnPtr<Object> Object::parse(PassRefPtr<protocol::Value> value, ErrorSupport* errors)
 {
-    RefPtr<JSONObject> object = JSONObject::cast(value);
+    RefPtr<protocol::DictionaryValue> object = DictionaryValue::cast(value);
     if (!object) {
         errors->addError("object expected");
         return nullptr;
     }
     return adoptPtr(new Object(object.release()));
 }
 
-PassRefPtr<JSONObject> Object::serialize() const
+PassRefPtr<protocol::DictionaryValue> Object::serialize() const
 {
     return m_object;
 }
 
 PassOwnPtr<Object> Object::clone() const
 {
     return adoptPtr(new Object(m_object));
 }
 
-Object::Object(PassRefPtr<JSONObject> object) : m_object(object) { }
+Object::Object(PassRefPtr<protocol::DictionaryValue> object) : m_object(object) { }
 Object::~Object() { }
 
-PassRefPtr<JSONValue> toValue(int value) { return JSONBasicValue::create(value); }
-PassRefPtr<JSONValue> toValue(double value) { return JSONBasicValue::create(value); }
-PassRefPtr<JSONValue> toValue(bool value) { return JSONBasicValue::create(value); }
-PassRefPtr<JSONValue> toValue(const String& param) { return JSONString::create(param); }
+PassRefPtr<protocol::Value> toValue(int value) { return FundamentalValue::create(value); }
+PassRefPtr<protocol::Value> toValue(double value) { return FundamentalValue::create(value); }
+PassRefPtr<protocol::Value> toValue(bool value) { return FundamentalValue::create(value); }
+PassRefPtr<protocol::Value> toValue(const String& param) { return StringValue::create(param); }
 
 // ------------- Enum values from types.
 {% for domain in api.domains %}
 
 namespace {{domain.domain}} {
   {% for type in domain.types %}
     {% if "enum" in type %}
 
 namespace {{type.id}}Enum {
       {% for literal in type.enum %}
 const char* {{ literal | dash_to_camelcase}} = "{{literal}}";
       {% endfor %}
 } // {{type.id}}Enum
     {% endif %}
     {% for property in type.properties %}
       {% if "enum" in property %}
 
         {% for literal in property.enum %}
 const char* {{type.id}}::{{property.name | to_title_case}}Enum::{{ literal | dash_to_camelcase}} = "{{literal}}";
         {% endfor %}
       {% endif %}
     {% endfor %}
     {% if not (type.type == "object") or not ("properties" in type) %}{% continue %}{% endif %}
 
-PassOwnPtr<{{type.id}}> {{type.id}}::parse(PassRefPtr<JSONValue> value, ErrorSupport* errors)
+PassOwnPtr<{{type.id}}> {{type.id}}::parse(PassRefPtr<protocol::Value> value, ErrorSupport* errors)
 {
-    if (!value || value->type() != JSONValue::TypeObject) {
+    if (!value || value->type() != protocol::Value::TypeObject) {
         errors->addError("object expected");
         return nullptr;
     }
 
     OwnPtr<{{type.id}}> result = adoptPtr(new {{type.id}}());
-    RefPtr<JSONObject> object = JSONObject::cast(value);
+    RefPtr<protocol::DictionaryValue> object = DictionaryValue::cast(value);
     errors->push();
     {% for property in type.properties %}
-    RefPtr<JSONValue> {{property.name}}Value = object->get("{{property.name}}");
+    RefPtr<protocol::Value> {{property.name}}Value = object->get("{{property.name}}");
       {% if property.optional %}
     if ({{property.name}}Value) {
         errors->setName("{{property.name}}");
         result->m_{{property.name}} = FromValue<{{resolve_type(property).raw_type}}>::parse({{property.name}}Value, errors);
     }
       {% else %}
     errors->setName("{{property.name}}");
     result->m_{{property.name}} = FromValue<{{resolve_type(property).raw_type}}>::parse({{property.name}}Value, errors);
       {% endif %}
     {% endfor %}
     errors->pop();
     if (errors->hasErrors())
         return nullptr;
     return result.release();
 }
 
-PassRefPtr<JSONObject> {{type.id}}::serialize() const
+PassRefPtr<protocol::DictionaryValue> {{type.id}}::serialize() const
 {
-    RefPtr<JSONObject> result = JSONObject::create();
+    RefPtr<protocol::DictionaryValue> result = DictionaryValue::create();
     {% for property in type.properties %}
       {% if property.optional %}
     if (m_{{property.name}}.isJust())
         result->setValue("{{property.name}}", toValue(m_{{property.name}}.fromJust()));
       {% else %}
     result->setValue("{{property.name}}", toValue(m_{{property.name}}));
       {% endif %}
     {% endfor %}
     return result.release();
 }
@@ skipping 22 matching lines @@
 } // {{param.name | to_title_case}}Enum
 } // {{command.name | to_title_case }}
 } // {{domain.domain}}
       {% endif %}
     {% endfor %}
   {% endfor %}
 {% endfor %}
 
 } // namespace protocol
 } // namespace blink