Extract debugger target enumeration into a separate class

content/browser/devtools/devtools_agent_host_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_agent_host_impl.h"
 
 #include "base/basictypes.h"
+#include "base/memory/singleton.h"
+#include "base/stringprintf.h"
 #include "content/common/devtools_messages.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"
 
 namespace content {
 
 namespace {
 static int g_next_agent_host_id = 0;
 }  // namespace
 
 DevToolsAgentHostImpl::DevToolsAgentHostImpl()
     : close_listener_(NULL),
-      id_(++g_next_agent_host_id) {
+      id_(base::StringPrintf("%d", ++g_next_agent_host_id)) {
 }
 
 void DevToolsAgentHostImpl::Attach() {
   SendMessageToAgent(new DevToolsAgentMsg_Attach(MSG_ROUTING_NONE));
   NotifyClientAttaching();
 }
 
 void DevToolsAgentHostImpl::Reattach(const std::string& saved_agent_state) {
   SendMessageToAgent(new DevToolsAgentMsg_Reattach(
       MSG_ROUTING_NONE,
@@ skipping 30 matching lines @@
 }
 
 void DevToolsAgentHostImpl::NotifyCloseListener() {
   if (close_listener_) {
     scoped_refptr<DevToolsAgentHostImpl> protect(this);
     close_listener_->AgentHostClosing(this);
     close_listener_ = NULL;
   }
 }
 
+namespace {
+  class DevToolsTargetList {

[jam, 2013/03/06 17:41:52]

nit: no tabbing inside a namespace. also usually there's one anonymous namespace
per cc file at the top. can you move this class there?

+   public:
+
+    static DevToolsTargetList* GetInstance() {
+      return Singleton<DevToolsTargetList>::get();
+    }
+
+    DevToolsAgentHost* GetRetained(const std::string& id) {
+      GarbageCollect();
+      AgentsMap::iterator it = agents_map_.find(id);
+      if (it != agents_map_.end())
+        return it->second;
+      return NULL;
+    }
+
+    void RetainFor(std::vector<RenderViewHost*> rvh_list) {
+      GarbageCollect();
+      for (std::vector<RenderViewHost*>::iterator it = rvh_list.begin();
+          it != rvh_list.end(); it++) {
+        scoped_refptr<DevToolsAgentHost> agent(DevToolsAgentHost::GetFor(*it));
+        agents_map_[agent->GetId()] = agent;
+      }
+    }
+
+   private:
+    typedef std::map<std::string, scoped_refptr<DevToolsAgentHost> > AgentsMap;
+
+    AgentsMap agents_map_;
+
+    void GarbageCollect() {
+      AgentsMap::iterator it = agents_map_.begin();
+      while (it != agents_map_.end()) {
+       if (!it->second->GetRenderViewHost())
+         agents_map_.erase(it++);
+       else
+         ++it;
+      }
+    }
+  };
+} // namespace
+
+//static
+std::vector<RenderViewHost*> DevToolsAgentHost::GetValidRenderViewHosts() {
+  std::vector<RenderViewHost*> result;
+  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* rvh =
+          RenderViewHost::From(const_cast<RenderWidgetHost*>(widget));
+      result.push_back(rvh);
+    }
+  }
+  return result;
+}
+
+//static
+void DevToolsAgentHost::RetainFor(std::vector<RenderViewHost*> rvh_list) {
+  DevToolsTargetList::GetInstance()->RetainFor(rvh_list);
+}
+
+// static
+DevToolsAgentHost* DevToolsAgentHost::GetRetained(const std::string& id) {
+  return DevToolsTargetList::GetInstance()->GetRetained(id);
+}
+
 }  // namespace content