headless: Implement DevTools events

headless/lib/browser/headless_devtools_client_impl.h

 // 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.
 
 #ifndef HEADLESS_LIB_BROWSER_HEADLESS_DEVTOOLS_CLIENT_IMPL_H_
 #define HEADLESS_LIB_BROWSER_HEADLESS_DEVTOOLS_CLIENT_IMPL_H_
 
 #include <unordered_map>
 
 #include "content/public/browser/devtools_agent_host_client.h"
@@ skipping 89 matching lines @@
   void SendMessage(const char* method,
                    std::unique_ptr<base::Value> params,
                    base::Callback<void(const base::Value&)> callback) override;
   void SendMessage(const char* method,
                    std::unique_ptr<base::Value> params,
                    base::Callback<void()> callback) override;
   void SendMessage(const char* method,
                    base::Callback<void(const base::Value&)> callback) override;
   void SendMessage(const char* method,
                    base::Callback<void()> callback) override;
+  void RegisterEventHandler(const char* method,
+                            base::Callback<void()> callback) override;
+  void RegisterEventHandler(
+      const char* method,
+      base::Callback<void(const base::Value&)> callback) override;
 
   void AttachToHost(content::DevToolsAgentHost* agent_host);
   void DetachFromHost(content::DevToolsAgentHost* agent_host);
 
  private:
-  // Represents a message for which we are still waiting for a reply. Contains
-  // a callback with or without a result parameter depending on the message that
-  // is pending.
-  struct PendingMessage {
-    PendingMessage();
-    PendingMessage(PendingMessage&& other);
-    explicit PendingMessage(base::Callback<void()> callback);
-    explicit PendingMessage(base::Callback<void(const base::Value&)> callback);
-    ~PendingMessage();
+  // Contains a callback with or without a result parameter depending on the
+  // message type.
+  struct Callback {
+    Callback();
+    Callback(Callback&& other);
+    explicit Callback(base::Callback<void()> callback);
+    explicit Callback(base::Callback<void(const base::Value&)> callback);
+    ~Callback();
 
-    PendingMessage& operator=(PendingMessage&& other);
+    Callback& operator=(Callback&& other);
 
-    // TODO(skyostil): Use a class union once allowed.
     base::Callback<void()> callback;
     base::Callback<void(const base::Value&)> callback_with_result;
   };
 
   template <typename CallbackType>
   void FinalizeAndSendMessage(base::DictionaryValue* message,
                               CallbackType callback);
 
   template <typename CallbackType>
   void SendMessageWithParams(const char* method,
                              std::unique_ptr<base::Value> params,
                              CallbackType callback);
 
   template <typename CallbackType>
   void SendMessageWithoutParams(const char* method, CallbackType callback);
 
+  bool DispatchMessageReply(const base::DictionaryValue& message_dict);
+  bool DispatchEvent(const base::DictionaryValue& message_dict);
+
   content::DevToolsAgentHost* agent_host_;  // Not owned.
   int next_message_id_;
-  std::unordered_map<int, PendingMessage> pending_messages_;
+  std::unordered_map<int, Callback> pending_messages_;
+  std::unordered_map<std::string, Callback> event_handlers_;
 
   accessibility::Domain accessibility_domain_;
   animation::Domain animation_domain_;
   application_cache::Domain application_cache_domain_;
   cache_storage::Domain cache_storage_domain_;
   console::Domain console_domain_;
   css::Domain css_domain_;
   database::Domain database_domain_;
   debugger::Domain debugger_domain_;
   device_orientation::Domain device_orientation_domain_;
@@ skipping 17 matching lines @@
   service_worker::Domain service_worker_domain_;
   tracing::Domain tracing_domain_;
   worker::Domain worker_domain_;
 
   DISALLOW_COPY_AND_ASSIGN(HeadlessDevToolsClientImpl);
 };
 
 }  // namespace headless
 
 #endif  // HEADLESS_LIB_BROWSER_HEADLESS_DEVTOOLS_CLIENT_IMPL_H_