DevTools: Extract target discovery and manipulation from DevToolsHttpHandlerImpl

chrome/browser/devtools/browser_list_tabcontents_provider.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/devtools/browser_list_tabcontents_provider.h"
 
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/devtools_agent_host.h"
+#include "content/public/browser/devtools_target_descriptor.h"
+#include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/browser/worker_service.h"
 #include "content/public/common/url_constants.h"
 #include "grit/devtools_discovery_page_resources.h"
 #include "net/socket/tcp_listen_socket.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using content::DevToolsHttpHandlerDelegate;
+using content::DevToolsAgentHost;
 using content::RenderViewHost;
+using content::WebContents;
+
+namespace {
+
+const char kTargetTypeOther[] = "other";
+
+std::string GetDescription(WebContents* web_contents) {
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents->GetBrowserContext());
+  if (!profile)
+    return std::string();
+
+  extensions::ExtensionHost* extension_host =
+      extensions::ExtensionSystem::Get(profile)->process_manager()->
+          GetBackgroundHostForExtension(web_contents->GetURL().host());
+
+  if (!extension_host || extension_host->host_contents() != web_contents)
+    return std::string();
+
+  return extension_host->extension()->name();
+}
+
+RenderViewHost* GetRenderViewHost(const std::string& id) {
+  DevToolsAgentHost* agent_host = DevToolsAgentHost::GetForId(id);
+  return agent_host ? agent_host->GetRenderViewHost() : NULL;
+}
+
+WebContents* GetWebContents(const std::string& id) {
+  RenderViewHost* rvh = GetRenderViewHost(id);
+  return rvh ? WebContents::FromRenderViewHost(rvh) : NULL;
+}
+
+}  // namespace
 
 BrowserListTabContentsProvider::BrowserListTabContentsProvider(
     chrome::HostDesktopType host_desktop_type)
     : host_desktop_type_(host_desktop_type) {
 }
 
 BrowserListTabContentsProvider::~BrowserListTabContentsProvider() {
 }
 
 std::string BrowserListTabContentsProvider::GetDiscoveryPageHTML() {
@@ skipping 21 matching lines @@
 base::FilePath BrowserListTabContentsProvider::GetDebugFrontendDir() {
 #if defined(DEBUG_DEVTOOLS)
   base::FilePath inspector_dir;
   PathService::Get(chrome::DIR_INSPECTOR, &inspector_dir);
   return inspector_dir;
 #else
   return base::FilePath();
 #endif
 }
 
+bool BrowserListTabContentsProvider::SupportsPageThumbnails() {
+  return true;
+}
+
 std::string BrowserListTabContentsProvider::GetPageThumbnailData(
-    const GURL& url) {
+    const std::string& id) {
+  WebContents* web_contents = GetWebContents(id);
+  if (!web_contents)
+    return std::string();
+
+  GURL url = web_contents->GetURL();
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     Profile* profile = (*it)->profile();
     history::TopSites* top_sites = profile->GetTopSites();
     if (!top_sites)
       continue;
     scoped_refptr<base::RefCountedMemory> data;
     if (top_sites->GetPageThumbnail(url, false, &data))
       return std::string(
           reinterpret_cast<const char*>(data->front()), data->size());
   }
 
   return std::string();
 }
 
-RenderViewHost* BrowserListTabContentsProvider::CreateNewTarget() {
+DevToolsHttpHandlerDelegate::Target*
+BrowserListTabContentsProvider::CreateNewTarget() {
+  WebContents* web_contents;
   const BrowserList* browser_list =
       BrowserList::GetInstance(host_desktop_type_);
-
   if (browser_list->empty()) {
     chrome::NewEmptyWindow(ProfileManager::GetLastUsedProfile(),
         host_desktop_type_);
-    return browser_list->empty() ? NULL :
-           browser_list->get(0)->tab_strip_model()->GetActiveWebContents()->
-               GetRenderViewHost();
+    if (browser_list->empty())
+      return NULL;
+    web_contents =
+        browser_list->get(0)->tab_strip_model()->GetActiveWebContents();
+  } else {
+    web_contents = chrome::AddSelectedTabWithURL(
+        browser_list->get(0),
+        GURL(content::kAboutBlankURL),
+        content::PAGE_TRANSITION_LINK);
   }
-
-  content::WebContents* web_contents = chrome::AddSelectedTabWithURL(
-      browser_list->get(0),
-      GURL(content::kAboutBlankURL),
-      content::PAGE_TRANSITION_LINK);
-  return web_contents->GetRenderViewHost();
+  return Target::FromWebContents(web_contents);
 }
 
-content::DevToolsHttpHandlerDelegate::TargetType
-BrowserListTabContentsProvider::GetTargetType(content::RenderViewHost* rvh) {
-  for (TabContentsIterator it; !it.done(); it.Next())
-    if (rvh == it->GetRenderViewHost())
-      return kTargetTypeTab;
-
-  return kTargetTypeOther;
+bool BrowserListTabContentsProvider::ActivateTarget(const std::string& id) {
+  WebContents* web_contents = GetWebContents(id);
+  if (!web_contents)
+    return false;
+  web_contents->GetDelegate()->ActivateContents(web_contents);
+  return true;
 }
 
-std::string BrowserListTabContentsProvider::GetViewDescription(
-    content::RenderViewHost* rvh) {
-  content::WebContents* web_contents =
-      content::WebContents::FromRenderViewHost(rvh);
-  if (!web_contents)
-    return std::string();
+bool BrowserListTabContentsProvider::CloseTarget(const std::string& id) {
+  RenderViewHost* rvh = GetRenderViewHost(id);
+  if (!rvh)
+    return false;
+  rvh->ClosePage();
+  return true;
+}
 
-  Profile* profile =
-      Profile::FromBrowserContext(web_contents->GetBrowserContext());
-  if (!profile)
-    return std::string();
+scoped_refptr<DevToolsAgentHost> BrowserListTabContentsProvider::GetAgentHost(
+      const std::string& id) {
+  return DevToolsAgentHost::GetForId(id);
+}
 
-  extensions::ExtensionHost* extension_host =
-      extensions::ExtensionSystem::Get(profile)->process_manager()->
-          GetBackgroundHostForExtension(web_contents->GetURL().host());
-
-  if (!extension_host || extension_host->host_contents() != web_contents)
-    return std::string();
-
-  return extension_host->extension()->name();
+void BrowserListTabContentsProvider::RequestTargets(TargetCallback callback) {
+  content::BrowserThread::PostTaskAndReplyWithResult(
+      content::BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&BrowserListTabContentsProvider::CollectWorkerTargets, this),
+      base::Bind(&BrowserListTabContentsProvider::RespondWithTargetList,
+                  this,
+                  callback));
 }
 
 #if defined(DEBUG_DEVTOOLS)
 static int g_last_tethering_port_ = 9333;
 
 scoped_ptr<net::StreamListenSocket>
 BrowserListTabContentsProvider::CreateSocketForTethering(
     net::StreamListenSocket::Delegate* delegate,
     std::string* name) {
   if (g_last_tethering_port_ == 9444)
     g_last_tethering_port_ = 9333;
   int port = ++g_last_tethering_port_;
   *name = base::IntToString(port);
   return net::TCPListenSocket::CreateAndListen("127.0.0.1", port, delegate)
       .PassAs<net::StreamListenSocket>();
 }
 #else
 scoped_ptr<net::StreamListenSocket>
 BrowserListTabContentsProvider::CreateSocketForTethering(
     net::StreamListenSocket::Delegate* delegate,
     std::string* name) {
   return scoped_ptr<net::StreamListenSocket>();
 }
 #endif  // defined(DEBUG_DEVTOOLS)
+
+DevToolsHttpHandlerDelegate::TargetList
+BrowserListTabContentsProvider::CollectWorkerTargets() {
+  TargetList targets;
+  std::vector<content::WorkerService::WorkerInfo> worker_info =
+      content::WorkerService::GetInstance()->GetWorkers();
+  for (size_t i = 0; i < worker_info.size(); ++i)
+    targets.push_back(Target::FromWorkerInfo(worker_info[i]));
+  return targets;
+}
+
+void BrowserListTabContentsProvider::RespondWithTargetList(
+    TargetCallback callback, const TargetList& worker_targets) {
+  std::set<RenderViewHost*> tab_rvhs;
+  for (TabContentsIterator it; !it.done(); it.Next())
+    tab_rvhs.insert(it->GetRenderViewHost());
+
+  TargetList targets;
+
+  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();
+    WebContents* web_contents = WebContents::FromRenderViewHost(*it);
+    if (!web_contents)
+      continue;
+    Target* target = Target::FromWebContents(web_contents);
+    if (!is_tab) {
+      target->OverrideType(kTargetTypeOther);
+      target->OverrideDescription(GetDescription(web_contents));
+    }
+    targets.push_back(target);
+  }
+
+  targets.insert(targets.end(), worker_targets.begin(), worker_targets.end());
+
+  callback.Run(targets);
+}