Currently we have two types of devtools UI: Chrome built in developer tools window and remote debugger connected over TCP(apavlov is working on it). To allow DevToolsManager coordinate both types of devtools uniformly their API is extracted into DevToolsClientHost interface.

Fix purify errors in DevToolsManager unit tests.
BUG=9150
Review URL: http://codereview.chromium.org/50009

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@12274 0039d316-1c4b-4281-b951-d872f2087c98

18 files changed, 336 insertions, 288 deletions

diff --git a/chrome/browser/browser.cc b/chrome/browser/browser.cc
index b45ab43..b2d7f7b 100644
--- a/chrome/browser/browser.cc
+++ b/chrome/browser/browser.cc
@@ -16,6 +16,7 @@
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/character_encoding.h"
 #include "chrome/browser/debugger/devtools_manager.h"
+#include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/location_bar.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/net/url_fixer_upper.h"
@@ -941,11 +942,19 @@ void Browser::OpenDebuggerWindow() {
 #ifndef CHROME_DEBUGGER_DISABLED
   UserMetrics::RecordAction(L"Debugger", profile_);
   TabContents* current_tab = GetSelectedTabContents();
-  if (current_tab->AsWebContents()) {
+  WebContents* wc = current_tab->AsWebContents();
+  if (wc) {
     if (CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableOutOfProcessDevTools)) {
-      WebContents* wc = current_tab->AsWebContents();
-      g_browser_process->devtools_manager()->ShowDevToolsForWebContents(wc);
+      DevToolsManager* manager = g_browser_process->devtools_manager();
+      DevToolsClientHost* host = manager->GetDevToolsClientHostFor(*wc);
+      if (!host) {
+        host = DevToolsWindow::Create();
+        manager->RegisterDevToolsClientHostFor(*wc, host);
+      }
+      DevToolsWindow* window = host->AsDevToolsWindow();
+      if (window)
+        window->Show();
     } else {
       // Only one debugger instance can exist at a time right now.
       // TODO(erikkay): need an alert, dialog, something
diff --git a/chrome/browser/browser_process_impl.cc b/chrome/browser/browser_process_impl.cc
index 1e4d0aa..5e1d9f3 100644
--- a/chrome/browser/browser_process_impl.cc
+++ b/chrome/browser/browser_process_impl.cc
@@ -363,8 +363,7 @@ void BrowserProcessImpl::CreateDebuggerWrapper(int port) {
 void BrowserProcessImpl::CreateDevToolsManager() {
   DCHECK(!devtools_manager_.get());
   created_devtools_manager_ = true;
-  devtools_manager_.reset(new DevToolsManager(
-      NULL /*Create DevToolsWindows directly*/));
+  devtools_manager_.reset(new DevToolsManager());
 }
 
 void BrowserProcessImpl::CreateAcceleratorHandler() {
diff --git a/chrome/browser/debugger/debugger.scons b/chrome/browser/debugger/debugger.scons
index adcc4a7..0990813 100644
--- a/chrome/browser/debugger/debugger.scons
+++ b/chrome/browser/debugger/debugger.scons
@@ -53,6 +53,7 @@ input_files = ChromeFileList([
     'debugger_window.h',
     'debugger_wrapper.cc',
     'debugger_wrapper.h',
+    'devtools_client_host.h',
     'devtools_manager.h',
     'devtools_manager.cc',
     'devtools_view.cc',
diff --git a/chrome/browser/debugger/debugger.vcproj b/chrome/browser/debugger/debugger.vcproj
index 8fdb2f5..e40fb81 100644
--- a/chrome/browser/debugger/debugger.vcproj
+++ b/chrome/browser/debugger/debugger.vcproj
@@ -206,6 +206,10 @@
 			>
 		</File>
 		<File
+			RelativePath=".\devtools_client_host.h"
+			>
+		</File>
+		<File
 			RelativePath=".\devtools_manager.cc"
 			>
 		</File>
diff --git a/chrome/browser/debugger/devtools_client_host.h b/chrome/browser/debugger/devtools_client_host.h
new file mode 100644
index 0000000..71534fb
--- /dev/null
+++ b/chrome/browser/debugger/devtools_client_host.h
@@ -0,0 +1,62 @@
+// Copyright (c) 2009 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.
+
+#ifndef CHROME_BROWSER_DEBUGGER_DEVTOOLS_CLIENT_HOST_H_
+#define CHROME_BROWSER_DEBUGGER_DEVTOOLS_CLIENT_HOST_H_
+
+#include "base/basictypes.h"
+
+namespace IPC {
+class Message;
+}
+
+class DevToolsWindow;
+
+// Describes interface for managing devtools clients from browser process. There
+// are currently two types of clients: devtools windows and TCP socket
+// debuggers.
+class DevToolsClientHost {
+ public:
+  class CloseListener {
+   public:
+    CloseListener() {}
+    virtual ~CloseListener() {}
+    virtual void ClientHostClosing(DevToolsClientHost* host) = 0;
+   private:
+    DISALLOW_COPY_AND_ASSIGN(CloseListener);
+  };
+
+  virtual ~DevToolsClientHost() {}
+
+  // This method is called when tab inspected by this devtools client is
+  // closing.
+  virtual void InspectedTabClosing() = 0;
+
+  // Sends the message to the devtools client hosted by this object.
+  virtual void SendMessageToClient(const IPC::Message& msg) = 0;
+
+  void set_close_listener(CloseListener* listener) {
+    close_listener_ = listener;
+  }
+
+  virtual DevToolsWindow* AsDevToolsWindow() { return NULL; }
+
+ protected:
+  DevToolsClientHost() : close_listener_(NULL) {}
+
+  // Should be called when the devtools client is going to die and this
+  // DevToolsClientHost should not be used anymore.
+  void NotifyCloseListener() {
+    if (close_listener_) {
+      close_listener_->ClientHostClosing(this);
+      close_listener_ = NULL;
+    }
+  }
+
+ private:
+  CloseListener* close_listener_;
+  DISALLOW_COPY_AND_ASSIGN(DevToolsClientHost);
+};
+
+#endif  // CHROME_BROWSER_DEBUGGER_DEVTOOLS_CLIENT_HOST_H_
diff --git a/chrome/browser/debugger/devtools_manager.cc b/chrome/browser/debugger/devtools_manager.cc
index 8a4edf4..470fb5c 100644
--- a/chrome/browser/debugger/devtools_manager.cc
+++ b/chrome/browser/debugger/devtools_manager.cc
@@ -5,132 +5,89 @@
 #include "chrome/browser/debugger/devtools_manager.h"
 
 #include "chrome/browser/debugger/devtools_window.h"
+#include "chrome/browser/debugger/devtools_client_host.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/web_contents.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/notification_type.h"
 
-
-class DevToolsInstanceDescriptorImpl : public DevToolsInstanceDescriptor {
- public:
-  explicit DevToolsInstanceDescriptorImpl(
-      DevToolsManager* manager,
-      NavigationController* navigation_controller)
-      : manager_(manager),
-        navigation_controller_(navigation_controller),
-        devtools_host_(NULL),
-        devtools_window_(NULL) {
-  }
-  virtual ~DevToolsInstanceDescriptorImpl() {}
-
-  virtual void SetDevToolsHost(RenderViewHost* render_view_host) {
-    devtools_host_ = render_view_host;
-  }
-
-  virtual void SetDevToolsWindow(DevToolsWindow* window) {
-    devtools_window_ = window;
-  }
-
-  virtual void Destroy() {
-    manager_->RemoveDescriptor(this);
-    delete this;
-  }
-
-  RenderViewHost* devtools_host() const {
-    return devtools_host_;
-  }
-
-  DevToolsWindow* devtools_window() const {
-    return devtools_window_;
-  }
-
-  NavigationController* navigation_controller() const {
-    return navigation_controller_;
-  }
-
- private:
-  DevToolsManager* manager_;
-  NavigationController* navigation_controller_;
-  RenderViewHost* devtools_host_;
-  DevToolsWindow* devtools_window_;
-
-  DISALLOW_COPY_AND_ASSIGN(DevToolsInstanceDescriptorImpl);
-};
-
-DevToolsManager::DevToolsManager(DevToolsWindowFactory* factory)
-    : web_contents_listeners_(NULL),
-      devtools_window_factory_(factory) {
+DevToolsManager::DevToolsManager() : web_contents_listeners_(NULL) {
 }
 
 DevToolsManager::~DevToolsManager() {
   DCHECK(!web_contents_listeners_.get()) <<
-      "All devtools windows must alredy have been closed.";
-}
-
-DevToolsWindow* DevToolsManager::CreateDevToolsWindow(
-    DevToolsInstanceDescriptor* descriptor) {
-  if (devtools_window_factory_) {
-    return devtools_window_factory_->CreateDevToolsWindow(descriptor);
-  } else {
-    return DevToolsWindow::Create(descriptor);
-  }
+      "All devtools client hosts must alredy have been destroyed.";
+  DCHECK(navcontroller_to_client_host_.empty());
+  DCHECK(client_host_to_navcontroller_.empty());
 }
 
 void DevToolsManager::Observe(NotificationType type,
                               const NotificationSource& source,
                               const NotificationDetails& details) {
   DCHECK(type == NotificationType::WEB_CONTENTS_DISCONNECTED);
+
   Source<WebContents> src(source);
-  NavigationController* controller = src->controller();
-  DescriptorMap::const_iterator it =
-      navcontroller_to_descriptor_.find(controller);
-  if (it == navcontroller_to_descriptor_.end()) {
+  DevToolsClientHost* client_host = GetDevToolsClientHostFor(*src.ptr());
+  if (!client_host) {
     return;
   }
+
+  NavigationController* controller = src->controller();
   bool active = (controller->active_contents() == src.ptr());
-  if (!active) {
-    return;
+  if (active) {
+    // Active tab contents disconnecting from its renderer means that the tab
+    // is closing.
+    client_host->InspectedTabClosing();
   }
-  // Active tab contents disconnecting from its renderer means that the tab
-  // is closing so we are closing devtools as well.
-  it->second->devtools_window()->Close();
 }
 
-void DevToolsManager::ShowDevToolsForWebContents(WebContents* web_contents) {
-  NavigationController* navigation_controller = web_contents->controller();
+DevToolsClientHost* DevToolsManager::GetDevToolsClientHostFor(
+    const WebContents& web_contents) {
+  NavigationController* navigation_controller = web_contents.controller();
+  ClientHostMap::const_iterator it =
+      navcontroller_to_client_host_.find(navigation_controller);
+  if (it != navcontroller_to_client_host_.end()) {
+    return it->second;
+  }
+  return NULL;
+}
 
-  DevToolsWindow* window(NULL);
-  DevToolsInstanceDescriptorImpl* desc(NULL);
-  DescriptorMap::const_iterator it =
-      navcontroller_to_descriptor_.find(navigation_controller);
-  if (it != navcontroller_to_descriptor_.end()) {
-    desc = it->second;
-    window = desc->devtools_window();
-  } else {
-    desc = new DevToolsInstanceDescriptorImpl(this, navigation_controller);
-    navcontroller_to_descriptor_[navigation_controller] = desc;
+void DevToolsManager::RegisterDevToolsClientHostFor(
+    const WebContents& web_contents,
+    DevToolsClientHost* client_host) {
+  DCHECK(!GetDevToolsClientHostFor(web_contents));
 
-    StartListening(navigation_controller);
+  NavigationController* navigation_controller = web_contents.controller();
+  navcontroller_to_client_host_[navigation_controller] = client_host;
+  client_host_to_navcontroller_[client_host] = navigation_controller;
+  client_host->set_close_listener(this);
 
-    window = CreateDevToolsWindow(desc);
-  }
-
-  window->Show();
+  StartListening(navigation_controller);
 }
 
-void DevToolsManager::ForwardToDevToolsAgent(RenderViewHost* from,
-                                             const IPC::Message& message) {
-  NavigationController* nav_controller(NULL);
-  for (DescriptorMap::const_iterator it = navcontroller_to_descriptor_.begin();
-       it != navcontroller_to_descriptor_.end();
+void DevToolsManager::ForwardToDevToolsAgent(
+    const RenderViewHost& client_rvh,
+    const IPC::Message& message) {
+    for (ClientHostMap::const_iterator it =
+             navcontroller_to_client_host_.begin();
+       it != navcontroller_to_client_host_.end();
        ++it) {
-    if (it->second->devtools_host() == from) {
-      nav_controller = it->second->navigation_controller();
-      break;
+    DevToolsWindow* win = it->second->AsDevToolsWindow();
+    if (!win) {
+      continue;
+    }
+    if (win->HasRenderViewHost(client_rvh)) {
+      ForwardToDevToolsAgent(*win, message);
+      return;
     }
   }
+}
 
+void DevToolsManager::ForwardToDevToolsAgent(const DevToolsClientHost& from,
+                                             const IPC::Message& message) {
+  NavigationController* nav_controller =
+      GetDevToolsAgentNavigationController(from);
   if (!nav_controller) {
     NOTREACHED();
     return;
@@ -155,39 +112,43 @@ void DevToolsManager::ForwardToDevToolsAgent(RenderViewHost* from,
   target_host->Send(m);
 }
 
-void DevToolsManager::ForwardToDevToolsClient(RenderViewHost* from,
+void DevToolsManager::ForwardToDevToolsClient(const RenderViewHost& from,
                                               const IPC::Message& message) {
-  WebContents* wc = from->delegate()->GetAsWebContents();
+  WebContents* wc = from.delegate()->GetAsWebContents();
   if (!wc) {
     NOTREACHED();
     return;
   }
-
-  NavigationController* navigation_controller = wc->controller();
-
-  DescriptorMap::const_iterator it =
-      navcontroller_to_descriptor_.find(navigation_controller);
-  if (it == navcontroller_to_descriptor_.end()) {
+  DevToolsClientHost* target_host = GetDevToolsClientHostFor(*wc);
+  if (!target_host) {
     NOTREACHED();
     return;
   }
-
-  RenderViewHost* target_host = it->second->devtools_host();
-  IPC::Message* m =  new IPC::Message(message);
-  m->set_routing_id(target_host->routing_id());
-  target_host->Send(m);
+  target_host->SendMessageToClient(message);
 }
 
-void DevToolsManager::RemoveDescriptor(
-    DevToolsInstanceDescriptorImpl* descriptor) {
-  NavigationController* navigation_controller =
-      descriptor->navigation_controller();
+void DevToolsManager::ClientHostClosing(DevToolsClientHost* host) {
+  NavigationController* controller = GetDevToolsAgentNavigationController(
+      *host);
+  DCHECK(controller);
+
   // This should be done before StopListening as the latter checks number of
   // alive devtools instances.
-  navcontroller_to_descriptor_.erase(navigation_controller);
-  StopListening(navigation_controller);
+  navcontroller_to_client_host_.erase(controller);
+  client_host_to_navcontroller_.erase(host);
+
+  StopListening(controller);
 }
 
+NavigationController* DevToolsManager::GetDevToolsAgentNavigationController(
+    const DevToolsClientHost& client_host) {
+  NavControllerMap::const_iterator it =
+      client_host_to_navcontroller_.find(&client_host);
+  if (it != client_host_to_navcontroller_.end()) {
+    return it->second;
+  }
+  return NULL;
+}
 
 void DevToolsManager::StartListening(
     NavigationController* navigation_controller) {
@@ -204,7 +165,8 @@ void DevToolsManager::StartListening(
 void DevToolsManager::StopListening(
     NavigationController* navigation_controller) {
   DCHECK(web_contents_listeners_.get());
-  if (navcontroller_to_descriptor_.empty()) {
+  if (navcontroller_to_client_host_.empty()) {
+    DCHECK(client_host_to_navcontroller_.empty());
     web_contents_listeners_.reset();
   }
 }
diff --git a/chrome/browser/debugger/devtools_manager.h b/chrome/browser/debugger/devtools_manager.h
index ce6ee73..fe1c803 100644
--- a/chrome/browser/debugger/devtools_manager.h
+++ b/chrome/browser/debugger/devtools_manager.h
@@ -9,104 +9,84 @@
 
 #include "base/basictypes.h"
 #include "base/scoped_ptr.h"
+#include "chrome/browser/debugger/devtools_client_host.h"
 #include "chrome/common/notification_service.h"
 
 namespace IPC {
 class Message;
 }
 
-class DevToolsInstanceDescriptor;
-class DevToolsInstanceDescriptorImpl;
-class DevToolsWindow;
-class DevToolsWindowFactory;
+class DevToolsClientHost;
 class NavigationController;
 class NotificationRegistrar;
 class RenderViewHost;
 class WebContents;
 
-// This class is a singleton that manages DevToolsWindow instances and routes
-// messages between developer tools clients and agents.
-class DevToolsManager : public NotificationObserver {
+// This class is a singleton that manages DevToolsClientHost instances and
+// routes messages between developer tools clients and agents.
+class DevToolsManager : public NotificationObserver,
+                        public DevToolsClientHost::CloseListener {
  public:
-  // If the factory is NULL, this will create DevToolsWindow objects using
-  // DevToolsWindow::Create static method.
-  DevToolsManager(DevToolsWindowFactory* factory);
+  DevToolsManager();
   virtual ~DevToolsManager();
 
-  // Opend developer tools window for |web_contents|. If there is already
-  // one it will be revealed otherwise a new instance will be created. The
-  // devtools window is actually opened for the tab owning |web_contents|. If
-  // navigation occurs in it causing change of contents in the tab the devtools
-  // window will attach to the new contents. When the tab is closed the manager
-  // will close related devtools window.
-  void ShowDevToolsForWebContents(WebContents* web_contents);
+  // Returns DevToolsClientHost registered for |web_contents| or NULL if
+  // there is no alive DevToolsClientHost registered for |web_contents|.
+  DevToolsClientHost* GetDevToolsClientHostFor(const WebContents& web_contents);
 
-  void ForwardToDevToolsAgent(RenderViewHost* from,
+  // Registers new DevToolsClientHost for |web_contents|. There must be no
+  // other DevToolsClientHosts registered for the WebContents at the moment.
+  void RegisterDevToolsClientHostFor(const WebContents& web_contents,
+                                     DevToolsClientHost* client_host);
+
+  void ForwardToDevToolsAgent(const RenderViewHost& client_rvh,
+                              const IPC::Message& message);
+  void ForwardToDevToolsAgent(const DevToolsClientHost& from,
                               const IPC::Message& message);
-  void ForwardToDevToolsClient(RenderViewHost* from,
+  void ForwardToDevToolsClient(const RenderViewHost& from,
                                const IPC::Message& message);
 
  private:
-  // Creates a DevToolsWindow using devtools_window_factory_ or by calling
-  // DevToolsWindow::Create, if the factory is NULL. All DevToolsWindows should
-  // be created by means of this method.
-  DevToolsWindow* CreateDevToolsWindow(DevToolsInstanceDescriptor* descriptor);
-
   // NotificationObserver override.
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
-  friend class DevToolsInstanceDescriptorImpl;
+  // DevToolsClientHost::CloseListener override.
+  // This method will remove all references from the manager to the
+  // DevToolsClientHost and unregister all listeners related to the
+  // DevToolsClientHost.
+  virtual void ClientHostClosing(DevToolsClientHost* host);
 
-  // This method is called by DevToolsInstanceDescriptorImpl when it's about
-  // to be destroyed. It will remove all references from the manager to the
-  // descriptor and unregister all listeners related to the descriptor.
-  void RemoveDescriptor(DevToolsInstanceDescriptorImpl* descriptor);
+  // Returns NavigationController for the tab that is inspected by devtools
+  // client hosted by DevToolsClientHost.
+  NavigationController* GetDevToolsAgentNavigationController(
+      const DevToolsClientHost& client_host);
 
   void StartListening(NavigationController* navigation_controller);
   void StopListening(NavigationController* navigation_controller);
 
-  // This object is not NULL iff there is at least one open DevToolsWindow.
+  // This object is not NULL iff there is at least one registered
+  // DevToolsClientHost.
   scoped_ptr<NotificationRegistrar> web_contents_listeners_;
 
-  // This maps is for tracking devtools instances opened for browser tabs. It
-  // allows us to have at most one devtools window per tab.
-  // We use NavigationController* as key because it survives crosee-site
-  // navigation in cases when tab contents may change.
+  // These two maps are for tracking dependencies between inspected tabs and
+  // their DevToolsClientHosts. They are usful for routing devtools messages
+  // and allow us to have at most one devtools client host per tab. We use
+  // NavigationController* as key because it survives crosee-site navigation in
+  // cases when tab contents may change.
   //
-  // This map doesn't own its values but DevToolsInstanceDescriptorImpl is
-  // expected to call RemoveDescriptor before dying to remove itself from the
-  // map.
-  typedef std::map<NavigationController*,
-                   DevToolsInstanceDescriptorImpl*> DescriptorMap;
-  DescriptorMap navcontroller_to_descriptor_;
-  DevToolsWindowFactory* devtools_window_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(DevToolsManager);
-};
+  // DevToolsManager start listening to DevToolsClientHosts when they are put
+  // into these maps and removes them when they are closing.
+  typedef std::map<const NavigationController*,
+                   DevToolsClientHost*> ClientHostMap;
+  ClientHostMap navcontroller_to_client_host_;
 
+  typedef std::map<const DevToolsClientHost*,
+                   NavigationController*> NavControllerMap;
+  NavControllerMap client_host_to_navcontroller_;
 
-// Incapsulates information about devtools window instance necessary for
-// routing devtools messages and managing the window. It should be initialized
-// by DevToolsWindow concrete implementation.
-class DevToolsInstanceDescriptor {
- public:
-  DevToolsInstanceDescriptor() {}
-
-  virtual void SetDevToolsHost(RenderViewHost* render_view_host) = 0;
-  virtual void SetDevToolsWindow(DevToolsWindow* window) = 0;
-
-  // This method is called when DevToolsWindow is closing and the descriptor
-  // becomes invalid. It will clean up DevToolsManager and delete this instance.
-  virtual void Destroy() = 0;
-
- protected:
-  // This method should be called from Destroy only.
-  virtual ~DevToolsInstanceDescriptor() {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(DevToolsInstanceDescriptor);
+  DISALLOW_COPY_AND_ASSIGN(DevToolsManager);
 };
 
 #endif  // CHROME_BROWSER_DEBUGGER_DEVTOOLS_MANAGER_H_
diff --git a/chrome/browser/debugger/devtools_manager_unittest.cc b/chrome/browser/debugger/devtools_manager_unittest.cc
index a43f95a..6169f60 100644
--- a/chrome/browser/debugger/devtools_manager_unittest.cc
+++ b/chrome/browser/debugger/devtools_manager_unittest.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "base/basictypes.h"
+#include "chrome/browser/debugger/devtools_client_host.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/renderer_host/test_render_view_host.h"
@@ -11,68 +12,46 @@
 
 namespace {
 
-class TestDevToolsWindow : public DevToolsWindow {
+class TestDevToolsClientHost : public DevToolsClientHost {
  public:
-  TestDevToolsWindow(DevToolsInstanceDescriptor* descriptor)
-      : descriptor_(descriptor),
-        shown_(false),
+  TestDevToolsClientHost()
+      : last_sent_message(NULL),
         closed_(false) {
-    descriptor->SetDevToolsWindow(this);
   }
 
-  virtual ~TestDevToolsWindow() {
-    EXPECT_EQ(shown_, closed_);
-  }
-
-  virtual void Show() {
-    open_counter++;
-    shown_ = true;
+  virtual ~TestDevToolsClientHost() {
+    EXPECT_TRUE(closed_);
   }
 
   virtual void Close() {
-    EXPECT_TRUE(shown_);
+    EXPECT_FALSE(closed_);
     close_counter++;
-    descriptor_->Destroy();
+    NotifyCloseListener();
     closed_ = true;
   }
+  virtual void InspectedTabClosing() {
+    Close();
+  }
+
+  virtual void SendMessageToClient(const IPC::Message& message) {
+    last_sent_message = &message;
+  }
 
   static void ResetCounters() {
-    open_counter = 0;
     close_counter = 0;
   }
 
-  static int open_counter;
   static int close_counter;
 
+  const IPC::Message* last_sent_message;
+
  private:
-  DevToolsInstanceDescriptor* descriptor_;
-  bool shown_;
   bool closed_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestDevToolsWindow);
+  DISALLOW_COPY_AND_ASSIGN(TestDevToolsClientHost);
 };
 
-int TestDevToolsWindow::open_counter = 0;
-int TestDevToolsWindow::close_counter = 0;
-
-
-class TestDevToolsWindowFactory : public DevToolsWindowFactory {
- public:
-  TestDevToolsWindowFactory() : DevToolsWindowFactory(),
-                                last_created_window(NULL) {}
-  virtual ~TestDevToolsWindowFactory() {}
-
-  virtual DevToolsWindow* CreateDevToolsWindow(
-      DevToolsInstanceDescriptor* descriptor) {
-    last_created_window = new TestDevToolsWindow(descriptor);
-    return last_created_window;
-  }
-
-  DevToolsWindow* last_created_window;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TestDevToolsWindowFactory);
-};
+int TestDevToolsClientHost::close_counter = 0;
 
 }  // namespace
 
@@ -84,27 +63,45 @@ class DevToolsManagerTest : public RenderViewHostTestHarness {
  protected:
   virtual void SetUp() {
     RenderViewHostTestHarness::SetUp();
-    TestDevToolsWindow::ResetCounters();
+    TestDevToolsClientHost::ResetCounters();
   }
 };
 
-TEST_F(DevToolsManagerTest, OpenAndManuallyCloseDevToolsWindow) {
-  TestDevToolsWindowFactory window_factory;
-  DevToolsManager manager(&window_factory);
-
-  manager.ShowDevToolsForWebContents(contents());
-  EXPECT_EQ(TestDevToolsWindow::open_counter, 1);
-  EXPECT_EQ(TestDevToolsWindow::close_counter, 0);
-
-  DevToolsWindow* window = window_factory.last_created_window;
-  // Test that same devtools window is used.
-  manager.ShowDevToolsForWebContents(contents());
-  // Check that no new windows were created.
-  EXPECT_TRUE(window == window_factory.last_created_window);
-  EXPECT_EQ(TestDevToolsWindow::open_counter, 2);
-  EXPECT_EQ(TestDevToolsWindow::close_counter, 0);
-
-  window->Close();
-  EXPECT_EQ(TestDevToolsWindow::open_counter, 2);
-  EXPECT_EQ(TestDevToolsWindow::close_counter, 1);
+TEST_F(DevToolsManagerTest, OpenAndManuallyCloseDevToolsClientHost) {
+  DevToolsManager manager;
+
+  DevToolsClientHost* host = manager.GetDevToolsClientHostFor(*contents());
+  EXPECT_TRUE(NULL == host);
+
+  TestDevToolsClientHost client_host;
+  manager.RegisterDevToolsClientHostFor(*contents(), &client_host);
+  // Test that just registered devtools host is returned.
+  host = manager.GetDevToolsClientHostFor(*contents());
+  EXPECT_TRUE(&client_host == host);
+  EXPECT_EQ(0, TestDevToolsClientHost::close_counter);
+
+  // Test that the same devtools host is returned.
+  host = manager.GetDevToolsClientHostFor(*contents());
+  EXPECT_TRUE(&client_host == host);
+  EXPECT_EQ(0, TestDevToolsClientHost::close_counter);
+
+  client_host.Close();
+  EXPECT_EQ(1, TestDevToolsClientHost::close_counter);
+  host = manager.GetDevToolsClientHostFor(*contents());
+  EXPECT_TRUE(NULL == host);
+}
+
+TEST_F(DevToolsManagerTest, ForwardMessageToClient) {
+  DevToolsManager manager;
+
+  TestDevToolsClientHost client_host;
+  manager.RegisterDevToolsClientHostFor(*contents(), &client_host);
+  EXPECT_EQ(0, TestDevToolsClientHost::close_counter);
+
+  IPC::Message m;
+  manager.ForwardToDevToolsClient(*contents()->render_view_host(), m);
+  EXPECT_TRUE(&m == client_host.last_sent_message);
+
+  client_host.Close();
+  EXPECT_EQ(1, TestDevToolsClientHost::close_counter);
 }
diff --git a/chrome/browser/debugger/devtools_view.cc b/chrome/browser/debugger/devtools_view.cc
index ca43a94..5913190 100644
--- a/chrome/browser/debugger/devtools_view.cc
+++ b/chrome/browser/debugger/devtools_view.cc
@@ -7,7 +7,7 @@
 #include <string>
 
 #include "chrome/browser/browser_list.h"
-#include "chrome/browser/debugger/devtools_manager.h"
+#include "chrome/browser/debugger/devtools_client_host.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/web_contents.h"
 #include "chrome/browser/views/tab_contents_container_view.h"
@@ -15,9 +15,7 @@
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 
-DevToolsView::DevToolsView(DevToolsInstanceDescriptor* descriptor)
-    : descriptor_(descriptor),
-      web_contents_(NULL) {
+DevToolsView::DevToolsView() : web_contents_(NULL) {
   web_container_ = new TabContentsContainerView();
   AddChildView(web_container_);
 }
@@ -58,7 +56,6 @@ void DevToolsView::Init() {
   web_contents_->set_delegate(this);
   web_container_->SetTabContents(web_contents_);
   web_contents_->render_view_host()->AllowDOMUIBindings();
-  descriptor_->SetDevToolsHost(web_contents_->render_view_host());
 
   // chrome-ui://devtools/devtools.html
   GURL contents(std::string(chrome::kChromeUIDevToolsURL) + "devtools.html");
@@ -69,13 +66,31 @@ void DevToolsView::Init() {
 }
 
 void DevToolsView::OnWindowClosing() {
-  DCHECK(descriptor_) << "OnWindowClosing is called twice";
-  if (descriptor_) {
-    descriptor_->Destroy();
-    descriptor_ = NULL;
+  DCHECK(web_contents_) << "OnWindowClosing is called twice";
+  if (web_contents_) {
+    // Detach last (and only) tab.
+    web_container_->SetTabContents(NULL);
+
+    // Destroy the tab and navigation controller.
+    web_contents_->CloseContents();
+    web_contents_ = NULL;
+  }
+}
+
+void DevToolsView::SendMessageToClient(const IPC::Message& message) {
+  if (web_contents_) {
+    RenderViewHost* target_host = web_contents_->render_view_host();
+    IPC::Message* m =  new IPC::Message(message);
+    m->set_routing_id(target_host->routing_id());
+    target_host->Send(m);
+  }
+}
+
+bool DevToolsView::HasRenderViewHost(const RenderViewHost& rvh) const {
+  if (web_contents_) {
+    return (&rvh == web_contents_->render_view_host());
   }
-  web_container_->SetTabContents(NULL);  // detach last (and only) tab
-  web_contents_->CloseContents();  // destroy the tab and navigation controller
+  return false;
 }
 
 void DevToolsView::OpenURLFromTab(TabContents* source,
diff --git a/chrome/browser/debugger/devtools_view.h b/chrome/browser/debugger/devtools_view.h
index 2dc956c..873f7e0 100644
--- a/chrome/browser/debugger/devtools_view.h
+++ b/chrome/browser/debugger/devtools_view.h
@@ -12,18 +12,24 @@
 #include "chrome/browser/tab_contents/tab_contents_delegate.h"
 #include "chrome/views/view.h"
 
-class DevToolsInstanceDescriptor;
+namespace IPC {
+class Message;
+}
+
+class RenderViewHost;
 class TabContentsContainerView;
 class WebContents;
 
 class DevToolsView : public views::View,
                      public TabContentsDelegate {
  public:
-  explicit DevToolsView(DevToolsInstanceDescriptor* descriptor);
+  explicit DevToolsView();
   virtual ~DevToolsView();
 
   // Destroy content views when the window is closing.
   void OnWindowClosing();
+  void SendMessageToClient(const IPC::Message& message);
+  bool HasRenderViewHost(const RenderViewHost& rvh) const;
 
  private:
   // Overridden from TabContentsDelegate:
@@ -63,7 +69,6 @@ class DevToolsView : public views::View,
 
   void Init();
 
-  DevToolsInstanceDescriptor* descriptor_;
   WebContents* web_contents_;
   TabContentsContainerView* web_container_;
 
diff --git a/chrome/browser/debugger/devtools_window.h b/chrome/browser/debugger/devtools_window.h
index 257c44d..da13ae2 100644
--- a/chrome/browser/debugger/devtools_window.h
+++ b/chrome/browser/debugger/devtools_window.h
@@ -6,32 +6,29 @@
 #define CHROME_BROWSER_DEBUGGER_DEV_TOOLS_WINDOW_H_
 
 #include "base/basictypes.h"
+#include "chrome/browser/debugger/devtools_client_host.h"
 
-class DevToolsInstanceDescriptor;
+class RenderViewHost;
 
-class DevToolsWindow {
+class DevToolsWindow : public DevToolsClientHost {
  public:
-  static DevToolsWindow* Create(DevToolsInstanceDescriptor* descriptor);
+  // Factory method for creating platform specific devtools windows.
+  static DevToolsWindow* Create();
+
   virtual ~DevToolsWindow() {}
 
-  // Show developer tools window.
+  // Show this window.
   virtual void Show() = 0;
-  virtual void Close() = 0;
+  virtual bool HasRenderViewHost(const RenderViewHost& rvh) const = 0;
+
+  // DevToolsClientHost override.
+  virtual DevToolsWindow* AsDevToolsWindow() { return this; }
 
  protected:
-  DevToolsWindow() {}
+  DevToolsWindow() : DevToolsClientHost() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DevToolsWindow);
 };
 
-// Factory for creating DevToolsWindows.  Useful for unit tests.
-class DevToolsWindowFactory {
- public:
-  virtual ~DevToolsWindowFactory() {}
-  virtual DevToolsWindow* CreateDevToolsWindow(
-      DevToolsInstanceDescriptor* descriptor) = 0;
-};
-
-
 #endif  // CHROME_BROWSER_DEBUGGER_DEV_TOOLS_WINDOW_H_
diff --git a/chrome/browser/debugger/devtools_window_gtk.cc b/chrome/browser/debugger/devtools_window_gtk.cc
index be7096d..99b37c7 100644
--- a/chrome/browser/debugger/devtools_window_gtk.cc
+++ b/chrome/browser/debugger/devtools_window_gtk.cc
@@ -7,7 +7,7 @@
 #include "base/logging.h"
 
 // static
-DevToolsWindow* DevToolsWindow::Create(DevToolsInstanceDescriptor* descriptor) {
+DevToolsWindow* DevToolsWindow::Create() {
   NOTIMPLEMENTED();
   return NULL;
 }
diff --git a/chrome/browser/debugger/devtools_window_mac.cc b/chrome/browser/debugger/devtools_window_mac.cc
index be7096d..99b37c7 100644
--- a/chrome/browser/debugger/devtools_window_mac.cc
+++ b/chrome/browser/debugger/devtools_window_mac.cc
@@ -7,7 +7,7 @@
 #include "base/logging.h"
 
 // static
-DevToolsWindow* DevToolsWindow::Create(DevToolsInstanceDescriptor* descriptor) {
+DevToolsWindow* DevToolsWindow::Create() {
   NOTIMPLEMENTED();
   return NULL;
 }
diff --git a/chrome/browser/debugger/devtools_window_win.cc b/chrome/browser/debugger/devtools_window_win.cc
index d5dba5f..25175f5 100644
--- a/chrome/browser/debugger/devtools_window_win.cc
+++ b/chrome/browser/debugger/devtools_window_win.cc
@@ -6,20 +6,21 @@
 
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/debugger/devtools_view.h"
+#include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/views/window/window.h"
 
 
 // static
-DevToolsWindow* DevToolsWindow::Create(DevToolsInstanceDescriptor* descriptor) {
-  DevToolsView* view = new DevToolsView(descriptor);
+DevToolsWindow* DevToolsWindow::Create() {
+  DevToolsView* view = new DevToolsView();
   DevToolsWindowWin* window = new DevToolsWindowWin(view);
-  descriptor->SetDevToolsWindow(window);
   views::Window::CreateChromeWindow(NULL, gfx::Rect(), window);
   return window;
 }
 
 DevToolsWindowWin::DevToolsWindowWin(DevToolsView* view)
-    : tools_view_(view) {
+    : DevToolsWindow(),
+      tools_view_(view) {
 }
 
 DevToolsWindowWin::~DevToolsWindowWin() {
@@ -34,7 +35,14 @@ void DevToolsWindowWin::Show() {
   }
 }
 
-void DevToolsWindowWin::Close() {
+bool DevToolsWindowWin::HasRenderViewHost(const RenderViewHost& rvh) const {
+  if (tools_view_) {
+    return tools_view_->HasRenderViewHost(rvh);
+  }
+  return false;
+}
+
+void DevToolsWindowWin::InspectedTabClosing() {
   if (window()) {
     window()->Close();
   } else {
@@ -42,12 +50,20 @@ void DevToolsWindowWin::Close() {
   }
 }
 
+void DevToolsWindowWin::SendMessageToClient(const IPC::Message& message) {
+  if (tools_view_) {
+    tools_view_->SendMessageToClient(message);
+  }
+}
+
 std::wstring DevToolsWindowWin::GetWindowTitle() const {
   return L"Developer Tools";
 }
 
 void DevToolsWindowWin::WindowClosing() {
   if (tools_view_) {
+    NotifyCloseListener();
+
     ReleaseWindow();
     tools_view_->OnWindowClosing();
     tools_view_ = NULL;
diff --git a/chrome/browser/debugger/devtools_window_win.h b/chrome/browser/debugger/devtools_window_win.h
index 0ebf01b..4cea5a3 100644
--- a/chrome/browser/debugger/devtools_window_win.h
+++ b/chrome/browser/debugger/devtools_window_win.h
@@ -12,7 +12,6 @@
 namespace views {
 class Window;
 }
-class DevToolsInstanceDescriptor;
 class DevToolsView;
 class TabContents;
 
@@ -21,13 +20,16 @@ class DevToolsWindowWin : public DevToolsWindow,
  public:
   virtual ~DevToolsWindowWin();
 
-  // Show developer tools window.
+  // DevToolsWindow implementation.
   virtual void Show();
-  virtual void Close();
+  virtual bool HasRenderViewHost(const RenderViewHost& rvh) const;
+
+  virtual void InspectedTabClosing();
+  virtual void SendMessageToClient(const IPC::Message& message);
 
  private:
   friend class DevToolsWindow;
-  explicit DevToolsWindowWin(DevToolsView* view);
+  DevToolsWindowWin(DevToolsView* view);
 
   // views::WindowDelegate methods:
   virtual std::wstring GetWindowTitle() const;
diff --git a/chrome/browser/renderer_host/render_view_host.cc b/chrome/browser/renderer_host/render_view_host.cc
index 6a4160e..826dff2 100644
--- a/chrome/browser/renderer_host/render_view_host.cc
+++ b/chrome/browser/renderer_host/render_view_host.cc
@@ -1194,11 +1194,12 @@ void RenderViewHost::DidDebugAttach() {
 }
 
 void RenderViewHost::OnForwardToDevToolsAgent(const IPC::Message& message) {
-  g_browser_process->devtools_manager()->ForwardToDevToolsAgent(this, message);
+  g_browser_process->devtools_manager()->ForwardToDevToolsAgent(*this, message);
 }
 
 void RenderViewHost::OnForwardToDevToolsClient(const IPC::Message& message) {
-  g_browser_process->devtools_manager()->ForwardToDevToolsClient(this, message);
+  g_browser_process->devtools_manager()->ForwardToDevToolsClient(*this,
+                                                                 message);
 }
 
 void RenderViewHost::OnUserMetricsRecordAction(const std::wstring& action) {
diff --git a/chrome/chrome.gyp b/chrome/chrome.gyp
index d0a4246..f75a25e8 100644
--- a/chrome/chrome.gyp
+++ b/chrome/chrome.gyp
@@ -543,6 +543,7 @@
         'browser/debugger/debugger_window.h',
         'browser/debugger/debugger_wrapper.cc',
         'browser/debugger/debugger_wrapper.h',
+        'browser/debugger/devtools_client_host.h',
         'browser/debugger/devtools_manager.h',
         'browser/debugger/devtools_manager.cc',
         'browser/debugger/devtools_window.h',
diff --git a/chrome/test/data/purify/unit_tests.exe.gtest.txt b/chrome/test/data/purify/unit_tests.exe.gtest.txt
index 6f0ea56..081eb0b 100644
--- a/chrome/test/data/purify/unit_tests.exe.gtest.txt
+++ b/chrome/test/data/purify/unit_tests.exe.gtest.txt
@@ -16,6 +16,3 @@ IPCSyncChannelTest.ChattyServer
 
 # issue 8362
 ExtensionViewTest.Index
-
-# issue 9150
-DevToolsManagerTest.*