DevTools: DevToolsAgentHost::Close/GetURL for service workers

content/browser/devtools/embedded_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/embedded_worker_devtools_agent_host.h"
 
 #include "content/browser/devtools/devtools_manager_impl.h"
 #include "content/browser/devtools/devtools_protocol.h"
 #include "content/browser/devtools/devtools_protocol_constants.h"
+#include "content/browser/service_worker/service_worker_context_core.h"
+#include "content/browser/service_worker/service_worker_version.h"
+#include "content/browser/shared_worker/shared_worker_service_impl.h"
 #include "content/common/devtools_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 
 namespace content {
 
+namespace {
+
+void TerminateSharedWorkerOnIO(
+    EmbeddedWorkerDevToolsAgentHost::WorkerId worker_id) {
+  SharedWorkerServiceImpl::GetInstance()->TerminateWorker(
+      worker_id.first, worker_id.second);
+}
+
+void StatusNoOp(ServiceWorkerStatusCode status) {
+}
+
+void TerminateServiceWorkerOnIO(
+    base::WeakPtr<ServiceWorkerContextCore> context_weak,
+    int64 version_id) {
+  if (ServiceWorkerContextCore* context = context_weak.get()) {
+    if (ServiceWorkerVersion* version = context->GetLiveVersion(version_id))
+      version->StopWorker(base::Bind(&StatusNoOp));
+  }
+}
+
+}
+
 EmbeddedWorkerDevToolsAgentHost::EmbeddedWorkerDevToolsAgentHost(
     WorkerId worker_id,
     const SharedWorkerInstance& shared_worker)
     : shared_worker_(new SharedWorkerInstance(shared_worker)),
       state_(WORKER_UNINSPECTED),
       worker_id_(worker_id) {
   WorkerCreated();
 }
 
 EmbeddedWorkerDevToolsAgentHost::EmbeddedWorkerDevToolsAgentHost(
     WorkerId worker_id,
     const ServiceWorkerIdentifier& service_worker,
     bool debug_service_worker_on_start)
     : service_worker_(new ServiceWorkerIdentifier(service_worker)),
       state_(WORKER_UNINSPECTED),
       worker_id_(worker_id) {
   if (debug_service_worker_on_start)
     state_ = WORKER_PAUSED_FOR_DEBUG_ON_START;
   WorkerCreated();
 }
 
 bool EmbeddedWorkerDevToolsAgentHost::IsWorker() const {
   return true;
 }
 
+GURL EmbeddedWorkerDevToolsAgentHost::GetURL() {
+  if (shared_worker_)
+    return shared_worker_->url();
+  if (service_worker_)
+    return service_worker_->url();
+  return GURL();
+}
+
+bool EmbeddedWorkerDevToolsAgentHost::Close() {
+  if (shared_worker_) {
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+        base::Bind(&TerminateSharedWorkerOnIO, worker_id_));
+    return true;
+  }
+  if (service_worker_) {
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+        base::Bind(&TerminateServiceWorkerOnIO,
+                   service_worker_->context_weak(),
+                   service_worker_->version_id()));
+    return true;
+  }
+  return false;
+}
+
 void EmbeddedWorkerDevToolsAgentHost::SendMessageToAgent(
     IPC::Message* message_raw) {
   scoped_ptr<IPC::Message> message(message_raw);
   if (state_ != WORKER_INSPECTED)
     return;
   if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first)) {
     message->set_routing_id(worker_id_.second);
     host->Send(message.release());
   }
 }
@@ skipping 99 matching lines @@
   DevToolsManagerImpl::GetInstance()->DispatchOnInspectorFrontend(
       this, message);
 }
 
 void EmbeddedWorkerDevToolsAgentHost::OnSaveAgentRuntimeState(
     const std::string& state) {
   saved_agent_state_ = state;
 }
 
 }  // namespace content