[DevTools] Unify toValue and FromValue into ValueConversions.

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 "{{output_package}}/{{domain.domain}}.h"
 
 #include "platform/inspector_protocol/DispatcherBase.h"
 
@@ skipping 31 matching lines @@
     }
 
     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}} = FromValue<{{resolve_type(property).raw_type}}>::parse({{property.name}}Value, errors);
+        result->m_{{property.name}} = ValueConversions<{{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);
+    result->m_{{property.name}} = ValueConversions<{{resolve_type(property).raw_type}}>::parse({{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> 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()));
+        result->setValue("{{property.name}}", ValueConversions<{{resolve_type(property).raw_type}}>::serialize(m_{{property.name}}.fromJust()));
       {% else %}
-    result->setValue("{{property.name}}", toValue({{resolve_type(property).to_raw_type % ("m_" + property.name)}}));
+    result->setValue("{{property.name}}", ValueConversions<{{resolve_type(property).raw_type}}>::serialize({{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);
 }
@@ skipping 28 matching lines @@
         {{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 ({{parameter.name}}.isJust())
-        paramsObject->setValue("{{parameter.name}}", toValue({{parameter.name}}.fromJust()));
+        paramsObject->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize({{parameter.name}}.fromJust()));
       {% else %}
-    paramsObject->setValue("{{parameter.name}}", toValue({{resolve_type(parameter).to_raw_type % parameter.name}}));
+    paramsObject->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize({{resolve_type(parameter).to_raw_type % parameter.name}}));
       {% endif %}
     {% endfor %}
     jsonMessage->setObject("params", std::move(paramsObject));
     if (m_frontendChannel)
         m_frontendChannel->sendProtocolNotification(jsonMessage->toJSONString());
 }
   {% endfor %}
 
 // --------------------- Dispatcher.
 
@@ skipping 54 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}}", toValue({{parameter.name}}.fromJust()));
+            resultObject->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize({{parameter.name}}.fromJust()));
            {% else %}
-        resultObject->setValue("{{parameter.name}}", toValue({{resolve_type(parameter).to_raw_type % parameter.name}}));
+        resultObject->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize({{resolve_type(parameter).to_raw_type % parameter.name}}));
             {% endif %}
           {% endfor %}
         sendIfActive(std::move(resultObject), ErrorString());
     }
 
     void sendFailure(const ErrorString& error) override
     {
         DCHECK(error.length());
         sendIfActive(nullptr, error);
     }
 
 };
     {% endif %}
 
 void DispatcherImpl::{{command.name}}(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
 {
     {% 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}} = FromValue<{{resolve_type(property).raw_type}}>::parse({{property.name}}Value, errors);
+        in_{{property.name}} = ValueConversions<{{resolve_type(property).raw_type}}>::parse({{property.name}}Value, errors);
     }
         {% else %}
     errors->setName("{{property.name}}");
-    {{resolve_type(property).type}} in_{{property.name}} = FromValue<{{resolve_type(property).raw_type}}>::parse({{property.name}}Value, errors);
+    {{resolve_type(property).type}} in_{{property.name}} = ValueConversions<{{resolve_type(property).raw_type}}>::parse({{property.name}}Value, errors);
         {% endif %}
       {% endfor %}
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(callId, InvalidParams, kInvalidRequest, errors);
         return;
     }
     {% endif %}
     {% if "async" in command %}
     std::unique_ptr<{{command.name | to_title_case}}CallbackImpl> callback(new {{command.name | to_title_case}}CallbackImpl(weakPtr(), callId));
@@ skipping 24 matching lines @@
       {%- elif "returns" in command %}
         {%- for property in command.returns -%}
           , &out_{{property.name}}
         {%- endfor %}
       {% endif %});
     {% if "returns" in command and not("async" in command) %}
     if (!error.length()) {
       {% for parameter in command.returns %}
         {% if "optional" in parameter %}
         if (out_{{parameter.name}}.isJust())
-            result->setValue("{{parameter.name}}", toValue(out_{{parameter.name}}.fromJust()));
+            result->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize(out_{{parameter.name}}.fromJust()));
         {% else %}
-        result->setValue("{{parameter.name}}", toValue({{resolve_type(parameter).to_raw_type % ("out_" + parameter.name)}}));
+        result->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize({{resolve_type(parameter).to_raw_type % ("out_" + parameter.name)}}));
         {% endif %}
       {% endfor %}
     }
     if (weak->get())
         weak->get()->sendResponse(callId, error, std::move(result));
     {% elif not("async" in command) %}
     if (weak->get())
         weak->get()->sendResponse(callId, error);
     {% endif %}
 }
   {% endfor %}
 
 // static
 void Dispatcher::wire(UberDispatcher* dispatcher, Backend* backend)
 {
     dispatcher->registerBackend("{{domain.domain}}", wrapUnique(new DispatcherImpl(dispatcher->channel(), backend)));
 }
 
 } // {{domain.domain}}
 } // namespace protocol
 } // namespace blink