headless: Move hidden commands and events to experimental domains

headless/lib/browser/domain_cc.template

 // 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/{{domain.domain | camelcase_to_hacker_style}}.h"
 
 #include "base/bind.h"
 
 namespace headless {
 
 namespace {{domain.domain | camelcase_to_hacker_style}} {
 
-Domain::Domain(internal::MessageDispatcher* dispatcher)
-    : dispatcher_(dispatcher) {
-  {% if "events" in domain %}
-    {# Register all events in this domain. #}
-    {% for event in domain.events %}
-  dispatcher_->RegisterEventHandler(
-      "{{domain.domain}}.{{event.name}}",
-      base::Bind(&Domain::Dispatch{{event.name | to_title_case}}Event,
-                 base::Unretained(this)));
-    {% endfor %}
-  {% endif %}
+ExperimentalDomain* Domain::GetExperimental() {

[altimin, 2016/04/21 14:49:10]

Nit: const?

[Sami, 2016/04/21 14:51:13]

I thought about it but it doesn't quite work since you usually want to be able
to call commands on the returned object.

+  return static_cast<ExperimentalDomain*>(this);
 }
 
   {% if "events" in domain %}
 void Domain::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);

[dgozman, 2016/04/21 17:30:45]

How do you add an Observer to a list of ExperimentalObservers?

[Sami, 2016/04/21 17:39:01]

It's a bit non-intuitive, but Observer inherits from ExperimentalObserver but
marks all the experimental events as final, so the user can't actually implement
them. This is exactly backwards compared to the agents themselves, where
ExperimentalAgent inherits from Agent, but I couldn't figure out a nicer way to
hide the experimental events from the user.

 }
 
 void Domain::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
   {% endif %}
 
-Domain::~Domain() {}
   {% for command in domain.commands %}
     {# Skip redirected commands. #}
     {% if "redirect" in command %}{% continue %}{% endif %}
 
+    {% set class_name = 'ExperimentalDomain' if command.hidden else 'Domain' %}
     {% set method_name = command.name | to_title_case %}
     {% if "parameters" in command and "returns" in command %}
-void Domain::{{method_name}}(std::unique_ptr<{{method_name}}Params> params, base::Callback<void(std::unique_ptr<{{method_name}}Result>)> callback) {
+void {{class_name}}::{{method_name}}(std::unique_ptr<{{method_name}}Params> params, base::Callback<void(std::unique_ptr<{{method_name}}Result>)> callback) {
   dispatcher_->SendMessage("{{domain.domain}}.{{command.name}}", params->Serialize(), base::Bind(&Domain::Handle{{method_name}}Response, callback));
     {% elif "parameters" in command %}
-void Domain::{{method_name}}(std::unique_ptr<{{method_name}}Params> params, base::Callback<void()> callback) {
+void {{class_name}}::{{method_name}}(std::unique_ptr<{{method_name}}Params> params, base::Callback<void()> callback) {
   dispatcher_->SendMessage("{{domain.domain}}.{{command.name}}", params->Serialize(), std::move(callback));
     {% elif "returns" in command %}
-void Domain::{{method_name}}(base::Callback<void(std::unique_ptr<{{method_name}}Result>)> callback) {
+void {{class_name}}::{{method_name}}(base::Callback<void(std::unique_ptr<{{method_name}}Result>)> callback) {
   dispatcher_->SendMessage("{{domain.domain}}.{{command.name}}", base::Bind(&Domain::Handle{{method_name}}Response, std::move(callback)));
     {% else %}
-void Domain::{{method_name}}(base::Callback<void()> callback) {
+void {{class_name}}::{{method_name}}(base::Callback<void()> callback) {
   dispatcher_->SendMessage("{{domain.domain}}.{{command.name}}", std::move(callback));
     {% endif %}
 }
     {# Generate convenience methods that take the required parameters directly. #}
     {% if not "parameters" in command %}{% continue %}{% endif %}
 
-void Domain::{{method_name}}({##}
+void {{class_name}}::{{method_name}}({##}
     {% for parameter in command.parameters -%}
         {% if parameter.get("optional", False) -%}
           {% break %}
         {% endif %}
         {% if not loop.first %}, {% endif %}
 {{resolve_type(parameter).pass_type}} {{parameter.name | camelcase_to_hacker_style -}}
     {% endfor %}
     {% if "parameters" in command and not command.parameters[0].get("optional", False) %}, {% endif %}{# -#}
     {% if "returns" in command -%}
       base::Callback<void(std::unique_ptr<{{method_name}}Result>)> callback{##}
@@ skipping 34 matching lines @@
 
 {# Generate dispatchers which call registered observers for an event. #}
 void Domain::Dispatch{{event.name | to_title_case}}Event({# -#}
     {% if "parameters" in event %}{# -#}
     const base::Value& params{# -#}
     {% endif %}) {
     {% if "parameters" in event %}
   ErrorReporter errors;
   std::unique_ptr<{{event.name | to_title_case}}Params> parsed_params({{event.name | to_title_case}}Params::Parse(params, &errors));
   DCHECK(!errors.HasErrors());
-  FOR_EACH_OBSERVER(Observer, observers_, On{{event.name | to_title_case}}(*parsed_params));
+  FOR_EACH_OBSERVER(ExperimentalObserver, observers_, On{{event.name | to_title_case}}(*parsed_params));
     {% else %}
-  FOR_EACH_OBSERVER(Observer, observers_, On{{event.name | to_title_case}}());
+  FOR_EACH_OBSERVER(ExperimentalObserver, observers_, On{{event.name | to_title_case}}());
     {% endif %}
 }
   {% endfor %}
 {% endif %}
 
+Domain::Domain(internal::MessageDispatcher* dispatcher)
+    : dispatcher_(dispatcher) {
+  {% if "events" in domain %}
+    {# Register all events in this domain. #}
+    {% for event in domain.events %}
+  dispatcher_->RegisterEventHandler(
+      "{{domain.domain}}.{{event.name}}",
+      base::Bind(&Domain::Dispatch{{event.name | to_title_case}}Event,
+                 base::Unretained(this)));
+    {% endfor %}
+  {% endif %}
+}
+
+Domain::~Domain() {}
+
+ExperimentalDomain::ExperimentalDomain(internal::MessageDispatcher* dispatcher)
+    : Domain(dispatcher) {}
+
+ExperimentalDomain::~ExperimentalDomain() {}
+
+  {% if "events" in domain %}
+void ExperimentalDomain::AddObserver(ExperimentalObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void ExperimentalDomain::RemoveObserver(ExperimentalObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+  {% endif %}
+
 }  // namespace {{domain.domain | camelcase_to_hacker_style}}
 
 } // namespace headless