DevTools: consistently use Maybe for optional values in the protocol generator.

third_party/WebKit/Source/platform/inspector_protocol/Dispatcher_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"
 
 #include "platform/JSONParser.h"
 #include "platform/inspector_protocol/FrontendChannel.h"
 #include "wtf/text/CString.h"
 
 namespace blink {
 namespace protocol {
 
-using protocol::OptionalValue;
+using protocol::Maybe;
 
 class DispatcherImpl : public Dispatcher {
 public:
     DispatcherImpl(FrontendChannel* frontendChannel)
         : m_frontendChannel(frontendChannel)
 {% for domain in api.domains %}
         , m_{{domain.domain | lower}}Agent(0)
 {% endfor %}
     {
 {% for domain in api.domains %}
@@ skipping 39 matching lines @@
 
     FrontendChannel* m_frontendChannel;
 
 {% for domain in api.domains %}
     {{domain.domain}}CommandHandler* m_{{domain.domain | lower}}Agent;
 {% endfor %}
 
     template<typename R, typename V, typename V0>
     static R getPropertyValueImpl(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors, V0 initial_value, bool (*as_method)(PassRefPtr<JSONValue>, V*), const char* type_name);
 
-    static OptionalValue<int> getInteger(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors);
-    static OptionalValue<double> getNumber(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors);
-    static OptionalValue<String> getString(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors);
-    static OptionalValue<bool> getBoolean(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors);
+    static Maybe<int> getInteger(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors);
+    static Maybe<double> getNumber(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors);
+    static Maybe<String> getString(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors);
+    static Maybe<bool> getBoolean(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors);
     static PassRefPtr<JSONObject> getObject(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors);
     static PassRefPtr<JSONArray> getArray(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors);
 
     void sendResponse(int sessionId, int callId, ErrorString invocationError, PassRefPtr<JSONObject> result)
     {
         sendResponse(sessionId, callId, invocationError, RefPtr<JSONValue>(), result);
     }
 
     void sendResponse(int sessionId, int callId, ErrorString invocationError)
     {
@@ skipping 11 matching lines @@
   {% for command in domain.commands %}
     {% if "redirect" in command %}{% continue %}{% endif %}
     {% if "handlers" in command and not ("renderer" in command["handlers"]) %}{% continue %}{% endif %}
 
     {% if "async" in command %}
 Dispatcher::{{domain.domain}}CommandHandler::{{command.name | to_title_case}}Callback::{{command.name | to_title_case}}Callback(PassRefPtr<DispatcherImpl> backendImpl, int sessionId, int id) : CallbackBase(backendImpl, sessionId, id) { }
 
 void Dispatcher::{{domain.domain}}CommandHandler::{{command.name | to_title_case}}Callback::sendSuccess(
       {%- for parameter in command.returns -%}
         {%- if "optional" in parameter -%}
-        {{resolve_type(parameter).optional_pass_type}} {{parameter.name}}
+        const Maybe<{{resolve_type(parameter).raw_type}}>& {{parameter.name}}
         {%- else -%}
         {{resolve_type(parameter).pass_type}} {{parameter.name}}
         {%- endif -%}
         {%- if not loop.last -%}, {% endif -%}
       {% endfor %})
 {
     RefPtr<JSONObject> resultObject = JSONObject::create();
       {% for parameter in command.returns %}
         {% if "optional" in parameter %}
-    {{resolve_type(parameter).optional_type}} opt_{{parameter.name}} = {{parameter.name}};
-    if (hasValue({{parameter.name}}))
-        resultObject->setValue("{{parameter.name}}", toValue({{resolve_type(parameter).from_optional_out % ("opt_" + parameter.name)}}));
+    if ({{parameter.name}}.isJust())
+        resultObject->setValue("{{parameter.name}}", toValue({{parameter.name}}));
        {% else %}
     resultObject->setValue("{{parameter.name}}", toValue({{parameter.name}}));
         {% endif %}
       {% endfor %}
     sendIfActive(resultObject.release(), ErrorString(), PassRefPtr<JSONValue>());
 }
     {% endif %}
 
 void DispatcherImpl::{{domain.domain}}_{{command.name}}(int sessionId, int callId, JSONObject* requestMessageObject, JSONArray* protocolErrors)
 {
     if (!m_{{domain.domain | lower}}Agent)
         protocolErrors->pushString("Inspector handler is not available.");
 
     if (protocolErrors->length()) {
         reportProtocolError(sessionId, callId, InvalidParams, String::format(InvalidParamsFormatString, "{{domain.domain}}.{{command.name}}"), protocolErrors);
         return;
     }
 
     {% if "parameters" in command %}
     // Prepare input parameters.
     RefPtr<JSONObject> paramsContainer = requestMessageObject->getObject("params");
     JSONObject* paramsContainerPtr = paramsContainer.get();
       {% for property in command.parameters %}
-    {{resolve_type(property).optional_type}} in_{{property.name}} = {{resolve_type(property).json_getter % ("paramsContainerPtr, \"" + property.name + "\", " + ("true" if "optional" in property else "false") + ", protocolErrors")}};
+    Maybe<{{resolve_type(property).raw_type}}> in_{{property.name}} = {{resolve_type(property).json_getter % ("paramsContainerPtr, \"" + property.name + "\", " + ("true" if "optional" in property else "false") + ", protocolErrors")}};
       {% endfor %}
     {% endif %}
 
     if (protocolErrors->length()) {
         reportProtocolError(sessionId, callId, InvalidParams, String::format(InvalidParamsFormatString, "{{domain.domain}}.{{command.name}}"), protocolErrors);
         return;
     }
 
     {% if "async" in command %}
     RefPtr<{{domain.domain}}CommandHandler::{{command.name | to_title_case}}Callback> callback = adoptRef(new {{domain.domain}}CommandHandler::{{command.name | to_title_case}}Callback(this, sessionId, callId));
     {% elif "returns" in command %}
     // Declare output parameters.
     RefPtr<JSONObject> result = JSONObject::create();
       {% for property in command.returns %}
         {% if "optional" in property %}
-    {{resolve_type(property).optional_type}} out_{{property.name}};
+    Maybe<{{resolve_type(property).raw_type}}> out_{{property.name}};
         {% else %}
     {{resolve_type(property).type}} out_{{property.name}};
         {% endif %}
       {% endfor %}
     {% endif %}
 
     ErrorString error;
     m_{{domain.domain | lower}}Agent->{{command.name}}(&error
       {%- for property in command.parameters -%}
         {%- if "optional" in property -%}
-        , {{resolve_type(property).to_pass_type % ("in_" + property.name)}}
+        , in_{{property.name}}
         {%- else -%}
-        , {{resolve_type(property).from_optional_out % ("in_" + property.name)}}
+        , in_{{property.name}}.takeJust()
         {%- endif -%}
       {%- endfor %}
       {%- if "async" in command -%}
         , callback.release()
       {%- 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 (hasValue(out_{{parameter.name}}))
-            result->setValue("{{parameter.name}}", toValue({{resolve_type(parameter).from_optional_out % ("out_" + parameter.name)}}));
+        if (out_{{parameter.name}}.isJust())
+            result->setValue("{{parameter.name}}", toValue(out_{{parameter.name}}));
         {% else %}
         result->setValue("{{parameter.name}}", toValue(out_{{resolve_type(parameter).to_pass_type % parameter.name}}));
         {% endif %}
       {% endfor %}
     }
     sendResponse(sessionId, callId, error, result);
     {% elif not("async" in command) %}
     sendResponse(sessionId, callId, error);
     {% endif %}
 }
@@ skipping 107 matching lines @@
 
 struct AsMethodBridges {
     static bool asInteger(PassRefPtr<JSONValue> value, int* output) { return value->asNumber(output); }
     static bool asNumber(PassRefPtr<JSONValue> value, double* output) { return value->asNumber(output); }
     static bool asString(PassRefPtr<JSONValue> value, String* output) { return value->asString(output); }
     static bool asBoolean(PassRefPtr<JSONValue> value, bool* output) { return value->asBoolean(output); }
     static bool asObject(PassRefPtr<JSONValue> value, RefPtr<JSONObject>* output) { *output = JSONObject::cast(value); return *output; }
     static bool asArray(PassRefPtr<JSONValue> value, RefPtr<JSONArray>* output) { *output = JSONArray::cast(value); return *output; }
 };
 
-OptionalValue<int> DispatcherImpl::getInteger(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors)
+Maybe<int> DispatcherImpl::getInteger(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors)
 {
     bool valueFound = false;
     int result = getPropertyValueImpl<int, int, int>(object, name, isOptional ? &valueFound : 0, protocolErrors, 0, AsMethodBridges::asInteger, "Number");
-    return valueFound || !isOptional ? OptionalValue<int>(result) : OptionalValue<int>();
+    return valueFound || !isOptional ? Maybe<int>(result) : Maybe<int>();
 }
 
-OptionalValue<double> DispatcherImpl::getNumber(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors)
+Maybe<double> DispatcherImpl::getNumber(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors)
 {
     bool valueFound = false;
     double result = getPropertyValueImpl<double, double, double>(object, name, isOptional ? &valueFound : 0, protocolErrors, 0, AsMethodBridges::asNumber, "Number");
-    return valueFound || !isOptional ? OptionalValue<double>(result) : OptionalValue<double>();
+    return valueFound || !isOptional ? Maybe<double>(result) : Maybe<double>();
 }
 
-OptionalValue<String> DispatcherImpl::getString(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors)
+Maybe<String> DispatcherImpl::getString(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors)
 {
     bool valueFound = false;
     String result = getPropertyValueImpl<String, String, String>(object, name, isOptional ? &valueFound : 0, protocolErrors, "", AsMethodBridges::asString, "String");
-    return valueFound || !isOptional ? OptionalValue<String>(result) : OptionalValue<String>();
+    return valueFound || !isOptional ? Maybe<String>(result) : Maybe<String>();
 }
 
-OptionalValue<bool> DispatcherImpl::getBoolean(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors)
+Maybe<bool> DispatcherImpl::getBoolean(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors)
 {
     bool valueFound = false;
     bool result = getPropertyValueImpl<bool, bool, bool>(object, name, isOptional ? &valueFound : 0, protocolErrors, false, AsMethodBridges::asBoolean, "Boolean");
-    return valueFound || !isOptional ? OptionalValue<bool>(result) : OptionalValue<bool>();
+    return valueFound || !isOptional ? Maybe<bool>(result) : Maybe<bool>();
 }
 
 PassRefPtr<JSONObject> DispatcherImpl::getObject(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors)
 {
     bool valueFound = false;
     return getPropertyValueImpl<PassRefPtr<JSONObject>, RefPtr<JSONObject>, JSONObject*>(object, name, isOptional ? &valueFound : 0, protocolErrors, 0, AsMethodBridges::asObject, "Object");
 }
 
 PassRefPtr<JSONArray> DispatcherImpl::getArray(JSONObject* object, const char* name, bool isOptional, JSONArray* protocolErrors)
 {
@@ skipping 36 matching lines @@
 void Dispatcher::CallbackBase::sendIfActive(PassRefPtr<JSONObject> partialMessage, const ErrorString& invocationError, PassRefPtr<JSONValue> errorData)
 {
     if (m_alreadySent)
         return;
     m_backendImpl->sendResponse(m_sessionId, m_id, invocationError, errorData, partialMessage);
     m_alreadySent = true;
 }
 
 } // namespace protocol
 } // namespace blink