Create chrome://serviceworker-internals

content/browser/service_worker/service_worker_internals_ui.cc

+// Copyright (c) 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/values.h"
+#include "content/browser/service_worker/service_worker_context_core.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"
+#include "content/public/common/url_constants.h"
+#include "grit/content_resources.h"
+
+using base::DictionaryValue;
+using base::FundamentalValue;
+using base::ListValue;
+using base::StringValue;
+using base::Value;
+using base::WeakPtr;
+
+namespace content {
+
+// This class, and the parameters to the *IOTHread methods should be
+// created on the UI thread, where it will delete itself and
+// those values.
+class ServiceWorkerInternalsUI::OperationProxy {
+ public:
+  explicit OperationProxy(const WeakPtr<ServiceWorkerInternalsUI> internals)
+      : internals_(internals) {}
+  ~OperationProxy() {}
+
+  void GetRegistrationsOnIOThread(ServiceWorkerContextWrapper* context,
+                                  const base::FilePath& context_path);
+  void UnregisterOnIOThread(scoped_ptr<ListValue> original_args,
+                            scoped_refptr<ServiceWorkerContextWrapper> context,
+                            const GURL& scope);
+  void StartWorkerOnIOThread(scoped_ptr<ListValue> original_args,
+                             scoped_refptr<ServiceWorkerContextWrapper> context,
+                             const GURL& scope);
+  void StopWorkerOnIOThread(scoped_ptr<ListValue> original_args,
+                            scoped_refptr<ServiceWorkerContextWrapper> context,
+                            const GURL& scope);
+
+ private:
+  void OnHaveRegistrations(
+      const base::FilePath& context_path,
+      scoped_ptr<std::vector<ServiceWorkerRegistration*> > registrations);
+
+  void OperationComplete(scoped_ptr<ListValue> original_args,
+                         ServiceWorkerStatusCode status);
+
+  void StartActiveWorker(
+      scoped_ptr<ListValue> original_args,
+      ServiceWorkerStatusCode status,
+      const scoped_refptr<ServiceWorkerRegistration>& registration);
+
+  void StopActiveWorker(
+      scoped_ptr<ListValue> original_args,
+      ServiceWorkerStatusCode status,
+      const scoped_refptr<ServiceWorkerRegistration>& registration);
+
+  WeakPtr<ServiceWorkerInternalsUI> internals_;
+};
+
+ServiceWorkerInternalsUI::ServiceWorkerInternalsUI(WebUI* web_ui)
+    : WebUIController(web_ui) {
+  WebUIDataSource* source =
+      WebUIDataSource::Create(kChromeUIServiceWorkerInternalsHost);
+  source->SetUseJsonJSFormatV2();
+  source->SetJsonPath("strings.js");
+  source->AddResourcePath("serviceworker_internals.js",
+                          IDR_SERVICE_WORKER_INTERNALS_JS);
+  source->AddResourcePath("serviceworker_internals.css",
+                          IDR_SERVICE_WORKER_INTERNALS_CSS);
+  source->SetDefaultResource(IDR_SERVICE_WORKER_INTERNALS_HTML);
+
+  BrowserContext* browser_context =
+      web_ui->GetWebContents()->GetBrowserContext();
+  WebUIDataSource::Add(browser_context, source);
+
+  web_ui->RegisterMessageCallback(
+      "getAllRegistrations",
+      base::Bind(&ServiceWorkerInternalsUI::GetAllRegistrations,
+                 base::Unretained(this)));
+  web_ui->RegisterMessageCallback(
+      "start",
+      base::Bind(&ServiceWorkerInternalsUI::StartWorker,
+                 base::Unretained(this)));
+  web_ui->RegisterMessageCallback(
+      "stop",
+      base::Bind(&ServiceWorkerInternalsUI::StopWorker,
+                 base::Unretained(this)));
+  web_ui->RegisterMessageCallback(
+      "unregister",
+      base::Bind(&ServiceWorkerInternalsUI::Unregister,
+                 base::Unretained(this)));
+}
+
+ServiceWorkerInternalsUI::~ServiceWorkerInternalsUI() {}
+
+void ServiceWorkerInternalsUI::GetAllRegistrations(const ListValue* args) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  BrowserContext* browser_context =
+      web_ui()->GetWebContents()->GetBrowserContext();
+
+  // Safe to use base::Unretained(this) because
+  // ForEachStoragePartition is synchronous.
+  BrowserContext::StoragePartitionCallback cb =
+      base::Bind(&ServiceWorkerInternalsUI::AddContextFromStoragePartition,
+                 base::Unretained(this));
+  BrowserContext::ForEachStoragePartition(browser_context, cb);
+}
+
+void ServiceWorkerInternalsUI::AddContextFromStoragePartition(
+    StoragePartition* partition) {
+  scoped_refptr<ServiceWorkerContextWrapper> context =
+      partition->GetServiceWorkerContext();
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(
+          &ServiceWorkerInternalsUI::OperationProxy::GetRegistrationsOnIOThread,
+          base::Unretained(new OperationProxy(AsWeakPtr())),
+          context,
+          partition->GetPath()));
+}
+
+namespace {
+void FindContext(const base::FilePath& partition_path,
+                 StoragePartition** result_partition,
+                 scoped_refptr<ServiceWorkerContextWrapper>* result_context,
+                 StoragePartition* storage_partition) {
+  if (storage_partition->GetPath() == partition_path) {
+    *result_partition = storage_partition;
+    *result_context = storage_partition->GetServiceWorkerContext();
+  }
+}
+}  // namespace
+
+bool ServiceWorkerInternalsUI::GetRegistrationInfo(
+    const ListValue* args,
+    base::FilePath* partition_path,
+    GURL* scope,
+    scoped_refptr<ServiceWorkerContextWrapper>* context) const {
+  base::FilePath::StringType path_string;
+  if (!args->GetString(0, &path_string))
+    return false;
+  *partition_path = base::FilePath(path_string);
+
+  std::string scope_string;
+  if (!args->GetString(1, &scope_string))
+    return false;
+  *scope = GURL(scope_string);
+
+  BrowserContext* browser_context =
+      web_ui()->GetWebContents()->GetBrowserContext();
+
+  StoragePartition* result_partition(NULL);
+  BrowserContext::StoragePartitionCallback cb =
+      base::Bind(&FindContext, *partition_path, &result_partition, context);
+  BrowserContext::ForEachStoragePartition(browser_context, cb);
+
+  if (!result_partition || !(*context))
+    return false;
+
+  return true;
+}
+
+void ServiceWorkerInternalsUI::StartWorker(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::StartWorkerOnIOThread,
+          base::Unretained(new OperationProxy(AsWeakPtr())),
+          base::Passed(&args_copy),
+          context,
+          scope));
+}
+
+void ServiceWorkerInternalsUI::StopWorker(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::StopWorkerOnIOThread,
+          base::Unretained(new OperationProxy(AsWeakPtr())),
+          base::Passed(&args_copy),
+          context,
+          scope));
+}
+
+void ServiceWorkerInternalsUI::OperationProxy::UnregisterOnIOThread(
+    scoped_ptr<ListValue> original_args,
+    scoped_refptr<ServiceWorkerContextWrapper> context,
+    const GURL& scope) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  context->context()->UnregisterServiceWorker(
+      scope,
+      0,  // render process id?
+      base::Bind(&ServiceWorkerInternalsUI::OperationProxy::OperationComplete,
+                 base::Unretained(this),
+                 base::Passed(&original_args)));
+}
+
+void ServiceWorkerInternalsUI::OperationProxy::OperationComplete(
+    scoped_ptr<ListValue> original_args,
+    ServiceWorkerStatusCode status) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&ServiceWorkerInternalsUI::OperationProxy::OperationComplete,
+                   base::Unretained(this),
+                   base::Passed(&original_args),
+                   status));
+    return;
+  }
+
+  original_args->Insert(0, new FundamentalValue(static_cast<int>(status)));
+  if (internals_)
+    internals_->web_ui()->CallJavascriptFunction(
+        "serviceworker.onOperationComplete",
+        std::vector<const Value*>(original_args->begin(),
+                                  original_args->end()));
+  delete this;
+}
+
+void ServiceWorkerInternalsUI::OperationProxy::StartWorkerOnIOThread(
+    scoped_ptr<ListValue> original_args,
+    scoped_refptr<ServiceWorkerContextWrapper> context,
+    const GURL& scope) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  // TODO(alecflett): Add support for starting/stopping workers for
+  // pending versions too.
+  context->context()->storage()->FindRegistrationForPattern(
+      scope,
+      base::Bind(&ServiceWorkerInternalsUI::OperationProxy::StartActiveWorker,
+                 base::Unretained(this),
+                 base::Passed(&original_args)));
+}
+
+void ServiceWorkerInternalsUI::OperationProxy::StartActiveWorker(
+    scoped_ptr<ListValue> original_args,
+    ServiceWorkerStatusCode status,
+    const scoped_refptr<ServiceWorkerRegistration>& registration) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (status == SERVICE_WORKER_OK) {
+    registration->active_version()->StartWorker(
+        base::Bind(&ServiceWorkerInternalsUI::OperationProxy::OperationComplete,
+                   base::Unretained(this),
+                   base::Passed(&original_args)));
+    return;
+  }
+
+  OperationComplete(original_args.Pass(), status);
+}
+
+void ServiceWorkerInternalsUI::OperationProxy::StopWorkerOnIOThread(
+    scoped_ptr<ListValue> original_args,
+    scoped_refptr<ServiceWorkerContextWrapper> context,
+    const GURL& scope) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  // TODO(alecflett): Add support for starting/stopping workers for
+  // pending versions too.
+  context->context()->storage()->FindRegistrationForPattern(
+      scope,
+      base::Bind(&ServiceWorkerInternalsUI::OperationProxy::StopActiveWorker,
+                 base::Unretained(this),
+                 base::Passed(&original_args)));
+}
+
+void ServiceWorkerInternalsUI::OperationProxy::StopActiveWorker(
+    scoped_ptr<ListValue> original_args,
+    ServiceWorkerStatusCode status,
+    const scoped_refptr<ServiceWorkerRegistration>& registration) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (status == SERVICE_WORKER_OK) {
+    registration->active_version()->StopWorker(
+        base::Bind(&ServiceWorkerInternalsUI::OperationProxy::OperationComplete,
+                   base::Unretained(this),
+                   base::Passed(&original_args)));
+    return;
+  }
+
+  OperationComplete(original_args.Pass(), status);
+}
+
+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(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(
+          &ServiceWorkerInternalsUI::OperationProxy::UnregisterOnIOThread,
+          base::Unretained(new OperationProxy(AsWeakPtr())),
+          base::Passed(&args_copy),
+          context,
+          scope));
+}
+
+void ServiceWorkerInternalsUI::OperationProxy::GetRegistrationsOnIOThread(
+    ServiceWorkerContextWrapper* context,
+    const base::FilePath& context_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  context->context()->storage()->FindAllRegistrations(
+      base::Bind(&ServiceWorkerInternalsUI::OperationProxy::OnHaveRegistrations,
+                 base::Unretained(this),
+                 context_path));
+}
+
+namespace {
+void UpdateVersionInfo(ServiceWorkerVersion* version, DictionaryValue* info) {
+  switch (version->embedded_worker()->status()) {
+    case ServiceWorkerVersion::STOPPED:
+      info->SetString("status", "STOPPED");
+      break;
+    case EmbeddedWorkerInstance::STARTING:
+      info->SetString("status", "STARTING");
+      break;
+    case EmbeddedWorkerInstance::RUNNING:
+      info->SetString("status", "RUNNING");
+      break;
+    case EmbeddedWorkerInstance::STOPPING:
+      info->SetString("status", "STOPPING");
+      break;
+  }
+
+  info->SetInteger("process_id", version->embedded_worker()->process_id());
+  // is this hardware thread or internal thread?
+  info->SetInteger("thread_id", version->embedded_worker()->thread_id());
+}
+}  // namespace
+
+void ServiceWorkerInternalsUI::OperationProxy::OnHaveRegistrations(
+    const base::FilePath& context_path,
+    scoped_ptr<std::vector<ServiceWorkerRegistration*> > registrations) {

[michaeln, 2014/03/04 00:25:47]

Don't we need a different representation for this info so we can send it across
threads? 

ServiceWorkerRegistration isn't thread safe and the active and pending versions
can swap out an any time. The reg object itself may be deleted by the time the
task runs on the UI thread.

+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(
+            &ServiceWorkerInternalsUI::OperationProxy::OnHaveRegistrations,
+            base::Unretained(this),
+            context_path,
+            base::Passed(&registrations)));
+    return;
+  }
+
+  ListValue result;
+  for (std::vector<ServiceWorkerRegistration*>::const_iterator it =
+           registrations->begin();
+       it != registrations->end();
+       ++it) {
+    const ServiceWorkerRegistration* registration = *it;
+    DictionaryValue* registration_info = new DictionaryValue();
+    registration_info->SetString("scope", registration->pattern().spec());
+    registration_info->SetString("script_url",
+                                 registration->script_url().spec());
+
+    if (registration->active_version()) {
+      DictionaryValue* active_info = new DictionaryValue();
+      UpdateVersionInfo(registration->active_version(), active_info);
+      registration_info->Set("active", active_info);
+    }
+
+    if (registration->pending_version()) {
+      DictionaryValue* pending_info = new DictionaryValue();
+      UpdateVersionInfo(registration->active_version(), pending_info);
+      registration_info->Set("pending", pending_info);
+    }
+
+    result.Append(registration_info);
+  }
+
+  if (internals_)
+    internals_->web_ui()->CallJavascriptFunction(
+        "serviceworker.onPartitionData",
+        result,
+        StringValue(context_path.value()));
+  delete this;
+}
+
+}  // namespace content