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

chrome/browser/devtools/devtools_target_impl.cc

 // Copyright 2013 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 "chrome/browser/devtools/devtools_target_impl.h"
 
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/devtools/devtools_window.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
@@ skipping 197 matching lines @@
 bool WorkerTarget::Close() const {
   content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
       base::Bind(&TerminateWorker, process_id_, route_id_));
   return true;
 }
 
 void WorkerTarget::Inspect(Profile* profile) const {
   DevToolsWindow::OpenDevToolsWindowForWorker(profile, GetAgentHost());
 }
 
+class ServiceWorkerTarget : public DevToolsTargetImpl {
+ public:
+  explicit ServiceWorkerTarget(scoped_refptr<DevToolsAgentHost> agent_host);
+  virtual void Inspect(Profile* profile) const OVERRIDE;
+};
+
+ServiceWorkerTarget::ServiceWorkerTarget(
+    scoped_refptr<DevToolsAgentHost> agent_host)
+    : DevToolsTargetImpl(agent_host) {
+  set_type(kTargetTypeWorker);
+  set_title("");
+  set_url(agent_host->GetURL());
+}
+
+void ServiceWorkerTarget::Inspect(Profile* profile) const {
+  DevToolsWindow::OpenDevToolsWindowForWorker(profile, GetAgentHost());
+}
+
 }  // namespace
 
 // DevToolsTargetImpl ----------------------------------------------------------
 
 DevToolsTargetImpl::~DevToolsTargetImpl() {
 }
 
 DevToolsTargetImpl::DevToolsTargetImpl(
     scoped_refptr<DevToolsAgentHost> agent_host)
     : agent_host_(agent_host) {
@@ skipping 65 matching lines @@
 
 void DevToolsTargetImpl::Reload() const {
 }
 
 // static
 scoped_ptr<DevToolsTargetImpl> DevToolsTargetImpl::CreateForRenderViewHost(
     content::RenderViewHost* rvh, bool is_tab) {
   return scoped_ptr<DevToolsTargetImpl>(new RenderViewHostTarget(rvh, is_tab));
 }
 
-// static
-DevToolsTargetImpl::List DevToolsTargetImpl::EnumerateRenderViewHostTargets() {
+
+static void CreateRenderViewHostTargets(
+    const DevToolsTargetImpl::Callback& callback,
+    const DevToolsAgentHost::List& agents) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   std::set<RenderViewHost*> tab_rvhs;
   for (TabContentsIterator it; !it.done(); it.Next())
     tab_rvhs.insert(it->GetRenderViewHost());
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DevToolsTargetImpl::List result;
-  std::vector<RenderViewHost*> rvh_list =
-      content::DevToolsAgentHost::GetValidRenderViewHosts();
-  for (std::vector<RenderViewHost*>::iterator it = rvh_list.begin();
-       it != rvh_list.end(); ++it) {
-    bool is_tab = tab_rvhs.find(*it) != tab_rvhs.end();
-    result.push_back(new RenderViewHostTarget(*it, is_tab));
+  for (content::DevToolsAgentHost::List::const_iterator it = agents.begin();
+       it != agents.end(); ++it) {
+    if (RenderViewHost* rvh = (*it)->GetRenderViewHost()) {
+      bool is_tab = tab_rvhs.find(rvh) != tab_rvhs.end();
+      result.push_back(new RenderViewHostTarget(rvh, is_tab));
+    }
   }
-  return result;
+  callback.Run(result);
+}
+
+// static
+void DevToolsTargetImpl::EnumerateRenderViewHostTargets(
+    const Callback& callback) {
+  content::DevToolsAgentHost::GetOrCreateAllHosts(
+      base::Bind(&CreateRenderViewHostTargets, callback));
 }
 
 static void CreateWorkerTargets(
     const std::vector<WorkerService::WorkerInfo>& worker_info,
-    DevToolsTargetImpl::Callback callback) {
+    const DevToolsTargetImpl::Callback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DevToolsTargetImpl::List result;
   for (size_t i = 0; i < worker_info.size(); ++i) {
     result.push_back(new WorkerTarget(worker_info[i]));
   }
   callback.Run(result);
 }
 
 // static
-void DevToolsTargetImpl::EnumerateWorkerTargets(Callback callback) {
+void DevToolsTargetImpl::EnumerateWorkerTargets(const Callback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&CreateWorkerTargets,
                  WorkerService::GetInstance()->GetWorkers(),
                  callback));
 }
 
-static void CollectAllTargets(
-    DevToolsTargetImpl::Callback callback,
-    const DevToolsTargetImpl::List& worker_targets) {
+static void Assign(DevToolsTargetImpl::List* targets_ptr,
+                   const DevToolsTargetImpl::List& targets) {
+  *targets_ptr = targets;
+}
+
+static void OnAgentHostsReceived(const DevToolsTargetImpl::Callback& callback,
+                                 const DevToolsTargetImpl::List& worker_targets,
+                                 const DevToolsAgentHost::List& agent_hosts) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DevToolsTargetImpl::List result =
-      DevToolsTargetImpl::EnumerateRenderViewHostTargets();
-  result.insert(result.begin(), worker_targets.begin(), worker_targets.end());
+  DevToolsTargetImpl::List result;
+  CreateRenderViewHostTargets(base::Bind(Assign, &result), agent_hosts);
+  result.insert(result.end(), worker_targets.begin(), worker_targets.end());
+  std::set<scoped_refptr<DevToolsAgentHost> > used_hosts;
+  for (DevToolsTargetImpl::List::iterator it = result.begin();
+      it != result.end(); ++it) {
+    used_hosts.insert((*it)->GetAgentHost());
+  }
+  for (DevToolsAgentHost::List::const_iterator it = agent_hosts.begin();
+      it != agent_hosts.end(); ++it) {
+    if (used_hosts.find(*it) == used_hosts.end())
+      result.push_back(new ServiceWorkerTarget(*it));
+  }
   callback.Run(result);
 }
 
+static void OnWorkersReceived(const DevToolsTargetImpl::Callback& callback,
+                              const DevToolsTargetImpl::List& worker_targets) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DevToolsAgentHost::GetOrCreateAllHosts(
+      base::Bind(&OnAgentHostsReceived, callback, worker_targets));
+}
+
 // static
-void DevToolsTargetImpl::EnumerateAllTargets(Callback callback) {
+void DevToolsTargetImpl::EnumerateAllTargets(const Callback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&DevToolsTargetImpl::EnumerateWorkerTargets,
-                 base::Bind(&CollectAllTargets, callback)));
+                 base::Bind(&OnWorkersReceived, callback)));
 }