DevTools: Enable network emulation on Service Workers

content/browser/devtools/service_worker_devtools_agent_host.cc

 // Copyright 2014 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 "content/browser/devtools/service_worker_devtools_agent_host.h"
 
+#include "base/json/json_writer.h"
 #include "base/strings/stringprintf.h"
+#include "content/browser/devtools/devtools_manager.h"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 #include "content/browser/devtools/service_worker_devtools_manager.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/devtools_manager_delegate.h"
 #include "content/public/browser/render_process_host.h"
 
 namespace content {
 
 namespace {
 
 void StatusNoOp(ServiceWorkerStatusCode status) {}
 
 void TerminateServiceWorkerOnIO(
     base::WeakPtr<ServiceWorkerContextCore> context_weak,
@@ skipping 25 matching lines @@
       version->SetDevToolsAttached(attached);
   }
 }
 
 }  // namespace
 
 ServiceWorkerDevToolsAgentHost::ServiceWorkerDevToolsAgentHost(
     WorkerId worker_id,
     const ServiceWorkerIdentifier& service_worker)
     : WorkerDevToolsAgentHost(worker_id),
-      service_worker_(new ServiceWorkerIdentifier(service_worker)) {
+      service_worker_(new ServiceWorkerIdentifier(service_worker)),
+      protocol_handler_(new DevToolsProtocolHandler(
+          base::Bind(
+              &ServiceWorkerDevToolsAgentHost::DispatchOnInspectorFrontend,
+              base::Unretained(this)))) {
 }
 
 DevToolsAgentHost::Type ServiceWorkerDevToolsAgentHost::GetType() {
   return TYPE_SERVICE_WORKER;
 }
 
 std::string ServiceWorkerDevToolsAgentHost::GetTitle() {
   if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id().first)) {
     return base::StringPrintf("Worker pid:%d",
                               base::GetProcId(host->GetHandle()));
@@ skipping 17 matching lines @@
   return true;
 }
 
 void ServiceWorkerDevToolsAgentHost::UnregisterWorker() {
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
       base::Bind(&UnregisterServiceWorkerOnIO,
                   service_worker_->context_weak(),
                   service_worker_->version_id()));
 }
 
+void ServiceWorkerDevToolsAgentHost::DispatchProtocolMessage(

[pfeldman, 2015/03/23 09:05:25]

Lets have this implemented in the devtools_agent_host_impl so that all
implementations could benefit from this. Subclasses will register their
dispatchers in the protected protocol handler. It should return boolean to
specify whether it handled anything.

+    const std::string& message) {
+  scoped_ptr<base::DictionaryValue> command =
+      protocol_handler_->ParseCommand(message);
+  if (!command)
+    return;
+
+  DevToolsManagerDelegate* delegate =
+      DevToolsManager::GetInstance()->delegate();
+  if (delegate) {
+    scoped_ptr<base::DictionaryValue> response(
+        delegate->HandleCommand(this, command.get()));
+    if (response) {
+      std::string json_response;
+      base::JSONWriter::Write(response.get(), &json_response);
+      DispatchOnInspectorFrontend(json_response);
+      return;
+    }
+  }
+
+  if (protocol_handler_->HandleOptionalCommand(command.Pass()))
+    return;
+
+  IPCDevToolsAgentHost::DispatchProtocolMessage(message);
+}
+
 void ServiceWorkerDevToolsAgentHost::OnClientAttached() {
   WorkerDevToolsAgentHost::OnClientAttached();
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
       base::Bind(&SetDevToolsAttachedOnIO,
                   service_worker_->context_weak(),
                   service_worker_->version_id(),
                   true));
 }
 
 void ServiceWorkerDevToolsAgentHost::OnClientDetached() {
   WorkerDevToolsAgentHost::OnClientDetached();
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
       base::Bind(&SetDevToolsAttachedOnIO,
                   service_worker_->context_weak(),
                   service_worker_->version_id(),
                   false));
 }
 
 bool ServiceWorkerDevToolsAgentHost::Matches(
     const ServiceWorkerIdentifier& other) {
   return service_worker_->Matches(other);
 }
 
+void ServiceWorkerDevToolsAgentHost::DispatchOnInspectorFrontend(
+    const std::string& message) {
+  if (!IsAttached())
+    return;
+  SendMessageToClient(message);
+}
+
 ServiceWorkerDevToolsAgentHost::~ServiceWorkerDevToolsAgentHost() {
   ServiceWorkerDevToolsManager::GetInstance()->RemoveInspectedWorkerData(
       worker_id());
 }
 
 }  // namespace content