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

chrome/browser/android/dev_tools_server.cc

 // Copyright (c) 2012 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/android/dev_tools_server.h"
 
 #include <pwd.h>
 #include <cstring>
 
 #include "base/android/jni_string.h"
@@ skipping 84 matching lines @@
   }
 
  protected:
   explicit TargetBase(WebContents* web_contents)
       : title_(base::UTF16ToUTF8(web_contents->GetTitle())),
         url_(web_contents->GetURL()),
         favicon_url_(GetFaviconURLForContents(web_contents)),
         last_activity_time_(web_contents->GetLastActiveTime()) {
   }
 
-  TargetBase(const base::string16& title, const GURL& url)
-      : title_(base::UTF16ToUTF8(title)),
+  TargetBase(const std::string& title, const GURL& url)
+      : title_(title),
         url_(url)
   {}
 
  private:
   const std::string title_;
   const GURL url_;
   const GURL favicon_url_;
   const base::TimeTicks last_activity_time_;
 };
 
@@ skipping 64 matching lines @@
     return true;
   }
 
  private:
   TabTarget(int tab_id, WebContents* web_contents)
       : TargetBase(web_contents),
         tab_id_(tab_id) {
   }
 
   TabTarget(int tab_id, const base::string16& title, const GURL& url)
-      : TargetBase(title, url),
+      : TargetBase(base::UTF16ToUTF8(title), url),
         tab_id_(tab_id) {
   }
 
   bool FindTab(TabModel** model_result, int* index_result) const {
     for (TabModelList::const_iterator iter = TabModelList::begin();
         iter != TabModelList::end(); ++iter) {
       TabModel* model = *iter;
       for (int i = 0; i < model->GetTabCount(); ++i) {
         TabAndroid* tab = model->GetTabAt(i);
         if (tab->GetAndroidId() == tab_id_) {
           *model_result = model;
           *index_result = i;
           return true;
         }
       }
     }
     return false;
   }
 
   const int tab_id_;
 };
 
 class NonTabTarget : public TargetBase {
  public:
-  explicit NonTabTarget(WebContents* web_contents)
-      : TargetBase(web_contents),
-        agent_host_(DevToolsAgentHost::GetOrCreateFor(
-            web_contents->GetRenderViewHost())) {
+  explicit NonTabTarget(scoped_refptr<DevToolsAgentHost> agent_host)
+      : TargetBase("Service Worker", agent_host->GetURL()),
+        agent_host_(agent_host) {
   }
 
   // content::DevToolsTarget implementation:
   virtual std::string GetId() const OVERRIDE {
     return agent_host_->GetId();
   }
 
   virtual std::string GetType() const OVERRIDE {
     if (TabModelList::begin() == TabModelList::end()) {
       // If there are no tab models we must be running in ChromeShell.
@@ skipping 86 matching lines @@
 
     TabAndroid* tab = TabAndroid::FromWebContents(web_contents);
     if (!tab)
       return scoped_ptr<content::DevToolsTarget>();
 
     return scoped_ptr<content::DevToolsTarget>(
         TabTarget::CreateForWebContents(tab->GetAndroidId(), web_contents));
   }
 
   virtual void EnumerateTargets(TargetCallback callback) OVERRIDE {
+    DevToolsAgentHost::GetOrCreateAllHosts(
+        base::Bind(&DevToolsServerDelegate::CreateAllTargets, callback));
+  }
+
+  static void CreateAllTargets(const TargetCallback& callback,
+                               const DevToolsAgentHost::List& agent_hosts) {
     TargetList targets;
 
     // Enumerate existing tabs, including the ones with no WebContents.
     std::set<WebContents*> tab_web_contents;
     for (TabModelList::const_iterator iter = TabModelList::begin();
         iter != TabModelList::end(); ++iter) {
       TabModel* model = *iter;
       for (int i = 0; i < model->GetTabCount(); ++i) {
         TabAndroid* tab = model->GetTabAt(i);
         WebContents* web_contents = model->GetWebContentsAt(i);
         if (web_contents) {
           tab_web_contents.insert(web_contents);
           targets.push_back(TabTarget::CreateForWebContents(tab->GetAndroidId(),
                                                             web_contents));
         } else {
           targets.push_back(TabTarget::CreateForUnloadedTab(tab->GetAndroidId(),
                                                             tab->GetTitle(),
                                                             tab->GetURL()));
         }
       }
     }
 
     // Add targets for WebContents not associated with any tabs.
-    std::vector<RenderViewHost*> rvh_list =
-        DevToolsAgentHost::GetValidRenderViewHosts();
-    for (std::vector<RenderViewHost*>::iterator it = rvh_list.begin();
-         it != rvh_list.end(); ++it) {
-      WebContents* web_contents = WebContents::FromRenderViewHost(*it);
-      if (!web_contents)
-        continue;
-      if (tab_web_contents.find(web_contents) != tab_web_contents.end())
-        continue;
-      targets.push_back(new NonTabTarget(web_contents));
+    for (DevToolsAgentHost::List::const_iterator it = agent_hosts.begin();
+        it != agent_hosts.end(); ++it) {
+      if (RenderViewHost* rvh = (*it)->GetRenderViewHost()) {
+        if (WebContents* web_contents = WebContents::FromRenderViewHost(rvh)) {
+          if (tab_web_contents.find(web_contents) != tab_web_contents.end())
+            continue;
+        }
+      }
+      targets.push_back(new NonTabTarget(*it));
     }
 
     callback.Run(targets);
   }
 
   virtual scoped_ptr<net::StreamListenSocket> CreateSocketForTethering(
       net::StreamListenSocket::Delegate* delegate,
       std::string* name) OVERRIDE {
     *name = base::StringPrintf(
         kTetheringSocketName, getpid(), ++last_tethering_socket_);
@@ skipping 102 matching lines @@
                                       jobject obj,
                                       jlong server,
                                       jboolean enabled) {
   DevToolsServer* devtools_server = reinterpret_cast<DevToolsServer*>(server);
   if (enabled) {
     devtools_server->Start();
   } else {
     devtools_server->Stop();
   }
 }