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

android_webview/native/aw_dev_tools_server.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 "android_webview/native/aw_dev_tools_server.h"
 
 #include "android_webview/native/aw_contents.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/json/json_writer.h"
@@ skipping 14 matching lines @@
 using content::RenderViewHost;
 using content::WebContents;
 
 namespace {
 
 const char kFrontEndURL[] =
     "http://chrome-devtools-frontend.appspot.com/serve_rev/%s/devtools.html";
 const char kSocketNameFormat[] = "webview_devtools_remote_%d";
 
 const char kTargetTypePage[] = "page";
+const char kTargetTypeOther[] = "other";
 
 std::string GetViewDescription(WebContents* web_contents);
 
 class Target : public content::DevToolsTarget {
  public:
-  explicit Target(WebContents* web_contents);
+  explicit Target(scoped_refptr<DevToolsAgentHost> agent_host);
 
   virtual std::string GetId() const OVERRIDE { return id_; }
   virtual std::string GetParentId() const OVERRIDE { return std::string(); }
-  virtual std::string GetType() const OVERRIDE { return kTargetTypePage; }
+  virtual std::string GetType() const OVERRIDE { return type_; }
   virtual std::string GetTitle() const OVERRIDE { return title_; }
   virtual std::string GetDescription() const OVERRIDE { return description_; }
   virtual GURL GetURL() const OVERRIDE { return url_; }
   virtual GURL GetFaviconURL() const OVERRIDE { return GURL(); }
   virtual base::TimeTicks GetLastActivityTime() const OVERRIDE {
     return last_activity_time_;
   }
   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 false; }
 
  private:
   scoped_refptr<DevToolsAgentHost> agent_host_;
   std::string id_;
+  std::string type_;
   std::string title_;
   std::string description_;
   GURL url_;
   base::TimeTicks last_activity_time_;
 };
 
-Target::Target(WebContents* web_contents) {
-  agent_host_ =
-      DevToolsAgentHost::GetOrCreateFor(web_contents->GetRenderViewHost());
-  id_ = agent_host_->GetId();
-  description_ = GetViewDescription(web_contents);
-  title_ = base::UTF16ToUTF8(web_contents->GetTitle());
-  url_ = web_contents->GetURL();
-  last_activity_time_ = web_contents->GetLastActiveTime();
+Target::Target(scoped_refptr<DevToolsAgentHost> agent_host)
+  : agent_host_(agent_host),
+    id_(agent_host_->GetId()),
+    url_(agent_host_->GetURL()) {
+  type_ = kTargetTypeOther;
+  if (RenderViewHost* rvh = agent_host_->GetRenderViewHost()) {
+    if (WebContents* web_contents = WebContents::FromRenderViewHost(rvh)) {
+      description_ = GetViewDescription(web_contents);
+      title_ = base::UTF16ToUTF8(web_contents->GetTitle());
+      last_activity_time_ = web_contents->GetLastActiveTime();
+      type_ = kTargetTypePage;
+    }
+  }
 }
 
 // Delegate implementation for the devtools http handler for WebView. A new
 // instance of this gets created each time web debugging is enabled.
 class AwDevToolsServerDelegate : public content::DevToolsHttpHandlerDelegate {
  public:
   AwDevToolsServerDelegate() {}
   virtual ~AwDevToolsServerDelegate() {}
 
   // DevToolsHttpProtocolHandler::Delegate overrides.
   virtual std::string GetDiscoveryPageHTML() OVERRIDE;
 
   virtual bool BundlesFrontendResources() OVERRIDE {
     return false;
   }
 
   virtual base::FilePath GetDebugFrontendDir() OVERRIDE {
     return base::FilePath();
   }
 
   virtual std::string GetPageThumbnailData(const GURL&) OVERRIDE {
     return "";
   }
 
   virtual scoped_ptr<content::DevToolsTarget> CreateNewTarget(
       const GURL&) OVERRIDE {
     return scoped_ptr<content::DevToolsTarget>();
   }
 
-  virtual void EnumerateTargets(TargetCallback callback) OVERRIDE {
-    TargetList targets;
-    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)
-        targets.push_back(new Target(web_contents));
-    }
-    callback.Run(targets);
-  }
+  virtual void EnumerateTargets(TargetCallback callback) OVERRIDE;
 
   virtual scoped_ptr<net::StreamListenSocket> CreateSocketForTethering(
       net::StreamListenSocket::Delegate* delegate,
       std::string* name) OVERRIDE {
     return scoped_ptr<net::StreamListenSocket>();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AwDevToolsServerDelegate);
 };
 
+static void CreateTargets(
+    const AwDevToolsServerDelegate::TargetCallback& callback,
+    const DevToolsAgentHost::List& agents) {
+  AwDevToolsServerDelegate::TargetList targets;
+  for (DevToolsAgentHost::List::const_iterator it = agents.begin();
+      it != agents.end(); ++it) {
+    targets.push_back(new Target(*it));
+  }
+  callback.Run(targets);
+}
+
+void AwDevToolsServerDelegate::EnumerateTargets(TargetCallback callback) {
+  DevToolsAgentHost::GetOrCreateAllHosts(base::Bind(&CreateTargets, callback));
+}
 
 std::string AwDevToolsServerDelegate::GetDiscoveryPageHTML() {
   const char html[] =
       "<html>"
       "<head><title>WebView remote debugging</title></head>"
       "<body>Please use <a href=\'chrome://inspect\'>chrome://inspect</a>"
       "</body>"
       "</html>";
   return html;
 }
@@ skipping 79 matching lines @@
   AwDevToolsServer* devtools_server =
       reinterpret_cast<AwDevToolsServer*>(server);
   if (enabled) {
     devtools_server->Start();
   } else {
     devtools_server->Stop();
   }
 }
 
 }  // namespace android_webview