DevTools: generate frontend and backend interfaces under domains.

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/inspector_protocol/Collections.h"
 #include "platform/inspector_protocol/FrontendChannel.h"
@@ skipping 59 matching lines @@
         return weak;
     }
 
     virtual void dispatch(const String16& message);
     virtual void reportProtocolError(int callId, CommonErrorCode, const String16& errorMessage, ErrorSupport* errors) const;
     using Dispatcher::reportProtocolError;
 
     void sendResponse(int callId, const ErrorString& invocationError, ErrorSupport* errors, std::unique_ptr<protocol::DictionaryValue> result);
 
 {% for domain in api.domains %}
-    virtual void registerAgent(blink::protocol::Backend::{{domain.domain}}* agent) { DCHECK(!m_{{domain.domain | lower}}Agent); m_{{domain.domain | lower}}Agent = agent; }
+    virtual void registerAgent(blink::protocol::{{domain.domain}}::Backend* agent) { DCHECK(!m_{{domain.domain | lower}}Agent); m_{{domain.domain | lower}}Agent = agent; }
 {% endfor %}
 
 private:
     friend class DispatcherCallbackBase;
     friend class DispatcherImplWeakPtr;
     using CallHandler = void (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
     using DispatchMap = protocol::HashMap<String16, CallHandler>;
 
 {% for domain in api.domains %}
   {% for command in domain.commands %}
     {% if "redirect" in command %}{% continue %}{% endif %}
     {% if "handlers" in command and not ("renderer" in command["handlers"]) %}{% continue %}{% endif %}
     void {{domain.domain}}_{{command.name}}(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
   {% endfor %}
 {% endfor %}
 
     FrontendChannel* m_frontendChannel;
 
 {% for domain in api.domains %}
-    Backend::{{domain.domain}}* m_{{domain.domain | lower}}Agent;
+    {{domain.domain}}::Backend* m_{{domain.domain | lower}}Agent;
 {% endfor %}
 
     void sendResponse(int callId, ErrorString invocationError, std::unique_ptr<protocol::DictionaryValue> result)
     {
         sendResponse(callId, invocationError, nullptr, std::move(result));
     }
 
     void sendResponse(int callId, ErrorString invocationError)
     {
         sendResponse(callId, invocationError, nullptr, DictionaryValue::create());
     }
 
     static const char kInvalidRequest[];
 
     DispatchMap m_dispatchMap;
     protocol::Vector<int> m_commonErrors;
     protocol::HashSet<DispatcherImplWeakPtr*> m_weakPtrs;
 };
 
-class PLATFORM_EXPORT DispatcherCallbackBase : public protocol::Backend::CallbackBase {
+class PLATFORM_EXPORT DispatcherCallbackBase : public protocol::BackendCallback {
 public:
     DispatcherCallbackBase(std::unique_ptr<DispatcherImplWeakPtr> backendImpl, int callId)
         : m_backendImpl(std::move(backendImpl)), m_callId(callId) { }
     virtual ~DispatcherCallbackBase() { }
     void dispose() { m_backendImpl = nullptr; }
 
 protected:
     void sendIfActive(std::unique_ptr<protocol::DictionaryValue> partialMessage, const ErrorString& invocationError)
     {
         if (!m_backendImpl->get())
@@ skipping 15 matching lines @@
 
 const char DispatcherImpl::kInvalidRequest[] = "Invalid request";
 
 {% for domain in api.domains %}
   {% 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 %}
 
-class PLATFORM_EXPORT {{domain.domain}}{{command.name | to_title_case}}Callback : public Backend::{{domain.domain}}::{{command.name | to_title_case}}Callback, public DispatcherCallbackBase {
+class PLATFORM_EXPORT {{domain.domain}}{{command.name | to_title_case}}Callback : public {{domain.domain}}::Backend::{{command.name | to_title_case}}Callback, public DispatcherCallbackBase {
 public:
     {{domain.domain}}{{command.name | to_title_case}}Callback(std::unique_ptr<DispatcherImplWeakPtr> backendImpl, int callId)
         : DispatcherCallbackBase(std::move(backendImpl), callId) { }
 
     void sendSuccess(
     {%- for parameter in command.returns -%}
       {%- if "optional" in parameter -%}
         const Maybe<{{resolve_type(parameter).raw_type}}>& {{parameter.name}}
       {%- else -%}
         {{resolve_type(parameter).pass_type}} {{parameter.name}}
@@ skipping 188 matching lines @@
         return false;
 
     if (!object->getString("method", result))
         return false;
 
     return true;
 }
 
 } // namespace protocol
 } // namespace blink