Roll third_party/inspector_protocol to 2952a8eb5d99fbc194946526b57d67ed52093699

third_party/inspector_protocol/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 "{{config.protocol.package}}/{{domain.domain}}.h"
 
 #include "{{config.protocol.package}}/Protocol.h"
 
@@ skipping 132 matching lines @@
     {% endfor %}
   {% endfor %}
 
 // ------------- Frontend notifications.
   {% for event in domain.events %}
     {% if "handlers" in event and not ("renderer" in event["handlers"]) %}{% continue %}{% endif %}
 
 void Frontend::{{event.name}}(
     {%- for parameter in event.parameters %}
       {% if "optional" in parameter -%}
-        {%- if new_style(domain) -%}
         Maybe<{{resolve_type(parameter).raw_type}}>
-        {%- else -%}
-        const Maybe<{{resolve_type(parameter).raw_type}}>&
-        {%- endif -%}
       {%- 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 %}
@@ skipping 62 matching lines @@
     {% if "async" in command %}
 
 class {{command.name | to_title_case}}CallbackImpl : public Backend::{{command.name | to_title_case}}Callback, public DispatcherBase::Callback {
 public:
     {{command.name | to_title_case}}CallbackImpl(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId)
         : DispatcherBase::Callback(std::move(backendImpl), callId) { }
 
     void sendSuccess(
       {%- for parameter in command.returns -%}
         {%- if "optional" in parameter -%}
-          {%- if new_style(domain) -%}
         Maybe<{{resolve_type(parameter).raw_type}}> {{parameter.name}}
-          {%- else -%}
-        const Maybe<{{resolve_type(parameter).raw_type}}>& {{parameter.name}}
-          {%- endif -%}
         {%- 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()));
            {% else %}
         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), DispatchResponse::OK());
     }
 
-      {% if new_style(domain) %}
     void sendFailure(const DispatchResponse& response) override
     {
         DCHECK(response.status() == DispatchResponse::kError);
         sendIfActive(nullptr, response);
     }
-      {% else %}
-    void sendFailure(const ErrorString& error) override
-    {
-        DCHECK(error.length());
-        sendIfActive(nullptr, DispatchResponse::Error(error));
-    }
-      {% endif %}
 };
     {% endif %}
 
 DispatchResponse::Status 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 %}
@@ skipping 21 matching lines @@
         {% if "optional" in property %}
     Maybe<{{resolve_type(property).raw_type}}> out_{{property.name}};
         {% else %}
     {{resolve_type(property).type}} out_{{property.name}};
         {% endif %}
       {% endfor %}
     {% endif %}
 
     {% if not("async" in command) %}
     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
-      {% if not new_style(domain) %}
-    ErrorString error;
-    m_backend->{{command.name}}(&error
-      {%- else %}
     DispatchResponse response = m_backend->{{command.name}}(
-      {%- endif -%}
       {%- for property in command.parameters -%}
-        {%- if not loop.first or not new_style(domain) -%}, {% endif -%}
+        {%- if not loop.first -%}, {% endif -%}
         {%- if "optional" in property -%}
-          {%- if new_style(domain) -%}
         std::move(in_{{property.name}})
-          {%- else -%}
-        in_{{property.name}}
-          {%- endif -%}
         {%- else -%}
         {{resolve_type(property).to_pass_type % ("in_" + property.name)}}
         {%- endif -%}
       {%- endfor %}
       {%- if "returns" in command %}
         {%- for property in command.returns -%}
-          {%- if not loop.first or command.parameters or not new_style(domain) -%}, {% endif -%}
+          {%- if not loop.first or command.parameters -%}, {% endif -%}
           &out_{{property.name}}
         {%- endfor %}
       {% endif %});
-      {% if not new_style(domain) %}
-    DispatchResponse response = error.length() ? DispatchResponse::Error(error) : DispatchResponse::OK();
-      {% 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()));
           {% else %}
         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, response, std::move(result));
       {% else %}
     if (weak->get())
         weak->get()->sendResponse(callId, response);
       {% endif %}
     return response.status();
     {% else %}
     std::unique_ptr<{{command.name | to_title_case}}CallbackImpl> callback(new {{command.name | to_title_case}}CallbackImpl(weakPtr(), callId));
     m_backend->{{command.name}}(
       {%- for property in command.parameters -%}
         {%- if not loop.first -%}, {% endif -%}
         {%- if "optional" in property -%}
-          {%- if new_style(domain) -%}
         std::move(in_{{property.name}})
-          {%- else -%}
-        in_{{property.name}}
-          {%- endif -%}
         {%- else -%}
         {{resolve_type(property).to_pass_type % ("in_" + property.name)}}
         {%- endif -%}
       {%- endfor -%}
         {%- if command.parameters -%}, {% endif -%}
         std::move(callback));
     return DispatchResponse::kAsync;
     {% endif %}
 }
   {% endfor %}
 
 // static
 void Dispatcher::wire(UberDispatcher* dispatcher, Backend* backend)
 {
     dispatcher->registerBackend("{{domain.domain}}", wrapUnique(new DispatcherImpl(dispatcher->channel(), backend)));
 }
 
 } // {{domain.domain}}
 {% for namespace in config.protocol.namespace %}
 } // namespace {{namespace}}
 {% endfor %}