[DevTools] Introduce Unregister/Start/Stop/Inspect buttons to ServiceWorkersView [1/2 chromium]

1/2 chromium: this cl
2/2 blink: https://codereview.chromium.org/1023293004/

Screen shot: https://code.google.com/p/chromium/issues/detail?id=466871#c9
BUG=466871

Review URL: https://codereview.chromium.org/1029553002

Cr-Commit-Position: refs/heads/master@{#321920}

content/browser/devtools/protocol/service_worker_handler.cc

@@ -12,6 +12,7 @@
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
+#include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_watcher.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_version.h"
@@ -32,19 +33,14 @@ namespace content {
 namespace devtools {
 namespace service_worker {
 
-namespace {
+using Response = DevToolsProtocolClient::Response;
 
-const char kServiceWorkerVersionRunningStatusStopped[] = "stopped";
-const char kServiceWorkerVersionRunningStatusStarting[] = "starting";
-const char kServiceWorkerVersionRunningStatusRunning[] = "running";
-const char kServiceWorkerVersionRunningStatusStopping[] = "stopping";
+namespace {
 
-const char kServiceWorkerVersionStatusNew[] = "new";
-const char kServiceWorkerVersionStatusInstalling[] = "installing";
-const char kServiceWorkerVersionStatusInstalled[] = "installed";
-const char kServiceWorkerVersionStatusActivating[] = "activating";
-const char kServiceWorkerVersionStatusActivated[] = "activated";
-const char kServiceWorkerVersionStatusRedundant[] = "redundant";
+void ResultNoOp(bool success) {
+}
+void StatusNoOp(ServiceWorkerStatusCode status) {
+}
 
 const std::string GetVersionRunningStatusString(
     content::ServiceWorkerVersion::RunningStatus running_status) {
@@ -145,9 +141,43 @@ bool CollectURLs(std::set<GURL>* urls, FrameTreeNode* tree_node) {
   return false;
 }
 
-}  // namespace
+void StopServiceWorkerOnIO(scoped_refptr<ServiceWorkerContextWrapper> context,
+                           int64 version_id) {
+  ServiceWorkerContextCore* context_core = context->context();
+  if (!context_core)
+    return;
+  if (content::ServiceWorkerVersion* version =
+          context_core->GetLiveVersion(version_id)) {
+    version->StopWorker(base::Bind(&StatusNoOp));
+  }
+}
 
-using Response = DevToolsProtocolClient::Response;
+void GetDevToolsRouteInfoOnIO(
+    scoped_refptr<ServiceWorkerContextWrapper> context,
+    int64 version_id,
+    const base::Callback<void(int, int)>& callback) {
+  ServiceWorkerContextCore* context_core = context->context();
+  if (!context_core)
+    return;
+  if (content::ServiceWorkerVersion* version =
+          context_core->GetLiveVersion(version_id)) {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(
+            callback, version->embedded_worker()->process_id(),
+            version->embedded_worker()->worker_devtools_agent_route_id()));
+  }
+}
+
+Response CreateContextErrorResoponse() {
+  return Response::InternalError("Could not connect to the context");
+}
+
+Response CreateInvalidVersionIdErrorResoponse() {
+  return Response::InternalError("Invalid version ID");
+}
+
+}  // namespace
 
 ServiceWorkerHandler::ServiceWorkerHandler()
     : enabled_(false), weak_factory_(this) {
@@ -260,6 +290,64 @@ Response ServiceWorkerHandler::Stop(
   return Response::OK();
 }
 
+Response ServiceWorkerHandler::Unregister(const std::string& scope_url) {
+  if (!enabled_)
+    return Response::OK();
+  if (!context_)
+    return CreateContextErrorResoponse();
+  context_->UnregisterServiceWorker(GURL(scope_url), base::Bind(&ResultNoOp));
+  return Response::OK();
+}
+
+Response ServiceWorkerHandler::StartWorker(const std::string& scope_url) {
+  if (!enabled_)
+    return Response::OK();
+  if (!context_)
+    return CreateContextErrorResoponse();
+  context_->StartServiceWorker(GURL(scope_url), base::Bind(&StatusNoOp));
+  return Response::OK();
+}
+
+Response ServiceWorkerHandler::StopWorker(const std::string& version_id) {
+  if (!enabled_)
+    return Response::OK();
+  if (!context_)
+    return CreateContextErrorResoponse();
+  int64 id = 0;
+  if (!base::StringToInt64(version_id, &id))
+    return CreateInvalidVersionIdErrorResoponse();
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&StopServiceWorkerOnIO, context_, id));
+  return Response::OK();
+}
+
+Response ServiceWorkerHandler::InspectWorker(const std::string& version_id) {
+  if (!enabled_)
+    return Response::OK();
+  if (!context_)
+    return CreateContextErrorResoponse();
+
+  int64 id = 0;
+  if (!base::StringToInt64(version_id, &id))
+    return CreateInvalidVersionIdErrorResoponse();
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&GetDevToolsRouteInfoOnIO, context_, id,
+                 base::Bind(&ServiceWorkerHandler::OpenNewDevToolsWindow,
+                            weak_factory_.GetWeakPtr())));
+  return Response::OK();
+}
+
+void ServiceWorkerHandler::OpenNewDevToolsWindow(int process_id,
+                                                 int devtools_agent_route_id) {
+  scoped_refptr<DevToolsAgentHostImpl> agent_host(
+      ServiceWorkerDevToolsManager::GetInstance()
+          ->GetDevToolsAgentHostForWorker(process_id, devtools_agent_route_id));
+  if (!agent_host.get())
+    return;
+  agent_host->Inspect(render_frame_host_->GetProcess()->GetBrowserContext());
+}
+
 void ServiceWorkerHandler::OnWorkerRegistrationUpdated(
     const std::vector<ServiceWorkerRegistrationInfo>& registrations) {
   std::vector<scoped_refptr<ServiceWorkerRegistration>> registration_values;

content/browser/devtools/protocol/service_worker_handler.h

@@ -48,6 +48,10 @@ class ServiceWorkerHandler : public DevToolsAgentHostClient,
   Response SendMessage(const std::string& worker_id,
                        const std::string& message);
   Response Stop(const std::string& worker_id);
+  Response Unregister(const std::string& scope_url);
+  Response StartWorker(const std::string& scope_url);
+  Response StopWorker(const std::string& version_id);
+  Response InspectWorker(const std::string& version_id);
 
   // WorkerDevToolsManager::Observer implementation.
   void WorkerCreated(ServiceWorkerDevToolsAgentHost* host) override;
@@ -69,6 +73,8 @@ class ServiceWorkerHandler : public DevToolsAgentHostClient,
   void OnWorkerVersionUpdated(
       const std::vector<ServiceWorkerVersionInfo>& registrations);
 
+  void OpenNewDevToolsWindow(int process_id, int devtools_agent_route_id);
+
   scoped_refptr<ServiceWorkerContextWrapper> context_;
   scoped_ptr<Client> client_;
   ServiceWorkerDevToolsAgentHost::Map attached_hosts_;

content/browser/service_worker/service_worker_context_wrapper.cc

@@ -21,6 +21,7 @@
 #include "content/browser/service_worker/service_worker_quota_client.h"
 #include "content/browser/service_worker/service_worker_request_handler.h"
 #include "content/browser/service_worker/service_worker_utils.h"
+#include "content/browser/service_worker/service_worker_version.h"
 #include "content/browser/storage_partition_impl.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
@@ -42,6 +43,30 @@ void RunSoon(const base::Closure& closure) {
   base::MessageLoop::current()->PostTask(FROM_HERE, closure);
 }
 
+void WorkerStarted(const ServiceWorkerContextWrapper::StatusCallback& callback,
+                   ServiceWorkerStatusCode status) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(callback, status));
+}
+
+void StartActiveWorkerOnIO(
+    const ServiceWorkerContextWrapper::StatusCallback& callback,
+    ServiceWorkerStatusCode status,
+    const scoped_refptr<ServiceWorkerRegistration>& registration) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (status == SERVICE_WORKER_OK) {
+    // Pass the reference of |registration| to WorkerStarted callback to prevent
+    // it from being deleted while starting the worker. If the refcount of
+    // |registration| is 1, it will be deleted after WorkerStarted is called.
+    registration->active_version()->StartWorker(
+        base::Bind(WorkerStarted, callback));
+    return;
+  }
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(callback, SERVICE_WORKER_ERROR_NOT_FOUND));
+}
+
 }  // namespace
 
 void ServiceWorkerContext::AddExcludedHeadersForFetchEvent(
@@ -212,6 +237,27 @@ void ServiceWorkerContextWrapper::UnregisterServiceWorker(
       base::Bind(&FinishUnregistrationOnIO, continuation));
 }
 
+void ServiceWorkerContextWrapper::StartServiceWorker(
+    const GURL& pattern,
+    const StatusCallback& callback) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&ServiceWorkerContextWrapper::StartServiceWorker, this,
+                   pattern, callback));
+    return;
+  }
+  if (!context_core_.get()) {
+    LOG(ERROR) << "ServiceWorkerContextCore is no longer alive.";
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(callback, SERVICE_WORKER_ERROR_START_WORKER_FAILED));
+    return;
+  }
+  context_core_->storage()->FindRegistrationForPattern(
+      pattern, base::Bind(&StartActiveWorkerOnIO, callback));
+}
+
 static void DidFindRegistrationForDocument(
     const net::CompletionCallback& callback,
     ServiceWorkerStatusCode status,

content/browser/service_worker/service_worker_context_wrapper.h

@@ -40,6 +40,7 @@ class CONTENT_EXPORT ServiceWorkerContextWrapper
     : NON_EXPORTED_BASE(public ServiceWorkerContext),
       public base::RefCountedThreadSafe<ServiceWorkerContextWrapper> {
  public:
+  typedef base::Callback<void(ServiceWorkerStatusCode)> StatusCallback;
   ServiceWorkerContextWrapper(BrowserContext* browser_context);
 
   // Init and Shutdown are for use on the UI thread when the profile,
@@ -90,6 +91,7 @@ class CONTENT_EXPORT ServiceWorkerContextWrapper
   virtual void DeleteForOrigin(const GURL& origin_url,
                                const ResultCallback& done);
 
+  void StartServiceWorker(const GURL& pattern, const StatusCallback& callback);
   void AddObserver(ServiceWorkerContextObserver* observer);
   void RemoveObserver(ServiceWorkerContextObserver* observer);
 

content/browser/service_worker/service_worker_internals_ui.cc

@@ -122,28 +122,6 @@ void UnregisterWithScope(
   context->context()->UnregisterServiceWorker(scope, callback);
 }
 
-void WorkerStarted(const scoped_refptr<ServiceWorkerRegistration>& registration,
-                   const ServiceWorkerInternalsUI::StatusCallback& callback,
-                   ServiceWorkerStatusCode status) {
-  callback.Run(status);
-}
-
-void StartActiveWorker(
-    const ServiceWorkerInternalsUI::StatusCallback& callback,
-    ServiceWorkerStatusCode status,
-    const scoped_refptr<ServiceWorkerRegistration>& registration) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (status == SERVICE_WORKER_OK) {
-    // Pass the reference of |registration| to WorkerStarted callback to prevent
-    // it from being deleted while starting the worker. If the refcount of
-    // |registration| is 1, it will be deleted after WorkerStarted is called.
-    registration->active_version()->StartWorker(
-        base::Bind(WorkerStarted, registration, callback));
-    return;
-  }
-  callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND);
-}
-
 void FindRegistrationForPattern(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     const GURL& scope,
@@ -655,11 +633,9 @@ void ServiceWorkerInternalsUI::StartWorker(const ListValue* args) {
       !cmd_args->GetString("scope", &scope_string)) {
     return;
   }
-
   base::Callback<void(ServiceWorkerStatusCode)> callback =
       base::Bind(OperationCompleteCallback, AsWeakPtr(), callback_id);
-  FindRegistrationForPattern(
-      context, GURL(scope_string), base::Bind(StartActiveWorker, callback));
+  context->StartServiceWorker(GURL(scope_string), callback);
 }
 
 }  // namespace content