DevTools: Added service workers to chrome://inspect/#devices

content/browser/devtools/embedded_worker_devtools_manager.cc

Index: content/browser/devtools/embedded_worker_devtools_manager.cc
diff --git a/content/browser/devtools/embedded_worker_devtools_manager.cc b/content/browser/devtools/embedded_worker_devtools_manager.cc
index 3ba61aafeea20e9b12ec8973ef32aa1e3f5cd7cb..2ed26a982b6bde88d25b567928f4f77799722b4f 100644
--- a/content/browser/devtools/embedded_worker_devtools_manager.cc
+++ b/content/browser/devtools/embedded_worker_devtools_manager.cc
@@ -8,9 +8,12 @@
 #include "content/browser/devtools/devtools_protocol.h"
 #include "content/browser/devtools/devtools_protocol_constants.h"
 #include "content/browser/devtools/ipc_devtools_agent_host.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_instance.h"
 #include "content/common/devtools_messages.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/devtools_target.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/worker_service.h"
 #include "ipc/ipc_listener.h"
@@ -32,10 +35,19 @@ bool SendMessageToWorker(
   return true;
 }
 
+void StatusNoOp(ServiceWorkerStatusCode status) {
+}
+
+void CloseServiceWorkerOnIO(ServiceWorkerContextCore* context,
+                            int64 version_id) {
+  if (ServiceWorkerVersion* version = context->GetLiveVersion(version_id))
+    version->StopWorker(base::Bind(&StatusNoOp));
+}
+
 }  // namespace
 
 EmbeddedWorkerDevToolsManager::ServiceWorkerIdentifier::ServiceWorkerIdentifier(
-    const ServiceWorkerContextCore* const service_worker_context,
+    ServiceWorkerContextCore* const service_worker_context,
     int64 service_worker_version_id)
     : service_worker_context_(service_worker_context),
       service_worker_version_id_(service_worker_version_id) {
@@ -173,13 +185,87 @@ class EmbeddedWorkerDevToolsManager::EmbeddedWorkerDevToolsAgentHost
   DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerDevToolsAgentHost);
 };
 
+class EmbeddedWorkerDevToolsManager::ServiceWorkerTarget
+    : public DevToolsTarget {
+ public:
+  ServiceWorkerTarget(
+      EmbeddedWorkerDevToolsAgentHost* agent_host, const GURL& url)
+      : agent_host_(agent_host),
+        url_(url) {
+  }
+
+  virtual ~ServiceWorkerTarget() {
+  }
+
+  virtual std::string GetId() const OVERRIDE {
+    return agent_host_->GetId();
+  }
+
+  virtual std::string GetParentId() const OVERRIDE {
+    return "";
+  }
+
+  virtual std::string GetType() const OVERRIDE {
+    return "worker";
+  }
+
+  virtual std::string GetTitle() const OVERRIDE {
+    return "Service Worker";
+  }
+
+  virtual std::string GetDescription() const OVERRIDE {
+    return "Service Worker";
+  }
+
+  virtual GURL GetURL() const OVERRIDE {
+    return url_;
+  }
+
+  virtual GURL GetFaviconURL() const OVERRIDE {
+    return GURL();
+  }
+
+  virtual base::TimeTicks GetLastActivityTime() const OVERRIDE {
+    return base::TimeTicks();
+  }
+
+  virtual bool IsAttached() const OVERRIDE {
+    return agent_host_->IsAttached();
+  }
+
+  virtual scoped_refptr<DevToolsAgentHost> GetAgentHost() const OVERRIDE {
+    return agent_host_;
+  }
+
+  virtual bool Activate() const OVERRIDE {
+    return false;
+  }
+
+  virtual bool Close() const OVERRIDE {
+    return EmbeddedWorkerDevToolsManager::GetInstance()->CloseServiceWorker(
+        agent_host_->worker_id());
+  }
+
+ private:
+  EmbeddedWorkerDevToolsAgentHost* agent_host_;
+  GURL url_;
+};
+
 // static
 EmbeddedWorkerDevToolsManager* EmbeddedWorkerDevToolsManager::GetInstance() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return Singleton<EmbeddedWorkerDevToolsManager>::get();
 }
 
-DevToolsAgentHost* EmbeddedWorkerDevToolsManager::GetDevToolsAgentHostForWorker(
+DevToolsAgentHost*
+EmbeddedWorkerDevToolsManager::GetDevToolsAgentHostForWorker(
+    int worker_process_id,
+    int worker_route_id) {
+  return GetOrCreateAgentHost(worker_process_id, worker_route_id);
+}
+
+EmbeddedWorkerDevToolsManager::EmbeddedWorkerDevToolsAgentHost*
+EmbeddedWorkerDevToolsManager::GetOrCreateAgentHost(
     int worker_process_id,
     int worker_route_id) {
   WorkerId id(worker_process_id, worker_route_id);
@@ -210,6 +296,54 @@ EmbeddedWorkerDevToolsManager::GetDevToolsAgentHostForServiceWorker(
   return GetDevToolsAgentHostForWorker(it->first.first, it->first.second);
 }
 
+void EmbeddedWorkerDevToolsManager::GetAllServiceWorkerTargets(
+    const TargetCallback& callback) {
+  std::map<WorkerId, ServiceWorkerIdentifier> ids;
+  for (WorkerInfoMap::iterator it = workers_.begin();
+       it != workers_.end(); ++it) {
+    if (const ServiceWorkerIdentifier* worker_id =
+        it->second->service_worker_id()) {
+      ids.insert(std::make_pair(it->first, *worker_id));
+    }
+  }
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&EmbeddedWorkerDevToolsManager::GetServiceWorkerUrlsOnIO,
+                 ids, callback));
+}
+
+// static
+void EmbeddedWorkerDevToolsManager::GetServiceWorkerUrlsOnIO(
+    const std::map<WorkerId, ServiceWorkerIdentifier>& ids,
+    const TargetCallback& callback) {
+  std::map<WorkerId, GURL> url_map;
+  for (std::map<WorkerId, ServiceWorkerIdentifier>::const_iterator it =
+      ids.begin(); it != ids.end(); ++it) {
+    ServiceWorkerVersion* version = it->second.service_worker_context_->

[horo, 2014/07/08 08:14:31]

ServiceWorkerIdentifier's service_worker_context_ was intended to be used only
for the identification of the workers.
service_worker_context_(ServiceWorkerContextCore) could have been deleted even
if it is in workers_(WorkerInfoMap).

If the inspector window is opened, when the worker is stopped the WorkerInfo of
the worker is still stored in WorkerInfoMap.
And at this situation, the ServiceWorkerContextCore could be deleted which is
owend by StoragePartition.

So insteadof calling the method of service_worker_context_ please get the
ServiceWorkerContext using BrowserContext::ForEachStoragePartition() like
ServiceWorkerInternalsUI::GetAllRegistrations().
https://code.google.com/p/chromium/codesearch#chromium/src/content/browser/se...

[vkuzkokov, 2014/07/08 09:38:48]

ForEachStoragePartition requires passing instance of BrowserContext. Which, I
guess, means that I have to somehow get all live instances of BrowserContext
first.

[horo, 2014/07/09 02:30:44]

Humm..
Doesn't DevToolsHttpHandler have a way to get the current profile?

+        GetLiveVersion(it->second.service_worker_version_id_);
+    if (version)
+        url_map[it->first] = version->script_url();
+  }
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+      base::Bind(&EmbeddedWorkerDevToolsManager::CreateTargets,
+                 url_map, callback));
+}
+
+// static
+void EmbeddedWorkerDevToolsManager::CreateTargets(
+    const std::map<WorkerId, GURL> url_map,
+    const TargetCallback& callback) {
+  std::vector<DevToolsTarget*> targets;
+  EmbeddedWorkerDevToolsManager* instance = GetInstance();
+  for (std::map<WorkerId, GURL>::const_iterator it = url_map.begin();
+      it != url_map.end(); ++it) {
+    if (EmbeddedWorkerDevToolsAgentHost* agent_host =
+        instance->GetOrCreateAgentHost(it->first.first, it->first.second)) {
+      targets.push_back(new ServiceWorkerTarget(agent_host, it->second));
+    }
+  }
+  callback.Run(targets);
+}
+
 EmbeddedWorkerDevToolsManager::EmbeddedWorkerDevToolsManager()
     : debug_service_worker_on_start_(false) {
 }
@@ -372,6 +506,20 @@ void EmbeddedWorkerDevToolsManager::MoveToPausedState(
   workers_.set(id, info.Pass());
 }
 
+bool EmbeddedWorkerDevToolsManager::CloseServiceWorker(const WorkerId& id) {
+  WorkerInfoMap::iterator it = workers_.find(id);
+  if (it == workers_.end())
+    return false;
+  ServiceWorkerIdentifier* service_worker = it->second->service_worker_id();
+  if (!service_worker)
+    return false;
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&CloseServiceWorkerOnIO,
+                 service_worker->service_worker_context_,
+                 service_worker->service_worker_version_id_));
+  return true;
+}
+
 void EmbeddedWorkerDevToolsManager::ResetForTesting() {
   workers_.clear();
 }