HeadlessDevToolsClientImpl::DispatchEvent to post a task

headless/lib/browser/headless_devtools_client_impl.cc

 // 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/lib/browser/headless_devtools_client_impl.h"
 
 #include <memory>
 
+#include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 
 namespace headless {
 
 // static
 std::unique_ptr<HeadlessDevToolsClient> HeadlessDevToolsClient::Create() {
   return base::WrapUnique(new HeadlessDevToolsClientImpl());
 }
 
 // static
@@ skipping 30 matching lines @@
       log_domain_(this),
       memory_domain_(this),
       network_domain_(this),
       page_domain_(this),
       profiler_domain_(this),
       rendering_domain_(this),
       runtime_domain_(this),
       security_domain_(this),
       service_worker_domain_(this),
       tracing_domain_(this),
-      worker_domain_(this) {}
+      worker_domain_(this),
+      browser_main_thread_(content::BrowserThread::GetTaskRunnerForThread(
+          content::BrowserThread::UI)),
+      weak_ptr_factory_(this) {}
 
 HeadlessDevToolsClientImpl::~HeadlessDevToolsClientImpl() {}
 
 void HeadlessDevToolsClientImpl::AttachToHost(
     content::DevToolsAgentHost* agent_host) {
   DCHECK(!agent_host_);
   agent_host_ = agent_host;
   agent_host_->AttachClient(this);
 }
 
 void HeadlessDevToolsClientImpl::DetachFromHost(
     content::DevToolsAgentHost* agent_host) {
   DCHECK_EQ(agent_host_, agent_host);
   agent_host_->DetachClient(this);
   agent_host_ = nullptr;
   pending_messages_.clear();
 }
 
 void HeadlessDevToolsClientImpl::DispatchProtocolMessage(
     content::DevToolsAgentHost* agent_host,
     const std::string& json_message) {
   DCHECK_EQ(agent_host_, agent_host);
   std::unique_ptr<base::Value> message =
       base::JSONReader::Read(json_message, base::JSON_PARSE_RFC);
   const base::DictionaryValue* message_dict;
   if (!message || !message->GetAsDictionary(&message_dict)) {
     NOTREACHED() << "Badly formed reply";
     return;
   }
-  if (!DispatchMessageReply(*message_dict) && !DispatchEvent(*message_dict))
+  if (!DispatchMessageReply(*message_dict) &&
+      !DispatchEvent(std::move(message), *message_dict)) {
     DLOG(ERROR) << "Unhandled protocol message: " << json_message;
+  }
 }
 
 bool HeadlessDevToolsClientImpl::DispatchMessageReply(
     const base::DictionaryValue& message_dict) {
   int id = 0;
   if (!message_dict.GetInteger("id", &id))
     return false;
   auto it = pending_messages_.find(id);
   if (it == pending_messages_.end()) {
     NOTREACHED() << "Unexpected reply";
     return false;
   }
   Callback callback = std::move(it->second);
   pending_messages_.erase(it);
   if (!callback.callback_with_result.is_null()) {
     const base::DictionaryValue* result_dict;
     if (!message_dict.GetDictionary("result", &result_dict)) {
       NOTREACHED() << "Badly formed reply result";
       return false;
     }
     callback.callback_with_result.Run(*result_dict);
   } else if (!callback.callback.is_null()) {
     callback.callback.Run();
   }
   return true;
 }
 
 bool HeadlessDevToolsClientImpl::DispatchEvent(
+    std::unique_ptr<base::Value> owning_message,
     const base::DictionaryValue& message_dict) {
   std::string method;
   if (!message_dict.GetString("method", &method))
     return false;
-  auto it = event_handlers_.find(method);
+  EventHandlerMap::const_iterator it = event_handlers_.find(method);
   if (it == event_handlers_.end()) {
     NOTREACHED() << "Unknown event: " << method;
     return false;
   }
   if (!it->second.is_null()) {
     const base::DictionaryValue* result_dict;
     if (!message_dict.GetDictionary("params", &result_dict)) {
       NOTREACHED() << "Badly formed event parameters";
       return false;
     }
-    it->second.Run(*result_dict);
+    // DevTools assumes event handling is async so we must post a task here or
+    // we risk breaking things.
+    browser_main_thread_->PostTask(
+        FROM_HERE, base::Bind(&HeadlessDevToolsClientImpl::DispatchEventTask,
+                              weak_ptr_factory_.GetWeakPtr(),
+                              base::Passed(std::move(owning_message)),
+                              &it->second, result_dict));
   }
   return true;
 }
 
+void HeadlessDevToolsClientImpl::DispatchEventTask(
+    std::unique_ptr<base::Value> owning_message,
+    const EventHandler* event_handler,
+    const base::DictionaryValue* result_dict) {
+  event_handler->Run(*result_dict);
+}
+
 void HeadlessDevToolsClientImpl::AgentHostClosed(
     content::DevToolsAgentHost* agent_host,
     bool replaced_with_another_client) {
   DCHECK_EQ(agent_host_, agent_host);
   agent_host = nullptr;
   pending_messages_.clear();
 }
 
 accessibility::Domain* HeadlessDevToolsClientImpl::GetAccessibility() {
   return &accessibility_domain_;
@@ skipping 194 matching lines @@
 HeadlessDevToolsClientImpl::Callback::Callback(
     base::Callback<void(const base::Value&)> callback)
     : callback_with_result(callback) {}
 
 HeadlessDevToolsClientImpl::Callback::~Callback() {}
 
 HeadlessDevToolsClientImpl::Callback& HeadlessDevToolsClientImpl::Callback::
 operator=(Callback&& other) = default;
 
 }  // namespace headless