Remove redundant DevToolsManager methods and clean up its clients.

content/browser/devtools/devtools_manager_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_manager_impl.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
@@ skipping 18 matching lines @@
 }
 
 DevToolsManagerImpl::DevToolsManagerImpl() {
 }
 
 DevToolsManagerImpl::~DevToolsManagerImpl() {
   DCHECK(agent_to_client_host_.empty());
   DCHECK(client_to_agent_host_.empty());
 }
 
-DevToolsClientHost* DevToolsManagerImpl::GetDevToolsClientHostFor(
-    DevToolsAgentHost* agent_host) {
+bool DevToolsManagerImpl::IsAttached(DevToolsAgentHost* agent_host) {
   DevToolsAgentHostImpl* agent_host_impl =
       static_cast<DevToolsAgentHostImpl*>(agent_host);
+  return !!GetDevToolsClientHostFor(agent_host_impl);
+}
+
+DevToolsClientHost* DevToolsManagerImpl::GetDevToolsClientHostFor(
+    DevToolsAgentHostImpl* agent_host_impl) {
   AgentToClientHostMap::iterator it =
       agent_to_client_host_.find(agent_host_impl);
   if (it != agent_to_client_host_.end())
     return it->second;
   return NULL;
 }
 
 DevToolsAgentHost* DevToolsManagerImpl::GetDevToolsAgentHostFor(
     DevToolsClientHost* client_host) {
   ClientToAgentHostMap::iterator it = client_to_agent_host_.find(client_host);
   if (it != client_to_agent_host_.end())
     return it->second;
   return NULL;
 }
 
 void DevToolsManagerImpl::RegisterDevToolsClientHostFor(
     DevToolsAgentHost* agent_host,
     DevToolsClientHost* client_host) {
   DevToolsAgentHostImpl* agent_host_impl =
       static_cast<DevToolsAgentHostImpl*>(agent_host);
+  DevToolsClientHost* old_client_host =
+      GetDevToolsClientHostFor(agent_host_impl);
+  if (old_client_host) {
+    old_client_host->ReplacedWithAnotherClient();

[pfeldman, 2013/03/29 14:59:23]

Ok. Only DevToolsWindow is allowed to kick other clients out, that's why it was
there.

[Vladislav Kaznacheev, 2013/03/29 15:15:35]

It was doing it through a public API which anyone can call.
On 2013/03/29 14:59:23, pfeldman wrote:

+    UnregisterDevToolsClientHostFor(agent_host_impl);
+  }
   BindClientHost(agent_host_impl, client_host);
   agent_host_impl->Attach();
 }
 
 bool DevToolsManagerImpl::DispatchOnInspectorBackend(
     DevToolsClientHost* from,
     const std::string& message) {
   DevToolsAgentHost* agent_host = GetDevToolsAgentHostFor(from);
   if (!agent_host)
     return false;
   DevToolsAgentHostImpl* agent_host_impl =
       static_cast<DevToolsAgentHostImpl*>(agent_host);
   agent_host_impl->DispatchOnInspectorBackend(message);
   return true;
 }
 
 void DevToolsManagerImpl::DispatchOnInspectorFrontend(
     DevToolsAgentHost* agent_host,
     const std::string& message) {
-  DevToolsClientHost* client_host = GetDevToolsClientHostFor(agent_host);
+  DevToolsAgentHostImpl* agent_host_impl =
+      static_cast<DevToolsAgentHostImpl*>(agent_host);
+  DevToolsClientHost* client_host = GetDevToolsClientHostFor(agent_host_impl);
   if (!client_host) {
     // Client window was closed while there were messages
     // being sent to it.
     return;
   }
   client_host->DispatchOnInspectorFrontend(message);
 }
 
 void DevToolsManagerImpl::ClientHostClosing(DevToolsClientHost* client_host) {
   DevToolsAgentHost* agent_host = GetDevToolsAgentHostFor(client_host);
   if (!agent_host)
     return;
   DevToolsAgentHostImpl* agent_host_impl =
       static_cast<DevToolsAgentHostImpl*>(agent_host);
   UnbindClientHost(agent_host_impl, client_host);
 }
 
 void DevToolsManagerImpl::AgentHostClosing(DevToolsAgentHostImpl* agent_host) {
-  UnregisterDevToolsClientHostFor(agent_host);
+  UnregisterDevToolsClientHostFor(
+      static_cast<DevToolsAgentHostImpl*>(agent_host));
 }
 
 void DevToolsManagerImpl::UnregisterDevToolsClientHostFor(
-    DevToolsAgentHost* agent_host) {
+    DevToolsAgentHostImpl* agent_host) {
   DevToolsClientHost* client_host = GetDevToolsClientHostFor(agent_host);
   if (!client_host)
     return;
-  DevToolsAgentHostImpl* agent_host_impl =
-      static_cast<DevToolsAgentHostImpl*>(agent_host);
-  UnbindClientHost(agent_host_impl, client_host);
+  UnbindClientHost(agent_host, client_host);
   client_host->InspectedContentsClosing();
 }
 
 void DevToolsManagerImpl::BindClientHost(
     DevToolsAgentHostImpl* agent_host,
     DevToolsClientHost* client_host) {
   DCHECK(agent_to_client_host_.find(agent_host) ==
       agent_to_client_host_.end());
   DCHECK(client_to_agent_host_.find(client_host) ==
       client_to_agent_host_.end());
@@ skipping 27 matching lines @@
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&DevToolsNetLogObserver::Detach));
   }
   // Lazy agent hosts can be deleted from within detach.
   // Do not access agent_host below this line.
   agent_host->Detach();
 }
 
 void DevToolsManagerImpl::CloseAllClientHosts() {
-  std::vector<DevToolsAgentHost*> agents;
+  std::vector<DevToolsAgentHostImpl*> agents;
   for (AgentToClientHostMap::iterator it =
            agent_to_client_host_.begin();
        it != agent_to_client_host_.end(); ++it) {
     agents.push_back(it->first);
   }
-  for (std::vector<DevToolsAgentHost*>::iterator it = agents.begin();
+  for (std::vector<DevToolsAgentHostImpl*>::iterator it = agents.begin();
        it != agents.end(); ++it) {
     UnregisterDevToolsClientHostFor(*it);
   }
 }
 
 }  // namespace content