[DevTools] Various tweaks to inspector_protocol.

third_party/WebKit/Source/platform/inspector_protocol/templates/TypeBuilder_h.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.
 
 #ifndef {{"_".join(config.protocol.namespace)}}_{{domain.domain}}_h
 #define {{"_".join(config.protocol.namespace)}}_{{domain.domain}}_h
 
-#include "{{config.class_export.header}}"
+{% if config.protocol.export_header %}
+#include {{format_include(config.protocol.export_header)}}
+{% endif %}
 #include "{{config.protocol.package}}/Protocol.h"
 // For each imported domain we generate a ValueConversions struct instead of a full domain definition
 // and include Domain::API version from there.
 {% for name in domain.dependencies %}
 #include "{{config.protocol.package}}/{{name}}.h"
 {% endfor %}
 {% if domain["has_exports"] %}
 #include "{{config.exported.package}}/{{domain.domain}}.h"
 {% endif %}
 
@@ skipping 15 matching lines @@
     {% elif type.type != "array" %}
 // {{type.description}}
 using {{type.id}} = {{resolve_type(type).type}};
     {% endif %}
   {% endfor %}
   {% for type in domain.types %}
     {% if "enum" in type %}
 
 namespace {{type.id}}Enum {
       {% for literal in type.enum %}
-{{config.class_export.macro}} extern const char* {{ literal | dash_to_camelcase}};
+{{config.protocol.export_macro}} extern const char* {{ literal | dash_to_camelcase}};
       {% endfor %}
 } // namespace {{type.id}}Enum
     {% endif %}
   {% endfor %}
   {% for command in join_arrays(domain, ["commands", "events"]) %}
     {% for param in join_arrays(command, ["parameters", "returns"]) %}
       {% if "enum" in param %}
 
 namespace {{command.name | to_title_case}} {
 namespace {{param.name | to_title_case}}Enum {
         {% for literal in param.enum %}
-{{config.class_export.macro}} extern const char* {{literal | dash_to_camelcase}};
+{{config.protocol.export_macro}} extern const char* {{literal | dash_to_camelcase}};
         {% endfor %}
 } // {{param.name | to_title_case}}Enum
 } // {{command.name | to_title_case }}
       {% endif %}
     {% endfor %}
   {% endfor %}
 
 // ------------- Type and builder declarations.
   {% for type in domain.types %}
     {% if not (type.type == "object") or not ("properties" in type) %}{% continue %}{% endif %}
     {% set type_def = type_definition(domain.domain + "." + type.id)%}
 
 // {{type.description}}
-class {{config.class_export.macro}} {{type.id}} {% if type.exported %}: public API::{{type.id}} {% endif %}{
+class {{config.protocol.export_macro}} {{type.id}} {% if type.exported %}: public API::{{type.id}} {% endif %}{
     PROTOCOL_DISALLOW_COPY({{type.id}});
 public:
     static std::unique_ptr<{{type.id}}> parse(protocol::Value* value, ErrorSupport* errors);
 
     ~{{type.id}}() { }
     {% for property in type.properties %}
       {% if "enum" in property %}
 
-    struct {{config.class_export.macro}} {{property.name | to_title_case}}Enum {
+    struct {{config.protocol.export_macro}} {{property.name | to_title_case}}Enum {
         {% for literal in property.enum %}
         static const char* {{literal | dash_to_camelcase}};
         {% endfor %}
     }; // {{property.name | to_title_case}}Enum
       {% endif %}
 
       {% if property.optional %}
     bool has{{property.name | to_title_case}}() { return m_{{property.name}}.isJust(); }
     {{resolve_type(property).raw_return_type}} get{{property.name | to_title_case}}({{resolve_type(property).raw_pass_type}} defaultValue) { return m_{{property.name}}.isJust() ? m_{{property.name}}.fromJust() : defaultValue; }
       {% else %}
@@ skipping 82 matching lines @@
       {% else %}
     {{resolve_type(property).type}} m_{{property.name}};
       {% endif %}
     {% endfor %}
 };
 
   {% endfor %}
 
 // ------------- Backend interface.
 
-class {{config.class_export.macro}} Backend {
+class {{config.protocol.export_macro}} Backend {
 public:
   {% 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 {{config.class_export.macro}} {{command.name | to_title_case}}Callback : public BackendCallback {
+    class {{config.protocol.export_macro}} {{command.name | to_title_case}}Callback : public BackendCallback {
     public:
         virtual 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}}
               {%- endif -%}
               {%- if not loop.last -%}, {% endif -%}
             {%- endfor -%}
@@ skipping 30 matching lines @@
   {% if not has_disable(domain.commands) %}
     virtual void disable(ErrorString*) { }
   {% endif %}
 
 protected:
     virtual ~Backend() { }
 };
 
 // ------------- Frontend interface.
 
-class {{config.class_export.macro}} Frontend {
+class {{config.protocol.export_macro}} Frontend {
 public:
     Frontend(FrontendChannel* frontendChannel) : m_frontendChannel(frontendChannel) { }
   {% for event in domain.events %}
     {% if "handlers" in event and not ("renderer" in event["handlers"]) %}{% continue %}{% endif %}
     void {{event.name}}(
     {%- for parameter in event.parameters -%}
       {%- if "optional" in parameter -%}
         const Maybe<{{resolve_type(parameter).raw_type}}>& {{parameter.name}} = Maybe<{{resolve_type(parameter).raw_type}}>()
       {%- else -%}
         {{resolve_type(parameter).pass_type}} {{parameter.name}}
       {%- endif -%}{%- if not loop.last -%}, {% endif -%}
     {%- endfor -%}
     );
   {% endfor %}
 
     void flush();
 private:
     FrontendChannel* m_frontendChannel;
 };
 
 // ------------- Dispatcher.
 
-class {{config.class_export.macro}} Dispatcher {
+class {{config.protocol.export_macro}} Dispatcher {
 public:
     static void wire(UberDispatcher*, Backend*);
 
 private:
     Dispatcher() { }
 };
 
 // ------------- Metainfo.
 
-class {{config.class_export.macro}} Metainfo {
+class {{config.protocol.export_macro}} Metainfo {
 public:
     using BackendClass = Backend;
     using FrontendClass = Frontend;
     using DispatcherClass = Dispatcher;
     static const char domainName[];
     static const char commandPrefix[];
     static const char version[];
 };
 
 } // namespace {{domain.domain}}
 {% for namespace in config.protocol.namespace %}
 } // namespace {{namespace}}
 {% endfor %}
 
 #endif // !defined({{"_".join(config.protocol.namespace)}}_{{domain.domain}}_h)