[headless] Refactor headless devtools client API.

headless/lib/browser/devtools_api/domain_types_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 HEADLESS_PUBLIC_DOMAINS_TYPES_H_
-#define HEADLESS_PUBLIC_DOMAINS_TYPES_H_
+#ifndef HEADLESS_PUBLIC_DEVTOOLS_DOMAINS_TYPES_{{domain.domain | camelcase_to_hacker_style | upper}}_H_
+#define HEADLESS_PUBLIC_DEVTOOLS_DOMAINS_TYPES_{{domain.domain | camelcase_to_hacker_style | upper}}_H_
 
 #include "base/optional.h"
 #include "base/values.h"
+{% for domain_name in domain.dependencies %}
+#include "headless/public/devtools/internal/types_forward_declaration_{{domain_name | camelcase_to_hacker_style}}.h"
+{% endfor %}
 #include "headless/public/headless_export.h"
 #include "headless/public/util/error_reporter.h"
 
 #include "base/memory/ptr_util.h"
 
 namespace headless {
 
-// ------------- Forward declarations and typedefs.
+namespace {{domain.domain | camelcase_to_hacker_style}} {
+{% for type in domain.types %}
+  {% if not (type.type == "object") or not ("properties" in type) %}{% continue %}{% endif %}
 
-{% for domain in api.domains %}
-
-namespace {{domain.domain | camelcase_to_hacker_style}} {
-  {% for type in domain.types %}
-    {% if type.type == "object" %}
-      {% if "properties" in type %}
-class {{type.id}};
-      {% else %}
-using {{type.id}} = base::Value;
-      {% endif %}
-    {% endif %}
-  {% endfor %}
-}  // namespace {{domain.domain}}
-{% endfor %}
-
-{% for domain in api.domains %}
-namespace {{domain.domain | camelcase_to_hacker_style}} {
-  {% for type in domain.types %}
-    {% if "enum" in type %}
-enum class {{type.id}} {
-      {% for literal in type.enum %}
-  {{ literal | sanitize_literal | dash_to_camelcase | camelcase_to_hacker_style | upper }}{{',' if not loop.last}}
-      {% endfor %}
-};
-
-    {% endif %}
-  {% endfor %}
-}  // namespace {{domain.domain | camelcase_to_hacker_style}}
-
-{% endfor %}
-
-// ------------- Type and builder declarations.
-{% for domain in api.domains %}
-
-namespace {{domain.domain | camelcase_to_hacker_style}} {
-  {% for type in domain.types %}
-    {% if not (type.type == "object") or not ("properties" in type) %}{% continue %}{% endif %}
-
-    {% if type.description %}
+  {% if type.description %}
 // {{type.description}}
-    {% endif %}
+  {% endif %}
 class HEADLESS_EXPORT {{type.id}} {
  public:
   static {{resolve_type(type).pass_type}} Parse(const base::Value& value, ErrorReporter* errors);
   ~{{type.id}}() { }
-    {% for property in type.properties %}
+  {% for property in type.properties %}
 
-    {% if property.description %}
+  {% if property.description %}
   // {{property.description}}
-    {% endif %}
-      {% if property.optional %}
+  {% endif %}
+    {% if property.optional %}
   bool Has{{property.name | to_title_case}}() const { return !!{{property.name | camelcase_to_hacker_style}}_; }
   {{resolve_type(property).raw_return_type}} Get{{property.name | to_title_case}}() const { DCHECK(Has{{property.name | to_title_case}}()); return {{resolve_type(property).to_raw_return_type % ("%s_.value()" % property.name | camelcase_to_hacker_style)}}; }
   void Set{{property.name | to_title_case}}({{resolve_type(property).pass_type}} value) { {{property.name | camelcase_to_hacker_style}}_ = {{resolve_type(property).to_pass_type % 'value'}}; }
-      {% else %}
+    {% else %}
   {{resolve_type(property).raw_return_type}} Get{{property.name | to_title_case}}() const { return {{resolve_type(property).to_raw_return_type % ("%s_" % property.name | camelcase_to_hacker_style)}}; }
   void Set{{property.name | to_title_case}}({{resolve_type(property).pass_type}} value) { {{property.name | camelcase_to_hacker_style}}_ = {{resolve_type(property).to_pass_type % 'value'}}; }
-      {% endif %}
-    {% endfor %}
+    {% endif %}
+  {% endfor %}
 
   std::unique_ptr<base::Value> Serialize() const;
   {{resolve_type(type).pass_type}} Clone() const;
 
   template<int STATE>
   class {{type.id}}Builder {
   public:
     enum {
       kNoFieldsSet = 0,
-    {% set count = 0 %}
-    {% for property in type.properties %}
-      {% if not(property.optional) %}
-        {% set count = count + 1 %}
+  {% set count = 0 %}
+  {% for property in type.properties %}
+    {% if not(property.optional) %}
+      {% set count = count + 1 %}
       k{{property.name | to_title_case}}Set = 1 << {{count}},
-      {% endif %}
-    {% endfor %}
+    {% endif %}
+  {% endfor %}
       kAllRequiredFieldsSet = (
-    {%- for property in type.properties %}
-      {% if not(property.optional) %}k{{property.name | to_title_case}}Set | {%endif %}
-    {% endfor %}0)
+  {%- for property in type.properties %}
+    {% if not(property.optional) %}k{{property.name | to_title_case}}Set | {%endif %}
+  {% endfor %}0)
     };
 
-    {% for property in type.properties %}
-      {% if property.optional %}
+  {% for property in type.properties %}
+    {% if property.optional %}
     {{type.id}}Builder<STATE>& Set{{property.name | to_title_case}}({{resolve_type(property).pass_type}} value) {
       result_->Set{{property.name | to_title_case}}({{resolve_type(property).to_pass_type % 'value'}});
       return *this;
     }
-      {% else %}
+    {% else %}
     {{type.id}}Builder<STATE | k{{property.name | to_title_case}}Set>& Set{{property.name | to_title_case}}({{resolve_type(property).pass_type}} value) {
       static_assert(!(STATE & k{{property.name | to_title_case}}Set), "property {{property.name}} should not have already been set");
       result_->Set{{property.name | to_title_case}}({{resolve_type(property).to_pass_type % 'value'}});
       return CastState<k{{property.name | to_title_case}}Set>();
     }
-      {% endif %}
+    {% endif %}
 
-    {% endfor %}
+  {% endfor %}
     {{resolve_type(type).pass_type}} Build() {
       static_assert(STATE == kAllRequiredFieldsSet, "all required fields should have been set");
       return std::move(result_);
     }
 
    private:
     friend class {{type.id}};
     {{type.id}}Builder() : result_(new {{type.id}}()) { }
 
     template<int STEP> {{type.id}}Builder<STATE | STEP>& CastState() {
       return *reinterpret_cast<{{type.id}}Builder<STATE | STEP>*>(this);
     }
 
     {{resolve_type(type).type}} result_;
   };
 
   static {{type.id}}Builder<0> Builder() {
     return {{type.id}}Builder<0>();
   }
 
  private:
   {{type.id}}() { }
 
-    {% for property in type.properties %}
-      {% if property.optional %}
+  {% for property in type.properties %}
+    {% if property.optional %}
   base::Optional<{{resolve_type(property).type}}> {{property.name | camelcase_to_hacker_style}}_;
-      {% else %}
+    {% else %}
   {{resolve_type(property).type}} {{property.name | camelcase_to_hacker_style}}_;
-      {% endif %}
-    {% endfor %}
+    {% endif %}
+  {% endfor %}
 
   DISALLOW_COPY_AND_ASSIGN({{type.id}});
 };
 
-  {% endfor %}
+{% endfor %}
 
 }  // namespace {{domain.domain | camelcase_to_hacker_style}}
-{% endfor %}
 
 }  // namespace headless
 
-#endif  // HEADLESS_PUBLIC_DOMAINS_TYPES_H_
+#endif  // HEADLESS_PUBLIC_DEVTOOLS_DOMAINS_TYPES_{{domain.domain | camelcase_to_hacker_style | upper}}_H_