Call EmbeddedWorkerDevToolsManager::ServiceWorkerCreated, WorkerContextStarted and WorkerDestroyed.

content/browser/service_worker/service_worker_internals_ui.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/service_worker/service_worker_internals_ui.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 66 matching lines @@
 
   void StopActiveWorker(
       ServiceWorkerStatusCode status,
       const scoped_refptr<ServiceWorkerRegistration>& registration);
 
   void DispatchSyncEventToActiveWorker(
       ServiceWorkerStatusCode status,
       const scoped_refptr<ServiceWorkerRegistration>& registration);
 
   void InspectActiveWorker(
-      const base::FilePath& context_path,
+      const ServiceWorkerContextCore* const service_worker_context,
       ServiceWorkerStatusCode status,
       const scoped_refptr<ServiceWorkerRegistration>& registration);
 
-  void InspecteWorkerOnUIThread(const base::FilePath& context_path,
-                                int64 version_id);
+  void InspecteWorkerOnUIThread(
+      const ServiceWorkerContextCore* const service_worker_context,
+      int64 version_id);
 
   WeakPtr<ServiceWorkerInternalsUI> internals_;
   scoped_ptr<ListValue> original_args_;
 };
 
 class ServiceWorkerInternalsUI::PartitionObserver
     : public ServiceWorkerContextObserver {
  public:
   PartitionObserver(int partition_id, WebUI* web_ui)
       : partition_id_(partition_id), web_ui_(web_ui) {}
@@ skipping 377 matching lines @@
 }
 
 void ServiceWorkerInternalsUI::OperationProxy::InspectWorkerOnIOThread(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     const GURL& scope) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   context->context()->storage()->FindRegistrationForPattern(
       scope,
       base::Bind(&ServiceWorkerInternalsUI::OperationProxy::InspectActiveWorker,
                  this,
-                 context->context()->storage_partition_path()));
+                 context->context()));
 }
 
 namespace {
 void UpdateVersionInfo(const ServiceWorkerVersionInfo& version,
                        DictionaryValue* info) {
   switch (version.running_status) {
     case ServiceWorkerVersion::STOPPED:
       info->SetString("running_status", "STOPPED");
       break;
     case ServiceWorkerVersion::STARTING:
@@ skipping 140 matching lines @@
           ServiceWorkerVersion::ACTIVE) {
     registration->active_version()->DispatchSyncEvent(base::Bind(
         &ServiceWorkerInternalsUI::OperationProxy::OperationComplete, this));
     return;
   }
 
   OperationComplete(SERVICE_WORKER_ERROR_FAILED);
 }
 
 void ServiceWorkerInternalsUI::OperationProxy::InspectActiveWorker(
-    const base::FilePath& context_path,
+    const ServiceWorkerContextCore* const service_worker_context,
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (status == SERVICE_WORKER_OK) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&OperationProxy::InspecteWorkerOnUIThread,
                    this,
-                   context_path,
+                   service_worker_context,
                    registration->active_version()->version_id()));
     return;
   }
 
   OperationComplete(status);
 }
 
 void ServiceWorkerInternalsUI::OperationProxy::InspecteWorkerOnUIThread(
-    const base::FilePath& context_path,
+    const ServiceWorkerContextCore* const service_worker_context,
     int64 version_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   scoped_refptr<DevToolsAgentHost> agent_host(
       EmbeddedWorkerDevToolsManager::GetInstance()
-          ->GetDevToolsAgentHostForServiceWorker(context_path, version_id));
+          ->GetDevToolsAgentHostForServiceWorker(service_worker_context,
+                                                 version_id));
   if (agent_host) {
     DevToolsManagerImpl::GetInstance()->Inspect(
         internals_->web_ui()->GetWebContents()->GetBrowserContext(),
         agent_host.get());
     OperationComplete(SERVICE_WORKER_OK);
     return;
   }
   OperationComplete(SERVICE_WORKER_ERROR_NOT_FOUND);
 }
 
 }  // namespace content