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

content/browser/devtools/embedded_worker_devtools_manager.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/devtools/embedded_worker_devtools_manager.h"
 
 #include "content/browser/devtools/devtools_manager_impl.h"
 #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"
 
 namespace content {
 
 namespace {
 
 bool SendMessageToWorker(
     const EmbeddedWorkerDevToolsManager::WorkerId& worker_id,
     IPC::Message* message) {
   RenderProcessHost* host = RenderProcessHost::FromID(worker_id.first);
   if (!host) {
     delete message;
     return false;
   }
   message->set_routing_id(worker_id.second);
   host->Send(message);
   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) {
 }
 
 EmbeddedWorkerDevToolsManager::ServiceWorkerIdentifier::ServiceWorkerIdentifier(
     const ServiceWorkerIdentifier& other)
     : service_worker_context_(other.service_worker_context_),
       service_worker_version_id_(other.service_worker_version_id_) {
 }
@@ skipping 117 matching lines @@
     if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first))
       host->AddRoute(worker_id_.second, this);
   }
 
   WorkerId worker_id_;
   bool worker_attached_;
   std::string state_;
   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);
 
   WorkerInfoMap::iterator it = workers_.find(id);
   if (it == workers_.end())
     return NULL;
 
   WorkerInfo* info = it->second;
   if (info->state() != WORKER_UNINSPECTED &&
@@ skipping 10 matching lines @@
 
 DevToolsAgentHost*
 EmbeddedWorkerDevToolsManager::GetDevToolsAgentHostForServiceWorker(
     const ServiceWorkerIdentifier& service_worker_id) {
   WorkerInfoMap::iterator it = FindExistingServiceWorkerInfo(service_worker_id);
   if (it == workers_.end())
     return NULL;
   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) {
 }
 
 EmbeddedWorkerDevToolsManager::~EmbeddedWorkerDevToolsManager() {
 }
 
 bool EmbeddedWorkerDevToolsManager::SharedWorkerCreated(
     int worker_process_id,
     int worker_route_id,
@@ skipping 142 matching lines @@
 
 void EmbeddedWorkerDevToolsManager::MoveToPausedState(
     const WorkerId& id,
     const WorkerInfoMap::iterator& it) {
   DCHECK_EQ(WORKER_TERMINATED, it->second->state());
   scoped_ptr<WorkerInfo> info = workers_.take_and_erase(it);
   info->set_state(WORKER_PAUSED_FOR_REATTACH);
   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();
 }
 
 }  // namespace content