headless: Register event handlers on demand

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}} {
 
 ExperimentalDomain* Domain::GetExperimental() {
   return static_cast<ExperimentalDomain*>(this);
 }
 
   {% if "events" in domain %}
 void Domain::AddObserver(Observer* observer) {
+  RegisterEventHandlersIfNeeded();
   observers_.AddObserver(observer);
 }
 
 void Domain::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
+
+void Domain::RegisterEventHandlersIfNeeded() {
+  if (event_handlers_registered_)
+    return;
+  event_handlers_registered_ = true;
+    {# 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 %}
 
   {% for command in domain.commands %}
     {# Skip redirected commands. #}
     {% if "redirect" in command %}{% continue %}{% endif %}
 
     {% set class_name = 'ExperimentalDomain' if command.experimental else 'Domain' %}
     {% set method_name = command.name | to_title_case %}
 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));
@@ skipping 67 matching lines @@
   DCHECK(!errors.HasErrors());
   for (ExperimentalObserver& observer : observers_) {
     observer.On{{event.name | to_title_case}}(*parsed_params);
   }
 }
   {% 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) {
+  RegisterEventHandlersIfNeeded();
   observers_.AddObserver(observer);
 }
 
 void ExperimentalDomain::RemoveObserver(ExperimentalObserver* observer) {
   observers_.RemoveObserver(observer);
 }
   {% endif %}
 
 }  // namespace {{domain.domain | camelcase_to_hacker_style}}
 
 } // namespace headless