Extract debugger target enumeration into a separate class

content/browser/devtools/devtools_http_handler_impl.cc

Index: content/browser/devtools/devtools_http_handler_impl.cc
diff --git a/content/browser/devtools/devtools_http_handler_impl.cc b/content/browser/devtools/devtools_http_handler_impl.cc
index 665d01f9cfe6dbdcb2b36fe61406819b961eb5c6..6c53bec1a608a862f1b95b02b603f0925190bc30 100644
--- a/content/browser/devtools/devtools_http_handler_impl.cc
+++ b/content/browser/devtools/devtools_http_handler_impl.cc
@@ -58,43 +58,22 @@ 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;
+    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 DevToolsAgentHost::GetRetained(identifier);
   }
-
- private:
-  typedef std::map<std::string, scoped_refptr<DevToolsAgentHost> > AgentsMap;
-  AgentsMap agents_map_;
 };
 
 // An internal implementation of DevToolsClientHost that delegates
@@ -156,6 +135,20 @@ class DevToolsClientHostImpl : public DevToolsClientHost {
   std::string detach_reason_;
 };
 
+static base::TimeTicks GetLastSelectedTime(RenderViewHost* rvh) {
+  WebContents* web_contents = rvh->GetDelegate()->GetAsWebContents();
+  if (!web_contents)
+    return base::TimeTicks();
+
+  return web_contents->GetLastSelectedTime();
+}
+
+typedef std::pair<RenderViewHost*, base::TimeTicks> PageInfo;
+
+static bool TimeComparator(const PageInfo& info1, const PageInfo& info2) {
+  return info1.second > info2.second;
+}
+
 }  // namespace
 
 // static
@@ -307,15 +300,23 @@ void DevToolsHttpHandlerImpl::OnHttpRequest(
     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) {
+      RenderViewHost* rvh = agent_host->GetRenderViewHost();
+      if (rvh)
+        page_url = rvh->GetDelegate()->GetURL();
+    }
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&DevToolsHttpHandlerImpl::OnThumbnailRequestUI,
                    this,
                    connection_id,
-                   info));
+                   page_url));
     return;
   }
 
@@ -394,55 +395,6 @@ void DevToolsHttpHandlerImpl::OnClose(int connection_id) {
           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) {
@@ -526,11 +478,23 @@ void DevToolsHttpHandlerImpl::OnJsonRequestUI(
   }
 
   if (command == "list") {
-    PageList page_list = GeneratePageList();
+    typedef std::vector<PageInfo> PageList;
+    PageList page_list;
+
+    std::vector<RenderViewHost*> rvh_list =
+        DevToolsAgentHost::GetValidRenderViewHosts();
+    DevToolsAgentHost::RetainFor(rvh_list);
+
+    for (std::vector<RenderViewHost*>::iterator it = rvh_list.begin();
+         it != rvh_list.end(); ++it)
+      page_list.push_back(PageInfo(*it, GetLastSelectedTime(*it)));
+
+    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;
   }
@@ -545,11 +509,11 @@ void DevToolsHttpHandlerImpl::OnJsonRequestUI(
                jsonp);
       return;
     }
-    PageInfo page_info =
-        CreatePageInfo(rvh, DevToolsHttpHandlerDelegate::kTargetTypeTab);
     std::string host = info.headers["Host"];
-    scoped_ptr<base::DictionaryValue> dictionary(
-        SerializePageInfo(page_info, host));
+    std::vector<RenderViewHost*> rvh_list;
+    rvh_list.push_back(rvh);
+    DevToolsAgentHost::RetainFor(rvh_list);
+    scoped_ptr<base::DictionaryValue> dictionary(SerializePageInfo(rvh, host));
     SendJson(connection_id, net::HTTP_OK, dictionary.get(), "", jsonp);
     return;
   }
@@ -587,17 +551,8 @@ void DevToolsHttpHandlerImpl::OnJsonRequestUI(
 }
 
 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
@@ -837,59 +792,46 @@ void DevToolsHttpHandlerImpl::AcceptWebSocket(
                  connection_id, request));
 }
 
-DevToolsHttpHandlerImpl::PageInfo
-DevToolsHttpHandlerImpl::CreatePageInfo(RenderViewHost* rvh,
-    DevToolsHttpHandlerDelegate::TargetType type) {
-  RenderViewHostDelegate* host_delegate = rvh->GetDelegate();
+base::DictionaryValue* DevToolsHttpHandlerImpl::SerializePageInfo(
+    RenderViewHost* rvh,
+    const std::string& host) {
+  base::DictionaryValue* dictionary = new base::DictionaryValue;
+
   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) {
+
+  std::string id = binding_->GetIdentifier(agent);
+  dictionary->SetString("id", id);
+
+  switch (delegate_->GetTargetType(rvh)) {
     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();
+  WebContents* web_contents = rvh->GetDelegate()->GetAsWebContents();
   if (web_contents) {
-    page_info.title = UTF16ToUTF8(
-        net::EscapeForHTML(web_contents->GetTitle()));
-    page_info.last_selected_time = web_contents->GetLastSelectedTime();
+    dictionary->SetString("title", UTF16ToUTF8(
+        net::EscapeForHTML(web_contents->GetTitle())));
+    dictionary->SetString("url", web_contents->GetURL().spec());
+
+    dictionary->SetString("thumbnailUrl", std::string(kThumbUrlPrefix) + id);
 
     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();
+      dictionary->SetString("faviconUrl", 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) {
+  if (!DevToolsManager::GetInstance()->GetDevToolsClientHostFor(agent)) {
     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);
   }