Extract debugger target enumeration into a separate class

content/browser/devtools/devtools_http_handler_impl.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 "content/browser/devtools/devtools_http_handler_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
-#include "base/stringprintf.h"
 #include "base/threading/thread.h"
-#include "base/utf_string_conversions.h"
-#include "base/values.h"
-#include "content/browser/devtools/devtools_agent_host_impl.h"
 #include "content/browser/devtools/devtools_browser_target.h"
 #include "content/browser/devtools/devtools_tracing_handler.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/devtools_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_client_host.h"
-#include "content/public/browser/devtools_http_handler_delegate.h"
 #include "content/public/browser/devtools_manager.h"
-#include "content/public/browser/favicon_status.h"
-#include "content/public/browser/navigation_entry.h"
+#include "content/public/browser/devtools_target_list.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
-#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
-#include "content/public/browser/render_widget_host.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/url_constants.h"
 #include "googleurl/src/gurl.h"
 #include "grit/devtools_resources_map.h"
-#include "net/base/escape.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/server/http_server_request_info.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDevToolsAgent.h"
 #include "ui/base/layout.h"
 #include "webkit/user_agent/user_agent.h"
 #include "webkit/user_agent/user_agent_util.h"
 
 namespace content {
 
 const int kBufferSize = 16 * 1024;
 
 namespace {
 
 static const char* kDevToolsHandlerThreadName = "Chrome_DevToolsHandlerThread";
 
+static const char* kThumbUrlPrefix = "/thumb/";
+
 class DevToolsDefaultBindingHandler
     : public DevToolsHttpHandler::DevToolsAgentHostBinding {
  public:
   DevToolsDefaultBindingHandler() {
   }
 
-  void GarbageCollect() {
-    AgentsMap::iterator it = agents_map_.begin();
-    while (it != agents_map_.end()) {
-      if (!it->second->GetRenderViewHost())
-        agents_map_.erase(it++);
-      else
-        ++it;
-    }
-  }
-
   virtual std::string GetIdentifier(DevToolsAgentHost* agent_host) OVERRIDE {
-    GarbageCollect();
-    DevToolsAgentHostImpl* agent_host_impl =
-        static_cast<DevToolsAgentHostImpl*>(agent_host);
-    std::string id = base::StringPrintf("%d", agent_host_impl->id());
-    agents_map_[id] = agent_host;
-    return id;
+    DevToolsTargetList::GetInstance()->Register(agent_host);
+    return agent_host->GetId();
   }
 
   virtual DevToolsAgentHost* ForIdentifier(
       const std::string& identifier) OVERRIDE {
-    GarbageCollect();
-    AgentsMap::iterator it = agents_map_.find(identifier);
-    if (it != agents_map_.end())
-      return it->second;
-    return NULL;
+    return DevToolsTargetList::GetInstance()->Lookup(identifier);
   }
-
- private:
-  typedef std::map<std::string, scoped_refptr<DevToolsAgentHost> > AgentsMap;
-  AgentsMap agents_map_;
 };
 
 // An internal implementation of DevToolsClientHost that delegates
 // messages sent for DevToolsClient to a DebuggerShell instance.
 class DevToolsClientHostImpl : public DevToolsClientHost {
  public:
   DevToolsClientHostImpl(
       MessageLoop* message_loop,
       net::HttpServer* server,
       int connection_id)
@@ skipping 41 matching lines @@
   }
 
  private:
   MessageLoop* message_loop_;
   net::HttpServer* server_;
   int connection_id_;
   bool is_closed_;
   std::string detach_reason_;
 };
 
+static base::TimeTicks GetLastSelectedTime(DevToolsAgentHost* agent) {
+  RenderViewHost* rvh = agent->GetRenderViewHost();
+  if (!rvh)
+    return base::TimeTicks();
+
+  WebContents* web_contents = rvh->GetDelegate()->GetAsWebContents();
+  if (!web_contents)
+    return base::TimeTicks();
+
+  return web_contents->GetLastSelectedTime();
+}
+
+typedef std::pair<DevToolsAgentHost*, base::TimeTicks> PageInfo;
+
+static bool TimeComparator(const PageInfo& info1, const PageInfo& info2) {
+  return info1.second > info2.second;
+}
+
 }  // namespace
 
 // static
 int DevToolsHttpHandler::GetFrontendResourceId(const std::string& name) {
   for (size_t i = 0; i < kDevtoolsResourcesSize; ++i) {
     if (name == kDevtoolsResources[i].name)
       return kDevtoolsResources[i].value;
   }
   return -1;
 }
@@ skipping 131 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&DevToolsHttpHandlerImpl::OnJsonRequestUI,
                    this,
                    connection_id,
                    info));
     return;
   }
 
-  if (info.path.find("/thumb/") == 0) {
+  if (info.path.find(kThumbUrlPrefix) == 0) {
     // Thumbnail request.
+    const std::string target_id = info.path.substr(strlen(kThumbUrlPrefix));
+    DevToolsAgentHost* agent_host = binding_->ForIdentifier(target_id);
+    GURL page_url;
+    if (agent_host)
+      page_url = agent_host->GetUrl();
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&DevToolsHttpHandlerImpl::OnThumbnailRequestUI,
                    this,
                    connection_id,
-                   info));
+                   page_url));
     return;
   }
 
   if (info.path == "" || info.path == "/") {
     // Discovery page request.
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&DevToolsHttpHandlerImpl::OnDiscoveryPageRequestUI,
                    this,
@@ skipping 58 matching lines @@
 void DevToolsHttpHandlerImpl::OnClose(int connection_id) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
           &DevToolsHttpHandlerImpl::OnCloseUI,
           this,
           connection_id));
 }
 
-struct DevToolsHttpHandlerImpl::PageInfo {
-  PageInfo()
-      : attached(false) {
-  }
-
-  std::string id;
-  std::string url;
-  std::string type;
-  bool attached;
-  std::string title;
-  std::string thumbnail_url;
-  std::string favicon_url;
-  base::TimeTicks last_selected_time;
-};
-
-// static
-bool DevToolsHttpHandlerImpl::SortPageListByTime(const PageInfo& info1,
-                                                 const PageInfo& info2) {
-  return info1.last_selected_time > info2.last_selected_time;
-}
-
-DevToolsHttpHandlerImpl::PageList DevToolsHttpHandlerImpl::GeneratePageList() {
-  PageList page_list;
-  for (RenderProcessHost::iterator it(RenderProcessHost::AllHostsIterator());
-       !it.IsAtEnd(); it.Advance()) {
-    RenderProcessHost* render_process_host = it.GetCurrentValue();
-    DCHECK(render_process_host);
-
-    // Ignore processes that don't have a connection, such as crashed contents.
-    if (!render_process_host->HasConnection())
-      continue;
-
-    RenderProcessHost::RenderWidgetHostsIterator rwit(
-        render_process_host->GetRenderWidgetHostsIterator());
-    for (; !rwit.IsAtEnd(); rwit.Advance()) {
-      const RenderWidgetHost* widget = rwit.GetCurrentValue();
-      DCHECK(widget);
-      if (!widget || !widget->IsRenderView())
-        continue;
-
-      RenderViewHost* host =
-          RenderViewHost::From(const_cast<RenderWidgetHost*>(widget));
-      page_list.push_back(CreatePageInfo(host, delegate_->GetTargetType(host)));
-    }
-  }
-  std::sort(page_list.begin(), page_list.end(), SortPageListByTime);
-  return page_list;
-}
-
 std::string DevToolsHttpHandlerImpl::GetFrontendURLInternal(
     const std::string rvh_id,
     const std::string& host) {
   return base::StringPrintf(
       "%s%sws=%s/devtools/page/%s",
       overridden_frontend_url_.c_str(),
       overridden_frontend_url_.find("?") == std::string::npos ? "?" : "&",
       host.c_str(),
       rvh_id.c_str());
 }
@@ skipping 63 matching lines @@
                       webkit_glue::GetWebKitVersion());
     version.SetString("Browser",
                       content::GetContentClient()->GetProduct());
     version.SetString("User-Agent",
                       webkit_glue::GetUserAgent(GURL(chrome::kAboutBlankURL)));
     SendJson(connection_id, net::HTTP_OK, &version, "", jsonp);
     return;
   }
 
   if (command == "list") {
-    PageList page_list = GeneratePageList();
+    typedef std::vector<PageInfo> PageList;
+    PageList page_list;
+
+    DevToolsTargetList* target_list = DevToolsTargetList::GetInstance();
+    target_list->Refresh();

[pfeldman, 2013/03/05 12:06:41]

This should be its private detail.

[Vladislav Kaznacheev, 2013/03/05 13:35:44]

Moved into begin()
On 2013/03/05 12:06:41, pfeldman wrote:

+    for (DevToolsTargetList::AgentsMap::iterator it = target_list->begin();
+         it != target_list->end(); ++it) {
+      DevToolsAgentHost* agent_host = it->second;
+      page_list.push_back(
+          PageInfo(agent_host, GetLastSelectedTime(agent_host)));
+    }
+    std::sort(page_list.begin(), page_list.end(), TimeComparator);
+
     base::ListValue json_pages_list;
     std::string host = info.headers["Host"];
     for (PageList::iterator i = page_list.begin(); i != page_list.end(); ++i)
-      json_pages_list.Append(SerializePageInfo(*i, host));
+      json_pages_list.Append(SerializePageInfo(i->first, host));
     SendJson(connection_id, net::HTTP_OK, &json_pages_list, "", jsonp);
     return;
   }
 
   if (command == "new") {
     RenderViewHost* rvh = delegate_->CreateNewTarget();
     if (!rvh) {
       SendJson(connection_id,
                net::HTTP_INTERNAL_SERVER_ERROR,
                NULL,
                "Could not create new page",
                jsonp);
       return;
     }
-    PageInfo page_info =
-        CreatePageInfo(rvh, DevToolsHttpHandlerDelegate::kTargetTypeTab);
     std::string host = info.headers["Host"];
     scoped_ptr<base::DictionaryValue> dictionary(
-        SerializePageInfo(page_info, host));
+        SerializePageInfo(DevToolsAgentHost::GetFor(rvh), host));
     SendJson(connection_id, net::HTTP_OK, dictionary.get(), "", jsonp);
     return;
   }
 
   if (command == "activate" || command == "close") {
     DevToolsAgentHost* agent_host = binding_->ForIdentifier(target_id);
     RenderViewHost* rvh = agent_host ? agent_host->GetRenderViewHost() : NULL;
     if (!rvh) {
       SendJson(connection_id,
                net::HTTP_NOT_FOUND,
@@ skipping 17 matching lines @@
   }
   SendJson(connection_id,
            net::HTTP_NOT_FOUND,
            NULL,
            "Unknown command: " + command,
            jsonp);
   return;
 }
 
 void DevToolsHttpHandlerImpl::OnThumbnailRequestUI(
-    int connection_id,
-    const net::HttpServerRequestInfo& info) {
-  std::string prefix = "/thumb/";
-  size_t pos = info.path.find(prefix);
-  if (pos != 0) {
-    Send404(connection_id);
-    return;
-  }
-
-  std::string page_url = info.path.substr(prefix.length());
-  std::string data = delegate_->GetPageThumbnailData(GURL(page_url));
+    int connection_id, const GURL& page_url) {
+  std::string data = delegate_->GetPageThumbnailData(page_url);
   if (!data.empty())
     Send200(connection_id, data, "image/png");
   else
     Send404(connection_id);
 }
 
 void DevToolsHttpHandlerImpl::OnDiscoveryPageRequestUI(int connection_id) {
   std::string response = delegate_->GetDiscoveryPageHTML();
   Send200(connection_id, response, "text/html; charset=UTF-8");
 }
@@ skipping 219 matching lines @@
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   if (!thread_.get())
     return;
   thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&net::HttpServer::AcceptWebSocket, server_.get(),
                  connection_id, request));
 }
 
-DevToolsHttpHandlerImpl::PageInfo
-DevToolsHttpHandlerImpl::CreatePageInfo(RenderViewHost* rvh,
-    DevToolsHttpHandlerDelegate::TargetType type) {
-  RenderViewHostDelegate* host_delegate = rvh->GetDelegate();
-  scoped_refptr<DevToolsAgentHost> agent(DevToolsAgentHost::GetFor(rvh));
-  DevToolsClientHost* client_host = DevToolsManager::GetInstance()->
-      GetDevToolsClientHostFor(agent);
-  PageInfo page_info;
-  page_info.id = binding_->GetIdentifier(agent);
-  page_info.attached = client_host != NULL;
-  page_info.url = host_delegate->GetURL().spec();
-
-  switch (type) {
+base::DictionaryValue* DevToolsHttpHandlerImpl::SerializePageInfo(
+    DevToolsAgentHost* agent_host,
+    const std::string& host) {
+  base::DictionaryValue* dictionary = new base::DictionaryValue;
+  dictionary->SetString("title", agent_host->GetTitle());
+  dictionary->SetString("url", agent_host->GetUrl().spec());
+  switch (delegate_->GetTargetType(agent_host->GetRenderViewHost())) {
     case DevToolsHttpHandlerDelegate::kTargetTypeTab:
-      page_info.type = "page";
+      dictionary->SetString("type", "page");
       break;
     default:
-      page_info.type = "other";
+      dictionary->SetString("type", "other");
   }
-
-  WebContents* web_contents = host_delegate->GetAsWebContents();
-  if (web_contents) {
-    page_info.title = UTF16ToUTF8(
-        net::EscapeForHTML(web_contents->GetTitle()));
-    page_info.last_selected_time = web_contents->GetLastSelectedTime();
-
-    NavigationController& controller = web_contents->GetController();
-    NavigationEntry* entry = controller.GetActiveEntry();
-    if (entry != NULL && entry->GetURL().is_valid()) {
-      page_info.thumbnail_url = "/thumb/" + entry->GetURL().spec();
-      page_info.favicon_url = entry->GetFavicon().url.spec();
-    }
-  }
-  return page_info;
-}
-
-base::DictionaryValue* DevToolsHttpHandlerImpl::SerializePageInfo(
-    const PageInfo& page_info,
-    const std::string& host) {
-  base::DictionaryValue* dictionary = new base::DictionaryValue;
-  dictionary->SetString("title", page_info.title);
-  dictionary->SetString("url", page_info.url);
-  dictionary->SetString("type", page_info.type);
-  dictionary->SetString("id", page_info.id);
-  dictionary->SetString("thumbnailUrl", page_info.thumbnail_url);
-  dictionary->SetString("faviconUrl", page_info.favicon_url);
-  if (!page_info.attached) {
+  std::string id = binding_->GetIdentifier(agent_host);
+  dictionary->SetString("id", id);
+  dictionary->SetString("thumbnailUrl", std::string(kThumbUrlPrefix) + id);
+  dictionary->SetString("faviconUrl", agent_host->GetFaviconUrl().spec());
+  if (!DevToolsManager::GetInstance()->GetDevToolsClientHostFor(agent_host)) {
     dictionary->SetString("webSocketDebuggerUrl",
                           base::StringPrintf("ws://%s/devtools/page/%s",
                                              host.c_str(),
-                                             page_info.id.c_str()));
+                                             id.c_str()));
     std::string devtools_frontend_url = GetFrontendURLInternal(
-        page_info.id.c_str(),
+        id.c_str(),
         host);
     dictionary->SetString("devtoolsFrontendUrl", devtools_frontend_url);
   }
   return dictionary;
 }
 
 }  // namespace content