[DevTools] Generate public versions of protocol classes to be exposed in v8_inspector/public.

third_party/WebKit/Source/platform/inspector_protocol/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 protocol_{{domain.domain}}_h
 #define protocol_{{domain.domain}}_h
 
 {% if export_macro == "PLATFORM_EXPORT" %}
 #include "platform/inspector_protocol/Platform.h"
 {% else %}
 #include "core/CoreExport.h"
 {% endif %}
 #include "platform/inspector_protocol/Array.h"
 #include "platform/inspector_protocol/BackendCallback.h"
 #include "platform/inspector_protocol/DispatcherBase.h"
 #include "platform/inspector_protocol/ErrorSupport.h"
 #include "platform/inspector_protocol/FrontendChannel.h"
 #include "platform/inspector_protocol/Maybe.h"
 #include "platform/inspector_protocol/Object.h"
 #include "platform/inspector_protocol/Platform.h"
 #include "platform/inspector_protocol/String16.h"
 #include "platform/inspector_protocol/Values.h"
 #include "platform/inspector_protocol/ValueConversions.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 "{{output_package}}/{{name}}.h"
 {% endfor %}
+{% if domain["has_exports"] %}
+#include "{{exported_package}}/{{domain.domain}}.h"
+{% endif %}
 
 namespace blink {
 namespace protocol {
 namespace {{domain.domain}} {
 
 // ------------- Forward and enum declarations.
   {% for type in domain.types %}
     {% if type.type == "object" %}
       {% if "properties" in type %}
 // {{type.description}}
 class {{type.id}};
       {% else %}
 // {{type.description}}
 using {{type.id}} = Object;
       {% endif %}
     {% 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 %}
 {{export_macro}} extern const char* {{ literal | dash_to_camelcase}};
       {% endfor %}
-} // {{type.id}}Enum
+} // 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 %}
 {{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 {{export_macro}} {{type.id}} {
+class {{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 {{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 %}
     {{resolve_type(property).raw_return_type}} get{{property.name | to_title_case}}() { return {{resolve_type(property).to_raw_type % ("m_" + property.name)}}; }
       {% endif %}
     void set{{property.name | to_title_case}}({{resolve_type(property).pass_type}} value) { m_{{property.name}} = {{resolve_type(property).to_rvalue % "value"}}; }
     {% endfor %}
 
     std::unique_ptr<protocol::DictionaryValue> serialize() const;
     std::unique_ptr<{{type.id}}> clone() const;
+    {% if type.exported %}
+    String16 toJSONString() const override;
+    {% endif %}
 
     template<int STATE>
     class {{type.id}}Builder {
     public:
         enum {
             NoFieldsSet = 0,
     {% set count = 0 %}
     {% for property in type.properties %}
       {% if not(property.optional) %}
         {% set count = count + 1 %}
@@ skipping 160 matching lines @@
     using FrontendClass = Frontend;
     using DispatcherClass = Dispatcher;
     static const char domainName[];
 };
 
 } // namespace {{domain.domain}}
 } // namespace protocol
 } // namespace blink
 
 #endif // !defined(protocol_{{domain.domain}}_h)