[inspector_protocol] Introduce protocol::Serializable

templates/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 {{format_include(config.protocol.package, domain.domain)}}
 
 #include {{format_include(config.protocol.package, "Protocol")}}
 
@@ skipping 29 matching lines @@
     {% 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 %}
 
-std::unique_ptr<{{type.id}}> {{type.id}}::parse(protocol::Value* value, ErrorSupport* errors)
+std::unique_ptr<{{type.id}}> {{type.id}}::fromValue(protocol::Value* value, ErrorSupport* errors)
 {
     if (!value || value->type() != protocol::Value::TypeObject) {
         errors->addError("object expected");
         return nullptr;
     }
 
     std::unique_ptr<{{type.id}}> result(new {{type.id}}());
     protocol::DictionaryValue* object = DictionaryValue::cast(value);
     errors->push();
     {% for property in type.properties %}
     protocol::Value* {{property.name}}Value = object->get("{{property.name}}");
       {% if property.optional %}
     if ({{property.name}}Value) {
         errors->setName("{{property.name}}");
-        result->m_{{property.name}} = ValueConversions<{{resolve_type(property).raw_type}}>::parse({{property.name}}Value, errors);
+        result->m_{{property.name}} = ValueConversions<{{resolve_type(property).raw_type}}>::fromValue({{property.name}}Value, errors);
     }
       {% else %}
     errors->setName("{{property.name}}");
-    result->m_{{property.name}} = ValueConversions<{{resolve_type(property).raw_type}}>::parse({{property.name}}Value, errors);
+    result->m_{{property.name}} = ValueConversions<{{resolve_type(property).raw_type}}>::fromValue({{property.name}}Value, errors);
       {% endif %}
     {% endfor %}
     errors->pop();
     if (errors->hasErrors())
         return nullptr;
     return result;
 }
 
-std::unique_ptr<protocol::DictionaryValue> {{type.id}}::serialize() const
+std::unique_ptr<protocol::DictionaryValue> {{type.id}}::toValue() const
 {
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     {% for property in type.properties %}
       {% if property.optional %}
     if (m_{{property.name}}.isJust())
-        result->setValue("{{property.name}}", ValueConversions<{{resolve_type(property).raw_type}}>::serialize(m_{{property.name}}.fromJust()));
+        result->setValue("{{property.name}}", ValueConversions<{{resolve_type(property).raw_type}}>::toValue(m_{{property.name}}.fromJust()));
       {% else %}
-    result->setValue("{{property.name}}", ValueConversions<{{resolve_type(property).raw_type}}>::serialize({{resolve_type(property).to_raw_type % ("m_" + property.name)}}));
+    result->setValue("{{property.name}}", ValueConversions<{{resolve_type(property).raw_type}}>::toValue({{resolve_type(property).to_raw_type % ("m_" + property.name)}}));
       {% endif %}
     {% endfor %}
     return result;
 }
 
 std::unique_ptr<{{type.id}}> {{type.id}}::clone() const
 {
     ErrorSupport errors;
-    return parse(serialize().get(), &errors);
+    return fromValue(toValue().get(), &errors);
 }
     {% if type.exported %}
 
 {{config.exported.string_out}} {{type.id}}::toJSONString() const
 {
-    String json = serialize()->toJSONString();
+    String json = toValue()->serialize();
     return {{config.exported.to_string_out % "json"}};
 }
 
 // static
 std::unique_ptr<API::{{type.id}}> API::{{type.id}}::fromJSONString(const {{config.exported.string_in}}& json)
 {
     ErrorSupport errors;
     std::unique_ptr<Value> value = StringUtil::parseJSON(json);
     if (!value)
         return nullptr;
-    return protocol::{{domain.domain}}::{{type.id}}::parse(value.get(), &errors);
+    return protocol::{{domain.domain}}::{{type.id}}::fromValue(value.get(), &errors);
 }
     {% endif %}
   {% endfor %}
 
 // ------------- Enum values from params.
 
   {% for command in join_arrays(domain, ["commands", "events"]) %}
     {% for param in join_arrays(command, ["parameters", "returns"]) %}
       {% if "enum" in param %}
 
@@ skipping 26 matching lines @@
 
 void Frontend::{{event.name | to_method_case}}(
     {%- for parameter in event.parameters %}
       {% if "optional" in parameter -%}
         Maybe<{{resolve_type(parameter).raw_type}}>
       {%- else -%}
         {{resolve_type(parameter).pass_type}}
       {%- endif %} {{parameter.name}}{%- if not loop.last -%}, {% endif -%}
     {% endfor -%})
 {
-    std::unique_ptr<protocol::DictionaryValue> jsonMessage = DictionaryValue::create();
-    jsonMessage->setString("method", "{{domain.domain}}.{{event.name}}");
-    std::unique_ptr<protocol::DictionaryValue> paramsObject = DictionaryValue::create();
-    {% for parameter in event.parameters %}
-      {% if "optional" in parameter %}
+    if (!m_frontendChannel)
+        return;
+      {% if event.parameters %}
+    std::unique_ptr<{{event.name | to_title_case}}Notification> messageData = {{event.name | to_title_case}}Notification::{{"create" | to_method_case}}()
+        {% for parameter in event.parameters %}
+          {% if not "optional" in parameter %}
+        .{{"set" | to_method_case}}{{parameter.name | to_title_case}}({{resolve_type(parameter).to_pass_type % parameter.name}})
+          {% endif %}
+        {% endfor %}
+        .{{ "build" | to_method_case }}();
+        {% for parameter in event.parameters %}
+          {% if "optional" in parameter %}
     if ({{parameter.name}}.isJust())
-        paramsObject->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize({{parameter.name}}.fromJust()));
+        messageData->{{"set" | to_method_case}}{{parameter.name | to_title_case}}(std::move({{parameter.name}}).takeJust());
+          {% endif %}
+        {% endfor %}
+    m_frontendChannel->sendProtocolNotification(InternalResponse::createNotification("{{domain.domain}}.{{event.name}}", std::move(messageData)));
       {% else %}
-    paramsObject->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize({{resolve_type(parameter).to_raw_type % parameter.name}}));
+    m_frontendChannel->sendProtocolNotification(InternalResponse::createNotification("{{domain.domain}}.{{event.name}}"));
       {% endif %}
-    {% endfor %}
-    jsonMessage->setObject("params", std::move(paramsObject));
-    if (m_frontendChannel)
-        m_frontendChannel->sendProtocolNotification(jsonMessage->toJSONString());
 }
   {% endfor %}
 
 void Frontend::flush()
 {
     m_frontendChannel->flushProtocolNotifications();
 }
 
 void Frontend::sendRawNotification(const String& notification)
 {
-    m_frontendChannel->sendProtocolNotification(notification);
+    m_frontendChannel->sendProtocolNotification(InternalRawNotification::create(notification));
 }
 
 // --------------------- Dispatcher.
 
 class DispatcherImpl : public protocol::DispatcherBase {
 public:
     DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend, bool fallThroughForNotFound)
         : DispatcherBase(frontendChannel)
         , m_backend(backend)
         , m_fallThroughForNotFound(fallThroughForNotFound) {
@@ skipping 52 matching lines @@
         {%- else -%}
         {{resolve_type(parameter).pass_type}} {{parameter.name}}
         {%- endif -%}
         {%- if not loop.last -%}, {% endif -%}
       {%- endfor -%}) override
     {
         std::unique_ptr<protocol::DictionaryValue> resultObject = DictionaryValue::create();
           {% for parameter in command.returns %}
             {% if "optional" in parameter %}
         if ({{parameter.name}}.isJust())
-            resultObject->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize({{parameter.name}}.fromJust()));
+            resultObject->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::toValue({{parameter.name}}.fromJust()));
            {% else %}
-        resultObject->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize({{resolve_type(parameter).to_raw_type % parameter.name}}));
+        resultObject->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::toValue({{resolve_type(parameter).to_raw_type % parameter.name}}));
             {% endif %}
           {% endfor %}
         sendIfActive(std::move(resultObject), DispatchResponse::OK());
     }
 
     void fallThrough() override
     {
         fallThroughIfActive();
     }
 
@@ skipping 10 matching lines @@
     {% if "parameters" in command %}
     // Prepare input parameters.
     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     errors->push();
       {% for property in command.parameters %}
     protocol::Value* {{property.name}}Value = object ? object->get("{{property.name}}") : nullptr;
         {% if property.optional %}
     Maybe<{{resolve_type(property).raw_type}}> in_{{property.name}};
     if ({{property.name}}Value) {
         errors->setName("{{property.name}}");
-        in_{{property.name}} = ValueConversions<{{resolve_type(property).raw_type}}>::parse({{property.name}}Value, errors);
+        in_{{property.name}} = ValueConversions<{{resolve_type(property).raw_type}}>::fromValue({{property.name}}Value, errors);
     }
         {% else %}
     errors->setName("{{property.name}}");
-    {{resolve_type(property).type}} in_{{property.name}} = ValueConversions<{{resolve_type(property).raw_type}}>::parse({{property.name}}Value, errors);
+    {{resolve_type(property).type}} in_{{property.name}} = ValueConversions<{{resolve_type(property).raw_type}}>::fromValue({{property.name}}Value, errors);
         {% endif %}
       {% endfor %}
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
         return DispatchResponse::kError;
     }
     {% endif %}
     {% if "returns" in command and not is_async_command(domain.domain, command.name) %}
     // Declare output parameters.
@@ skipping 24 matching lines @@
         {%- endfor %}
       {% endif %});
       {% if "returns" in command %}
     if (response.status() == DispatchResponse::kFallThrough)
         return response.status();
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
         {% for parameter in command.returns %}
           {% if "optional" in parameter %}
         if (out_{{parameter.name}}.isJust())
-            result->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize(out_{{parameter.name}}.fromJust()));
+            result->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::toValue(out_{{parameter.name}}.fromJust()));
           {% else %}
-        result->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize({{resolve_type(parameter).to_raw_type % ("out_" + parameter.name)}}));
+        result->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::toValue({{resolve_type(parameter).to_raw_type % ("out_" + parameter.name)}}));
           {% endif %}
         {% endfor %}
     }
     if (weak->get())
         weak->get()->sendResponse(callId, response, std::move(result));
       {% else %}
     if (weak->get())
         weak->get()->sendResponse(callId, response);
       {% endif %}
     return response.status();
@@ skipping 18 matching lines @@
 // static
 void Dispatcher::wire(UberDispatcher* dispatcher, Backend* backend)
 {
     dispatcher->registerBackend("{{domain.domain}}", std::unique_ptr<protocol::DispatcherBase>(new DispatcherImpl(dispatcher->channel(), backend, dispatcher->fallThroughForNotFound())));
 }
 
 } // {{domain.domain}}
 {% for namespace in config.protocol.namespace %}
 } // namespace {{namespace}}
 {% endfor %}