Add "inspect" button to chrome://serviceworker-internals.

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"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
+#include "content/browser/devtools/devtools_manager_impl.h"
+#include "content/browser/devtools/embedded_worker_devtools_manager.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
@@ skipping 24 matching lines @@
                                   const base::FilePath& context_path);
   void UnregisterOnIOThread(scoped_refptr<ServiceWorkerContextWrapper> context,
                             const GURL& scope);
   void StartWorkerOnIOThread(scoped_refptr<ServiceWorkerContextWrapper> context,
                              const GURL& scope);
   void StopWorkerOnIOThread(scoped_refptr<ServiceWorkerContextWrapper> context,
                             const GURL& scope);
   void DispatchSyncEventToWorkerOnIOThread(
       scoped_refptr<ServiceWorkerContextWrapper> context,
       const GURL& scope);
+  void InspectWorkerOnIOThread(
+      scoped_refptr<ServiceWorkerContextWrapper> context,
+      const GURL& scope);
 
  private:
   friend class base::RefCountedThreadSafe<OperationProxy>;
   ~OperationProxy() {}
   void OnHaveRegistrations(
       int partition_id,
       const base::FilePath& context_path,
       const std::vector<ServiceWorkerRegistrationInfo>& registrations);
 
   void OperationComplete(ServiceWorkerStatusCode status);
 
   void StartActiveWorker(
       ServiceWorkerStatusCode status,
       const scoped_refptr<ServiceWorkerRegistration>& registration);
 
   void StopActiveWorker(
       ServiceWorkerStatusCode status,
       const scoped_refptr<ServiceWorkerRegistration>& registration);
 
   void DispatchSyncEventToActiveWorker(
       ServiceWorkerStatusCode status,
       const scoped_refptr<ServiceWorkerRegistration>& registration);
 
+  void InspectActiveWorker(
+      const ServiceWorkerContextCore* const service_worker_context,
+      ServiceWorkerStatusCode status,
+      const scoped_refptr<ServiceWorkerRegistration>& registration);
+
+  void InspectWorkerOnUIThread(
+      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) {}
   virtual ~PartitionObserver() {}
@@ skipping 111 matching lines @@
       base::Bind(&ServiceWorkerInternalsUI::StopWorker,
                  base::Unretained(this)));
   web_ui->RegisterMessageCallback(
       "unregister",
       base::Bind(&ServiceWorkerInternalsUI::Unregister,
                  base::Unretained(this)));
   web_ui->RegisterMessageCallback(
       "sync",
       base::Bind(&ServiceWorkerInternalsUI::DispatchSyncEventToWorker,
                  base::Unretained(this)));
+  web_ui->RegisterMessageCallback(
+      "inspect",
+      base::Bind(&ServiceWorkerInternalsUI::InspectWorker,
+                 base::Unretained(this)));
 }
 
 ServiceWorkerInternalsUI::~ServiceWorkerInternalsUI() {
   BrowserContext* browser_context =
       web_ui()->GetWebContents()->GetBrowserContext();
   // Safe to use base::Unretained(this) because
   // ForEachStoragePartition is synchronous.
   BrowserContext::StoragePartitionCallback remove_observer_cb =
       base::Bind(&ServiceWorkerInternalsUI::RemoveObserverFromStoragePartition,
                  base::Unretained(this));
@@ skipping 108 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&ServiceWorkerInternalsUI::OperationProxy::
                      DispatchSyncEventToWorkerOnIOThread,
                  new OperationProxy(AsWeakPtr(), args_copy.Pass()),
                  context,
                  scope));
 }
 
+void ServiceWorkerInternalsUI::InspectWorker(const ListValue* args) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  base::FilePath partition_path;
+  GURL scope;
+  scoped_refptr<ServiceWorkerContextWrapper> context;
+  if (!GetRegistrationInfo(args, &partition_path, &scope, &context))
+    return;
+  scoped_ptr<ListValue> args_copy(args->DeepCopy());
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(
+          &ServiceWorkerInternalsUI::OperationProxy::InspectWorkerOnIOThread,
+          new OperationProxy(AsWeakPtr(), args_copy.Pass()),
+          context,
+          scope));
+}
+
 void ServiceWorkerInternalsUI::Unregister(const ListValue* args) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::FilePath partition_path;
   GURL scope;
   scoped_refptr<ServiceWorkerContextWrapper> context;
   if (!GetRegistrationInfo(args, &partition_path, &scope, &context))
     return;
 
   scoped_ptr<ListValue> args_copy(args->DeepCopy());
   BrowserThread::PostTask(
@@ skipping 96 matching lines @@
     scoped_refptr<ServiceWorkerContextWrapper> context,
     const GURL& scope) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   context->context()->storage()->FindRegistrationForPattern(
       scope,
       base::Bind(&ServiceWorkerInternalsUI::OperationProxy::
                      DispatchSyncEventToActiveWorker,
                  this));
 }
 
+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()));
+}
+
 namespace {
 void UpdateVersionInfo(const ServiceWorkerVersionInfo& version,
                        DictionaryValue* info) {
   switch (version.running_status) {
     case ServiceWorkerVersion::STOPPED:
       info->SetString("running_status", "STOPPED");
       break;
     case ServiceWorkerVersion::STARTING:
       info->SetString("running_status", "STARTING");
       break;
@@ skipping 137 matching lines @@
       registration->active_version()->status() ==
           ServiceWorkerVersion::ACTIVE) {
     registration->active_version()->DispatchSyncEvent(base::Bind(
         &ServiceWorkerInternalsUI::OperationProxy::OperationComplete, this));
     return;
   }
 
   OperationComplete(SERVICE_WORKER_ERROR_FAILED);
 }
 
+void ServiceWorkerInternalsUI::OperationProxy::InspectActiveWorker(
+    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::InspectWorkerOnUIThread,
+                   this,
+                   service_worker_context,
+                   registration->active_version()->version_id()));
+    return;
+  }
+
+  OperationComplete(status);
+}
+
+void ServiceWorkerInternalsUI::OperationProxy::InspectWorkerOnUIThread(
+    const ServiceWorkerContextCore* const service_worker_context,
+    int64 version_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  scoped_refptr<DevToolsAgentHost> agent_host(
+      EmbeddedWorkerDevToolsManager::GetInstance()
+          ->GetDevToolsAgentHostForServiceWorker(
+              EmbeddedWorkerDevToolsManager::ServiceWorkerIdentifier(
+                  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