DevTools: add initial support for shared workers debugging.

WorkerDevToolsManager is a service that is used for managing DevTools connections to DevTools agents in shared workers. It operates on the IO thread. Each debugged shared worker instance has unique devtools id which is used for addressing workers when passing messages between WorkerDevToolsManager and DevToolsManager. WorkerDevToolsManager translates those ids into WorkerProcessHost and worker_routing_id and back.

WorkerDevToolsMessageFilter passes worker messages to the WorkerDevToolsManager which in turn forwards them to DevToolsManager on the UI thread where they are dispatched to corresponding DevTools window.

Messages from DevTools frontend go through the DevToolsManager which forwards them to WorkerDevToolsManager on the IO thread where they are sent by means of corresponding WorkerProcessHost to the corresponding WorkerDevToolsAgent.

BUG=None
TEST=None

Review URL: http://codereview.chromium.org/7248076

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

15 files changed, 557 insertions, 49 deletions

diff --git a/content/browser/debugger/devtools_handler.cc b/content/browser/debugger/devtools_handler.cc
index 396ef1a..fc97c40 100644
--- a/content/browser/debugger/devtools_handler.cc
+++ b/content/browser/debugger/devtools_handler.cc
@@ -7,6 +7,7 @@
 #include "content/browser/debugger/devtools_file_util.h"
 #include "content/browser/debugger/devtools_manager.h"
 #include "content/browser/debugger/devtools_window.h"
+#include "content/browser/debugger/worker_devtools_manager_io.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/devtools_messages.h"
@@ -42,6 +43,9 @@ void DevToolsHandler::OnForwardToAgent(const IPC::Message& message) {
       render_view_host());
   if (!window)
     return;
+  if (WorkerDevToolsManagerIO::ForwardToWorkerDevToolsAgentOnUIThread(
+      window, message))
+    return;
   DevToolsManager::GetInstance()->ForwardToDevToolsAgent(window, message);
 }
 
diff --git a/content/browser/debugger/devtools_window.cc b/content/browser/debugger/devtools_window.cc
index a7aae48..8d0abbb 100644
--- a/content/browser/debugger/devtools_window.cc
+++ b/content/browser/debugger/devtools_window.cc
@@ -75,6 +75,12 @@ DevToolsWindow* DevToolsWindow::FindDevToolsWindow(
 }
 
 // static
+DevToolsWindow* DevToolsWindow::CreateDevToolsWindowForWorker(
+    Profile* profile) {
+  return new DevToolsWindow(profile, NULL, false);
+}
+
+// static
 DevToolsWindow* DevToolsWindow::OpenDevToolsWindow(
     RenderViewHost* inspected_rvh) {
   return ToggleDevToolsWindow(inspected_rvh, true,
@@ -131,10 +137,12 @@ DevToolsWindow::DevToolsWindow(Profile* profile,
       this,
       chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
       Source<ThemeService>(ThemeServiceFactory::GetForProfile(profile_)));
-  TabContents* tab = inspected_rvh->delegate()->GetAsTabContents();
-  if (tab)
-    inspected_tab_ = TabContentsWrapper::GetCurrentWrapperForContents(tab);
-
+  // There is no inspected_rvh in case of shared workers.
+  if (inspected_rvh) {
+    TabContents* tab = inspected_rvh->delegate()->GetAsTabContents();
+    if (tab)
+      inspected_tab_ = TabContentsWrapper::GetCurrentWrapperForContents(tab);
+  }
   instances_.push_back(this);
 }
 
diff --git a/content/browser/debugger/devtools_window.h b/content/browser/debugger/devtools_window.h
index 819e068..2c26ec6 100644
--- a/content/browser/debugger/devtools_window.h
+++ b/content/browser/debugger/devtools_window.h
@@ -38,6 +38,7 @@ class DevToolsWindow
   static TabContentsWrapper* GetDevToolsContents(TabContents* inspected_tab);
   static DevToolsWindow* FindDevToolsWindow(RenderViewHost* window_rvh);
 
+  static DevToolsWindow* CreateDevToolsWindowForWorker(Profile* profile);
   static DevToolsWindow* OpenDevToolsWindow(RenderViewHost* inspected_rvh);
   static DevToolsWindow* ToggleDevToolsWindow(RenderViewHost* inspected_rvh,
                                               DevToolsToggleAction action);
diff --git a/content/browser/debugger/worker_devtools_manager_io.cc b/content/browser/debugger/worker_devtools_manager_io.cc
new file mode 100644
index 0000000..7fec014
--- /dev/null
+++ b/content/browser/debugger/worker_devtools_manager_io.cc
@@ -0,0 +1,306 @@
+// Copyright (c) 2011 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/debugger/worker_devtools_manager_io.h"
+
+#include <list>
+
+#include "base/tuple.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "content/browser/browser_thread.h"
+#include "content/browser/debugger/devtools_manager.h"
+#include "content/browser/debugger/devtools_window.h"
+#include "content/browser/debugger/worker_devtools_message_filter.h"
+#include "content/browser/worker_host/worker_process_host.h"
+#include "content/common/devtools_messages.h"
+
+namespace {
+
+void NotifyWorkerDevToolsClientClosingOnIOThread(int worker_process_host_id,
+                                                 int worker_route_id) {
+  WorkerDevToolsManagerIO::GetInstance()->WorkerDevToolsClientClosing(
+      worker_process_host_id,
+      worker_route_id);
+}
+
+class ClientsUI : public DevToolsClientHost::CloseListener {
+ public:
+  static ClientsUI* GetInstance() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    static ClientsUI* instance = new ClientsUI();
+    return instance;
+  }
+
+  DevToolsClientHost* FindDevToolsClient(int worker_process_host_id,
+                                         int worker_route_id) {
+    WorkerIdToClientHostMap::iterator it =
+        worker_id_to_client_host_.find(WorkerId(worker_process_host_id,
+                                                worker_route_id));
+    if (it == worker_id_to_client_host_.end())
+      return NULL;
+    return it->second;
+  }
+
+  bool FindWorkerInfo(DevToolsClientHost* client_host,
+                      int* host_id,
+                      int* route_id) {
+    for (WorkerIdToClientHostMap::const_iterator it =
+             worker_id_to_client_host_.begin();
+         it != worker_id_to_client_host_.end(); ++it) {
+      if (it->second == client_host) {
+        WorkerId id = it->first;
+        *host_id = id.first;
+        *route_id = id.second;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  void RegisterDevToolsClientForWorker(int worker_process_host_id,
+                                       int worker_route_id,
+                                       DevToolsClientHost* client) {
+    client->set_close_listener(this);
+    WorkerId worker_id(worker_process_host_id, worker_route_id);
+    worker_id_to_client_host_[worker_id] = client;
+  }
+
+ private:
+  ClientsUI() {}
+  virtual ~ClientsUI() {}
+
+  virtual void ClientHostClosing(DevToolsClientHost* host) {
+    WorkerIdToClientHostMap::iterator it = worker_id_to_client_host_.begin();
+    for (; it != worker_id_to_client_host_.end(); ++it) {
+      if (it->second == host) {
+        WorkerId id = it->first;
+        BrowserThread::PostTask(
+            BrowserThread::IO, FROM_HERE,
+            NewRunnableFunction(NotifyWorkerDevToolsClientClosingOnIOThread,
+                                id.first, id.second));
+        worker_id_to_client_host_.erase(it);
+        return;
+      }
+    }
+  }
+
+  typedef std::pair<int, int> WorkerId;
+  typedef std::map<WorkerId, DevToolsClientHost*> WorkerIdToClientHostMap;
+  WorkerIdToClientHostMap worker_id_to_client_host_;
+
+  DISALLOW_COPY_AND_ASSIGN(ClientsUI);
+};
+
+}  // namespace
+
+class WorkerDevToolsManagerIO::InspectedWorkersList {
+ public:
+  InspectedWorkersList() {}
+
+  void AddInstance(WorkerProcessHost* host, int route_id) {
+    DCHECK(!Contains(host->id(), route_id));
+    map_.push_back(Entry(host, route_id));
+  }
+
+  bool Contains(int host_id, int route_id) {
+    return FindHost(host_id, route_id) != NULL;
+  }
+
+  WorkerProcessHost* FindHost(int host_id, int route_id) {
+    Entries::iterator it = FindEntry(host_id, route_id);
+    if (it == map_.end())
+      return NULL;
+    return it->host;
+  }
+
+  WorkerProcessHost* RemoveInstance(int host_id, int route_id) {
+    Entries::iterator it = FindEntry(host_id, route_id);
+    if (it == map_.end())
+      return NULL;
+    WorkerProcessHost* host = it->host;
+    map_.erase(it);
+    return host;
+  }
+
+  void WorkerDevToolsMessageFilterClosing(int worker_process_host_id) {
+    Entries::iterator it = map_.begin();
+    while (it != map_.end()) {
+      if (it->host->id() == worker_process_host_id)
+        it = map_.erase(it);
+      else
+        ++it;
+    }
+  }
+
+ private:
+  struct Entry {
+    Entry(WorkerProcessHost* host, int route_id)
+        : host(host),
+          route_id(route_id) {}
+    WorkerProcessHost* const host;
+    int const route_id;
+  };
+  typedef std::list<Entry> Entries;
+
+  Entries::iterator FindEntry(int host_id, int route_id) {
+    Entries::iterator it = map_.begin();
+    while (it != map_.end()) {
+      if (it->host->id() == host_id && it->route_id == route_id)
+        break;
+    }
+    return it;
+  }
+
+  Entries map_;
+  DISALLOW_COPY_AND_ASSIGN(InspectedWorkersList);
+};
+
+// static
+WorkerDevToolsManagerIO* WorkerDevToolsManagerIO::GetInstance() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  return Singleton<WorkerDevToolsManagerIO>::get();
+}
+
+WorkerDevToolsManagerIO::WorkerDevToolsManagerIO()
+    : inspected_workers_(new InspectedWorkersList()) {
+}
+
+WorkerDevToolsManagerIO::~WorkerDevToolsManagerIO() {
+}
+
+bool WorkerDevToolsManagerIO::ForwardToWorkerDevToolsAgentOnUIThread(
+    DevToolsClientHost* from,
+    const IPC::Message& message) {
+  int worker_process_host_id;
+  int worker_route_id;
+  if (!ClientsUI::GetInstance()->FindWorkerInfo(
+          from, &worker_process_host_id, &worker_route_id))
+    return false;
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      NewRunnableFunction(
+          ForwardToWorkerDevToolsAgentOnIOThread,
+          worker_process_host_id,
+          worker_route_id,
+          IPC::Message(message)));
+  return true;
+}
+
+static void OpenDevToolsForWorkerOnUIThread(int worker_process_host_id,
+                                            int worker_route_id) {
+  Profile* profile = ProfileManager::GetDefaultProfile();
+  if (!profile)
+    return;
+  DevToolsWindow* window = DevToolsWindow::CreateDevToolsWindowForWorker(
+      profile);
+  window->Show(DEVTOOLS_TOGGLE_ACTION_NONE);
+  ClientsUI::GetInstance()->RegisterDevToolsClientForWorker(
+      worker_process_host_id, worker_route_id, window);
+}
+
+static WorkerProcessHost* FindWorkerProcessHostForWorker(
+    int worker_process_host_id,
+    int worker_route_id) {
+  BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (; !iter.Done(); ++iter) {
+    if (iter->id() != worker_process_host_id)
+      continue;
+    WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
+    const WorkerProcessHost::Instances& instances = worker->instances();
+    for (WorkerProcessHost::Instances::const_iterator i = instances.begin();
+         i != instances.end(); ++i) {
+      if (i->shared() && i->worker_route_id() == worker_route_id)
+        return worker;
+    }
+    return NULL;
+  }
+  return NULL;
+}
+
+void WorkerDevToolsManagerIO::OpenDevToolsForWorker(int worker_process_host_id,
+                                                    int worker_route_id) {
+  WorkerProcessHost* host = FindWorkerProcessHostForWorker(
+      worker_process_host_id,
+      worker_route_id);
+  if (!host)
+    return;
+
+  // DevTools client is already attached.
+  if (inspected_workers_->Contains(worker_process_host_id, worker_route_id))
+    return;
+
+  host->Send(new WorkerDevToolsAgentMsg_Attach(worker_route_id));
+
+  inspected_workers_->AddInstance(host, worker_route_id);
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      NewRunnableFunction(
+          OpenDevToolsForWorkerOnUIThread,
+          worker_process_host_id,
+          worker_route_id));
+}
+
+void WorkerDevToolsManagerIO::WorkerDevToolsClientClosing(
+    int worker_process_host_id,
+    int worker_route_id) {
+  WorkerProcessHost* host = inspected_workers_->RemoveInstance(
+      worker_process_host_id, worker_route_id);
+  if (host)
+    host->Send(new WorkerDevToolsAgentMsg_Detach(worker_route_id));
+}
+
+static void ForwardToDevToolsClientOnUIThread(
+    int worker_process_host_id,
+    int worker_route_id,
+    const IPC::Message& message) {
+  DevToolsClientHost* client = ClientsUI::GetInstance()->
+      FindDevToolsClient(worker_process_host_id, worker_route_id);
+  if (client)
+    client->SendMessageToClient(message);
+}
+
+void WorkerDevToolsManagerIO::ForwardToDevToolsClient(
+    int worker_process_host_id,
+    int worker_route_id,
+    const IPC::Message& message) {
+  if (!inspected_workers_->Contains(worker_process_host_id, worker_route_id)) {
+      NOTREACHED();
+      return;
+  }
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      NewRunnableFunction(
+          ForwardToDevToolsClientOnUIThread,
+          worker_process_host_id,
+          worker_route_id,
+          IPC::Message(message)));
+}
+
+void WorkerDevToolsManagerIO::WorkerProcessDestroying(
+    int worker_process_host_id) {
+  inspected_workers_->WorkerDevToolsMessageFilterClosing(
+      worker_process_host_id);
+}
+
+void WorkerDevToolsManagerIO::ForwardToWorkerDevToolsAgentOnIOThread(
+    int worker_process_host_id,
+    int worker_route_id,
+    const IPC::Message& message) {
+  WorkerDevToolsManagerIO::GetInstance()->ForwardToWorkerDevToolsAgent(
+      worker_process_host_id, worker_route_id, message);
+}
+
+void WorkerDevToolsManagerIO::ForwardToWorkerDevToolsAgent(
+    int worker_process_host_id,
+    int worker_route_id,
+    const IPC::Message& message) {
+  WorkerProcessHost* host = inspected_workers_->FindHost(
+      worker_process_host_id,
+      worker_route_id);
+  if (!host)
+    return;
+  IPC::Message* msg = new IPC::Message(message);
+  msg->set_routing_id(worker_route_id);
+  host->Send(msg);
+}
diff --git a/content/browser/debugger/worker_devtools_manager_io.h b/content/browser/debugger/worker_devtools_manager_io.h
new file mode 100644
index 0000000..fbacff6
--- /dev/null
+++ b/content/browser/debugger/worker_devtools_manager_io.h
@@ -0,0 +1,57 @@
+// Copyright (c) 2011 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 CONTENT_BROWSER_DEBUGGER_WORKER_DEVTOOLS_MANAGER_IO_H_
+#define CONTENT_BROWSER_DEBUGGER_WORKER_DEVTOOLS_MANAGER_IO_H_
+#pragma once
+
+#include "base/basictypes.h"
+#include "base/memory/singleton.h"
+#include "base/scoped_ptr.h"
+
+namespace IPC {
+class Message;
+}
+class DevToolsClientHost;
+class WorkerDevToolsMessageFilter;
+
+// All methods are supposed to be called on the IO thread.
+class WorkerDevToolsManagerIO {
+ public:
+  // Returns the WorkerDevToolsManagerIO singleton.
+  static WorkerDevToolsManagerIO* GetInstance();
+
+  // This method is called on the UI thread by the devtools handler.
+  static bool ForwardToWorkerDevToolsAgentOnUIThread(
+      DevToolsClientHost* from,
+      const IPC::Message& message);
+
+  void OpenDevToolsForWorker(int worker_process_id, int worker_route_id);
+  void WorkerDevToolsClientClosing(int worker_process_host_id,
+                                   int worker_route_id);
+
+  void ForwardToDevToolsClient(int worker_process_id,
+                               int worker_route_id,
+                               const IPC::Message& message);
+  void WorkerProcessDestroying(int worker_process_host_id);
+
+ private:
+  friend struct DefaultSingletonTraits<WorkerDevToolsManagerIO>;
+
+  WorkerDevToolsManagerIO();
+  ~WorkerDevToolsManagerIO();
+  static void ForwardToWorkerDevToolsAgentOnIOThread(
+      int worker_process_host_id,
+      int worker_route_id,
+      const IPC::Message& message);
+  void ForwardToWorkerDevToolsAgent(int worker_process_host_id,
+                                    int worker_route_id,
+                                    const IPC::Message& message);
+  class InspectedWorkersList;
+  scoped_ptr<InspectedWorkersList> inspected_workers_;
+
+  DISALLOW_COPY_AND_ASSIGN(WorkerDevToolsManagerIO);
+};
+
+#endif  // CONTENT_BROWSER_DEBUGGER_WORKER_DEVTOOLS_MANAGER_IO_H_
diff --git a/content/browser/debugger/worker_devtools_message_filter.cc b/content/browser/debugger/worker_devtools_message_filter.cc
new file mode 100644
index 0000000..a086c9b
--- /dev/null
+++ b/content/browser/debugger/worker_devtools_message_filter.cc
@@ -0,0 +1,42 @@
+// Copyright (c) 2011 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/debugger/worker_devtools_message_filter.h"
+
+#include "content/browser/debugger/worker_devtools_manager_io.h"
+#include "content/browser/worker_host/worker_service.h"
+#include "content/common/devtools_messages.h"
+#include "content/common/worker_messages.h"
+
+WorkerDevToolsMessageFilter::WorkerDevToolsMessageFilter(
+    int worker_process_host_id)
+    : worker_process_host_id_(worker_process_host_id) {
+}
+
+WorkerDevToolsMessageFilter::~WorkerDevToolsMessageFilter() {
+}
+
+void WorkerDevToolsMessageFilter::OnChannelClosing() {
+  BrowserMessageFilter::OnChannelClosing();
+  WorkerDevToolsManagerIO::GetInstance()->WorkerProcessDestroying(
+      worker_process_host_id_);
+}
+
+bool WorkerDevToolsMessageFilter::OnMessageReceived(
+    const IPC::Message& message,
+    bool* message_was_ok) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP_EX(WorkerDevToolsMessageFilter, message,
+                           *message_was_ok)
+    IPC_MESSAGE_HANDLER(DevToolsHostMsg_ForwardToClient, OnForwardToClient)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP_EX()
+  return handled;
+}
+
+void WorkerDevToolsMessageFilter::OnForwardToClient(
+    const IPC::Message& message) {
+  WorkerDevToolsManagerIO::GetInstance()->ForwardToDevToolsClient(
+      worker_process_host_id_, message.routing_id(), message);
+}
diff --git a/content/browser/debugger/worker_devtools_message_filter.h b/content/browser/debugger/worker_devtools_message_filter.h
new file mode 100644
index 0000000..5353782
--- /dev/null
+++ b/content/browser/debugger/worker_devtools_message_filter.h
@@ -0,0 +1,31 @@
+// Copyright (c) 2011 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 CONTENT_BROWSER_DEBUGGER_WORKER_DEVTOOLS_MESSAGE_FILTER_H_
+#define CONTENT_BROWSER_DEBUGGER_WORKER_DEVTOOLS_MESSAGE_FILTER_H_
+#pragma once
+
+#include "base/callback.h"
+#include "content/browser/browser_message_filter.h"
+
+class WorkerDevToolsMessageFilter : public BrowserMessageFilter {
+ public:
+  explicit WorkerDevToolsMessageFilter(int worker_process_host_id);
+
+ private:
+  virtual ~WorkerDevToolsMessageFilter();
+
+  // BrowserMessageFilter implementation.
+  virtual void OnChannelClosing();
+  virtual bool OnMessageReceived(const IPC::Message& message,
+                                 bool* message_was_ok);
+  // Message handlers.
+  void OnForwardToClient(const IPC::Message& message);
+
+  int worker_process_host_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(WorkerDevToolsMessageFilter);
+};
+
+#endif  // CONTENT_BROWSER_DEBUGGER_WORKER_DEVTOOLS_MESSAGE_FILTER_H_
diff --git a/content/browser/worker_host/worker_process_host.cc b/content/browser/worker_host/worker_process_host.cc
index 8dc2e1a..59fdcee8 100644
--- a/content/browser/worker_host/worker_process_host.cc
+++ b/content/browser/worker_host/worker_process_host.cc
@@ -16,6 +16,7 @@
 #include "content/browser/browser_thread.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/content_browser_client.h"
+#include "content/browser/debugger/worker_devtools_message_filter.h"
 #include "content/browser/file_system/file_system_dispatcher_host.h"
 #include "content/browser/mime_registry_message_filter.h"
 #include "content/browser/renderer_host/blob_message_filter.h"
@@ -255,6 +256,7 @@ void WorkerProcessHost::CreateMessageFilters(int render_process_id) {
       new SocketStreamDispatcherHost(
           new URLRequestContextSelector(request_context), resource_context_);
   AddFilter(socket_stream_dispatcher_host);
+  AddFilter(new WorkerDevToolsMessageFilter(id()));
 }
 
 void WorkerProcessHost::CreateWorker(const WorkerInstance& instance) {
diff --git a/content/common/devtools_messages.h b/content/common/devtools_messages.h
index 6c456b6..98d998d 100644
--- a/content/common/devtools_messages.h
+++ b/content/common/devtools_messages.h
@@ -153,5 +153,3 @@ IPC_MESSAGE_ROUTED2(DevToolsHostMsg_RuntimePropertyChanged,
 
 IPC_MESSAGE_ROUTED0(WorkerDevToolsAgentMsg_Attach)
 IPC_MESSAGE_ROUTED0(WorkerDevToolsAgentMsg_Detach)
-IPC_MESSAGE_ROUTED1(WorkerDevToolsAgentMsg_DispatchOnInspectorBackend,
-                    std::string /* message */)
diff --git a/content/renderer/worker_devtools_agent_proxy.cc b/content/renderer/worker_devtools_agent_proxy.cc
index ba7fe2a..db09e0d 100644
--- a/content/renderer/worker_devtools_agent_proxy.cc
+++ b/content/renderer/worker_devtools_agent_proxy.cc
@@ -53,8 +53,7 @@ void WorkerDevToolsAgentProxy::DetachDevTools() {
 
 void WorkerDevToolsAgentProxy::SendDevToolsMessage(
     const std::string& message) {
-  Send(new WorkerDevToolsAgentMsg_DispatchOnInspectorBackend(route_id_,
-                                                             message));
+  Send(new DevToolsAgentMsg_DispatchOnInspectorBackend(route_id_, message));
 }
 
 void WorkerDevToolsAgentProxy::OnDispatchMessageFromWorker(
diff --git a/content/worker/websharedworker_stub.cc b/content/worker/websharedworker_stub.cc
index 3ecf598..da16b15 100644
--- a/content/worker/websharedworker_stub.cc
+++ b/content/worker/websharedworker_stub.cc
@@ -8,6 +8,7 @@
 #include "content/common/file_system/file_system_dispatcher.h"
 #include "content/common/webmessageportchannel_impl.h"
 #include "content/common/worker_messages.h"
+#include "content/worker/worker_devtools_agent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSharedWorker.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
@@ -17,9 +18,13 @@ WebSharedWorkerStub::WebSharedWorkerStub(
     const WorkerAppCacheInitInfo& appcache_init_info)
     : WebWorkerStubBase(route_id, appcache_init_info),
       name_(name),
-      started_(false) {
+      started_(false),
+      worker_devtools_agent_(NULL) {
   // TODO(atwilson): Add support for NaCl when they support MessagePorts.
   impl_ = WebKit::WebSharedWorker::create(client());
+  worker_devtools_agent_.reset(WorkerDevToolsAgent::CreateForSharedWorker(
+      route_id, impl_));
+  client()->set_devtools_agent(worker_devtools_agent_.get());
 }
 
 WebSharedWorkerStub::~WebSharedWorkerStub() {
@@ -27,6 +32,9 @@ WebSharedWorkerStub::~WebSharedWorkerStub() {
 }
 
 bool WebSharedWorkerStub::OnMessageReceived(const IPC::Message& message) {
+  if (worker_devtools_agent_->OnMessageReceived(message))
+    return true;
+
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WebSharedWorkerStub, message)
     IPC_MESSAGE_HANDLER(WorkerMsg_StartWorkerContext, OnStartWorkerContext)
diff --git a/content/worker/websharedworker_stub.h b/content/worker/websharedworker_stub.h
index 6083460..dc4ebed 100644
--- a/content/worker/websharedworker_stub.h
+++ b/content/worker/websharedworker_stub.h
@@ -14,6 +14,8 @@ namespace WebKit {
 class WebSharedWorker;
 }
 
+class WorkerDevToolsAgent;
+
 // This class creates a WebSharedWorker, and translates incoming IPCs to the
 // appropriate WebSharedWorker APIs.
 class WebSharedWorkerStub : public WebWorkerStubBase {
@@ -39,6 +41,7 @@ class WebSharedWorkerStub : public WebWorkerStubBase {
   string16 name_;
   bool started_;
   GURL url_;
+  scoped_ptr<WorkerDevToolsAgent> worker_devtools_agent_;
 
   typedef std::pair<int, int> PendingConnectInfo;
   typedef std::vector<PendingConnectInfo> PendingConnectInfoList;
diff --git a/content/worker/webworker_stub.cc b/content/worker/webworker_stub.cc
index b7ecd13..f782bb3 100644
--- a/content/worker/webworker_stub.cc
+++ b/content/worker/webworker_stub.cc
@@ -23,7 +23,7 @@ WebWorkerStub::WebWorkerStub(const GURL& url, int route_id,
       ALLOW_THIS_IN_INITIALIZER_LIST(impl_(WebWorker::create(client()))),
       url_(url),
       ALLOW_THIS_IN_INITIALIZER_LIST(worker_devtools_agent_(
-          new WorkerDevToolsAgent(route_id, impl_))) {
+          WorkerDevToolsAgent::CreateForDedicatedWorker(route_id, impl_))) {
   client()->set_devtools_agent(worker_devtools_agent_.get());
 }
 
diff --git a/content/worker/worker_devtools_agent.cc b/content/worker/worker_devtools_agent.cc
index af00871..2ff069a 100644
--- a/content/worker/worker_devtools_agent.cc
+++ b/content/worker/worker_devtools_agent.cc
@@ -7,51 +7,98 @@
 #include "content/common/devtools_messages.h"
 #include "content/worker/worker_thread.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCString.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebSharedWorker.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebWorker.h"
 
+using WebKit::WebSharedWorker;
 using WebKit::WebString;
 using WebKit::WebWorker;
 
-WorkerDevToolsAgent::WorkerDevToolsAgent(int route_id, WebWorker* webworker)
-    : route_id_(route_id),
-      webworker_(webworker) {
+namespace {
+
+template<class T>
+class WorkerDevToolsAgentImpl : public WorkerDevToolsAgent {
+ public:
+  WorkerDevToolsAgentImpl(int route_id, T* webworker)
+      : WorkerDevToolsAgent(route_id),
+        webworker_(webworker) {}
+
+ private:
+  virtual ~WorkerDevToolsAgentImpl() {}
+
+  // Called on the Worker thread.
+  virtual bool OnMessageReceived(const IPC::Message& message) {
+    bool handled = true;
+    IPC_BEGIN_MESSAGE_MAP(WorkerDevToolsAgentImpl, message)
+      IPC_MESSAGE_HANDLER(WorkerDevToolsAgentMsg_Attach, OnAttach)
+      IPC_MESSAGE_HANDLER(WorkerDevToolsAgentMsg_Detach, OnDetach)
+      IPC_MESSAGE_HANDLER(DevToolsAgentMsg_DispatchOnInspectorBackend,
+                          OnDispatchOnInspectorBackend)
+      IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_END_MESSAGE_MAP()
+    return handled;
+  }
+
+  virtual void SendDevToolsMessage(const WebKit::WebString& message);
+
+  void OnAttach() {
+    webworker_->attachDevTools();
+  }
+
+  void OnDetach() {
+    webworker_->detachDevTools();
+  }
+
+  void OnDispatchOnInspectorBackend(
+      const std::string& message) {
+    webworker_->dispatchDevToolsMessage(WebString::fromUTF8(message));
+  }
+
+  T* webworker_;
+
+  DISALLOW_COPY_AND_ASSIGN(WorkerDevToolsAgentImpl);
+};
+
+
+template<>
+void WorkerDevToolsAgentImpl<WebWorker>::SendDevToolsMessage(
+    const WebKit::WebString& message) {
+  Send(new DevToolsAgentMsg_DispatchMessageFromWorker(route_id_,
+                                                      message.utf8()));
 }
 
-WorkerDevToolsAgent::~WorkerDevToolsAgent() {
+template<>
+void WorkerDevToolsAgentImpl<WebSharedWorker>::SendDevToolsMessage(
+    const WebKit::WebString& message) {
+    IPC::Message m = DevToolsClientMsg_DispatchOnInspectorFrontend(
+        route_id_,
+        message.utf8());
+    Send(new DevToolsHostMsg_ForwardToClient(route_id_, m));
 }
 
-// Called on the Worker thread.
-bool WorkerDevToolsAgent::OnMessageReceived(const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(WorkerDevToolsAgent, message)
-    IPC_MESSAGE_HANDLER(WorkerDevToolsAgentMsg_Attach, OnAttach)
-    IPC_MESSAGE_HANDLER(WorkerDevToolsAgentMsg_Detach, OnDetach)
-    IPC_MESSAGE_HANDLER(WorkerDevToolsAgentMsg_DispatchOnInspectorBackend,
-                        OnDispatchOnInspectorBackend)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
+}  // namespace
+
+WorkerDevToolsAgent::WorkerDevToolsAgent(int route_id)
+    : route_id_(route_id) {
 }
 
-void WorkerDevToolsAgent::OnAttach() {
-  webworker_->attachDevTools();
+WorkerDevToolsAgent* WorkerDevToolsAgent::CreateForDedicatedWorker(
+    int route_id,
+    WebWorker* webworker) {
+  return new WorkerDevToolsAgentImpl<WebWorker>(route_id, webworker);
 }
 
-void WorkerDevToolsAgent::OnDetach() {
-  webworker_->detachDevTools();
+WorkerDevToolsAgent* WorkerDevToolsAgent::CreateForSharedWorker(
+    int route_id,
+    WebSharedWorker* webshared_worker) {
+  return new WorkerDevToolsAgentImpl<WebSharedWorker>(route_id,
+                                                      webshared_worker);
 }
 
-void WorkerDevToolsAgent::OnDispatchOnInspectorBackend(
-    const std::string& message) {
-  webworker_->dispatchDevToolsMessage(WebString::fromUTF8(message));
+WorkerDevToolsAgent::~WorkerDevToolsAgent() {
 }
 
 bool WorkerDevToolsAgent::Send(IPC::Message* message) {
   return WorkerThread::current()->Send(message);
 }
-
-void WorkerDevToolsAgent::SendDevToolsMessage(const WebString& message) {
-  Send(new DevToolsAgentMsg_DispatchMessageFromWorker(route_id_,
-                                                      message.utf8()));
-}
diff --git a/content/worker/worker_devtools_agent.h b/content/worker/worker_devtools_agent.h
index 64dc3c8..372dac7 100644
--- a/content/worker/worker_devtools_agent.h
+++ b/content/worker/worker_devtools_agent.h
@@ -15,28 +15,30 @@ class Message;
 }
 
 namespace WebKit {
+class WebSharedWorker;
 class WebString;
 class WebWorker;
 }
 
 class WorkerDevToolsAgent {
  public:
-  WorkerDevToolsAgent(int route_id, WebKit::WebWorker*);
-  ~WorkerDevToolsAgent();
+  static WorkerDevToolsAgent* CreateForDedicatedWorker(
+      int route_id,
+      WebKit::WebWorker*);
+  static WorkerDevToolsAgent* CreateForSharedWorker(
+      int route_id,
+      WebKit::WebSharedWorker*);
+  virtual ~WorkerDevToolsAgent();
 
-  bool OnMessageReceived(const IPC::Message& message);
+  // Called on the Worker thread.
+  virtual bool OnMessageReceived(const IPC::Message& message) = 0;
+  virtual void SendDevToolsMessage(const WebKit::WebString&) = 0;
 
-  void SendDevToolsMessage(const WebKit::WebString&);
-
- private:
-  void OnAttach();
-  void OnDetach();
-  void OnDispatchOnInspectorBackend(const std::string& message);
+ protected:
+  explicit WorkerDevToolsAgent(int route_id);
 
   bool Send(IPC::Message* message);
-
-  int route_id_;
-  WebKit::WebWorker* webworker_;
+  const int route_id_;
 
   DISALLOW_COPY_AND_ASSIGN(WorkerDevToolsAgent);
 };