headless: Implement client API generation

headless/lib/browser/types_cc.template

Index: headless/lib/browser/types_cc.template
diff --git a/headless/lib/browser/types_cc.template b/headless/lib/browser/types_cc.template
new file mode 100644
index 0000000000000000000000000000000000000000..1c2d6b81462b47bfa1334ecc5ad25040fbe9a50c
--- /dev/null
+++ b/headless/lib/browser/types_cc.template
@@ -0,0 +1,130 @@
+// This file is generated
+
+// Copyright 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 "headless/public/domains/types.h"
+
+#include "base/memory/ptr_util.h"
+#include "headless/public/domains/type_conversions.h"
+
+namespace headless {
+
+// ------------- Enum values from types.
+{% for domain in api.domains %}
+  {% continue %}
+
+namespace internal {
+
+  {% for type in domain.types %}
+// {{type}}
+    {% if type.type == "array" %}
+template <>
+struct FromValue<{{resolve_type(type).raw_type}}> {
+  static {{resolve_type(type).raw_type}} Parse(const base::Value& value, ErrorReporter* errors) {
+    {{resolve_type(type).raw_type}} result;
+    const base::ListValue* list;
+    if (!value.GetAsList(&list)) {
+      errors->AddError("list value expected");
+      return result;
+    }
+    errors->Push();
+    for (const auto& item : *list)
+      result.push_back(FromValue<{{resolve_type(type).raw_type}}::value_type>::Parse(*item, errors));
+    errors->Pop();
+    return result;
+  }
+};
+
+      {% continue %}
+    {% endif %}
+#}
+    {% if not (type.type == "object") or not ("properties" in type) %}{% continue %}{% endif %}
+    {% set namespace = domain.domain | camelcase_to_hacker_style %}
+template <>
+struct FromValue<{{namespace}}::{{type.id}}> {
+  static std::unique_ptr<{{namespace}}::{{type.id}}> Parse(const base::Value& value, ErrorReporter* errors) {
+    return {{namespace}}::{{type.id}}::Parse(value, errors);
+  }
+};
+
+template <typename T>
+std::unique_ptr<base::Value> ToValueImpl(const {{namespace}}::{{type.id}}& value, T*) {
+  return value.Serialize();
+}
+
+  {% endfor %}
+}  // namespace internal
+{% endfor %}
+
+{% 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 %}
+
+std::unique_ptr<{{type.id}}> {{type.id}}::Parse(const base::Value& value, ErrorReporter* errors) {
+  errors->Push();
+  errors->SetName("{{type.id}}");
+  const base::DictionaryValue* object;
+  if (!value.GetAsDictionary(&object)) {
+    errors->AddError("object expected");
+    errors->Pop();
+    return nullptr;
+  }
+
+  std::unique_ptr<{{type.id}}> result(new {{type.id}}());
+  errors->Push();
+  errors->SetName("{{type.id}}");
+    {% for property in type.properties %}
+      {% set value_name = property.name | camelcase_to_hacker_style + "_value" %}
+  const base::Value* {{value_name}};
+  if (object->Get("{{property.name}}", &{{value_name}})) {
+    errors->SetName("{{property.name}}");
+      {% if property.optional %}
+    result->{{property.name | camelcase_to_hacker_style}}_ = Just(internal::FromValue<{{resolve_type(property).raw_type}}>::Parse(*{{value_name}}, errors));
+      {% else %}
+    result->{{property.name | camelcase_to_hacker_style}}_ = internal::FromValue<{{resolve_type(property).raw_type}}>::Parse(*{{value_name}}, errors);
+      {% endif %}
+      {% if property.optional %}
+  }
+      {% else %}
+  } else {
+    errors->AddError("required property missing: {{property.name}}");
+  }
+      {% endif %}
+    {% endfor %}
+  errors->Pop();
+  errors->Pop();
+  if (errors->HasErrors())
+    return nullptr;
+  return result;
+}
+
+std::unique_ptr<base::Value> {{type.id}}::Serialize() const {
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
+    {% for property in type.properties %}
+      {% set type = resolve_type(property) %}
+      {% if property.optional %}
+  if ({{property.name | camelcase_to_hacker_style}}_.IsJust())
+    result->Set("{{property.name}}", internal::ToValue({{type.to_raw_type % ("%s_.FromJust()" % property.name | camelcase_to_hacker_style)}}));
+      {% else %}
+  result->Set("{{property.name}}", internal::ToValue({{type.to_raw_type % ("%s_" % property.name | camelcase_to_hacker_style)}}));
+      {% endif %}
+    {% endfor %}
+  return std::move(result);
+}
+
+std::unique_ptr<{{type.id}}> {{type.id}}::Clone() const {
+  ErrorReporter errors;
+  std::unique_ptr<{{type.id}}> result = Parse(*Serialize(), &errors);
+  DCHECK(!errors.HasErrors());
+  return result;
+}
+
+  {% endfor %}
+}  // namespace {{domain.domain | camelcase_to_hacker_style}}
+{% endfor %}
+
+} // namespace headless