Split EmbeddedWorkerDevToolsManager into two for Shared- and ServiceWorker

One more follow-up patch for
https://codereview.chromium.org/761923004/#msg18
https://codereview.chromium.org/814513003/

- Split EmbeddedWorkerDevToolsManager into two, Shared- and ServiceWorkerDevToolsManager, and made them inherit from EmbeddedWorkerDevToolsManager
- Renamed EmbeddedWorkerDevToolsAgentHost to WorkerDevToolsAgentHost
- Renamed EmbeddedWorkerDevToolsManager to WorkerDevToolsManager

BUG=443470
TEST=SharedWorkerDevToolsMangerTest\*

Review URL: https://codereview.chromium.org/817653002

Cr-Commit-Position: refs/heads/master@{#309412}

24 files changed, 549 insertions, 454 deletions

diff --git a/content/browser/devtools/devtools_agent_host_impl.cc b/content/browser/devtools/devtools_agent_host_impl.cc
index 3c85dd7..5274b83 100644
--- a/content/browser/devtools/devtools_agent_host_impl.cc
+++ b/content/browser/devtools/devtools_agent_host_impl.cc
@@ -11,8 +11,9 @@
 #include "base/guid.h"
 #include "base/lazy_instance.h"
 #include "content/browser/devtools/devtools_manager.h"
-#include "content/browser/devtools/embedded_worker_devtools_manager.h"
 #include "content/browser/devtools/forwarding_agent_host.h"
+#include "content/browser/devtools/service_worker_devtools_manager.h"
+#include "content/browser/devtools/shared_worker_devtools_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_manager_delegate.h"
 
@@ -30,8 +31,9 @@ base::LazyInstance<AgentStateCallbacks>::Leaky g_callbacks =
 
 // static
 DevToolsAgentHost::List DevToolsAgentHost::GetOrCreateAll() {
-  List result = EmbeddedWorkerDevToolsManager::GetInstance()
-      ->GetOrCreateAllAgentHosts();
+  List result;
+  SharedWorkerDevToolsManager::GetInstance()->AddAllAgentHosts(&result);
+  ServiceWorkerDevToolsManager::GetInstance()->AddAllAgentHosts(&result);
   std::vector<WebContents*> wc_list =
       DevToolsAgentHostImpl::GetInspectableWebContents();
   for (std::vector<WebContents*>::iterator it = wc_list.begin();
diff --git a/content/browser/devtools/devtools_manager_unittest.cc b/content/browser/devtools/devtools_manager_unittest.cc
index 9eb47d7..6495c69 100644
--- a/content/browser/devtools/devtools_manager_unittest.cc
+++ b/content/browser/devtools/devtools_manager_unittest.cc
@@ -6,8 +6,8 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "content/browser/devtools/devtools_manager.h"
-#include "content/browser/devtools/embedded_worker_devtools_manager.h"
 #include "content/browser/devtools/render_view_devtools_agent_host.h"
+#include "content/browser/devtools/shared_worker_devtools_manager.h"
 #include "content/browser/shared_worker/shared_worker_instance.h"
 #include "content/browser/shared_worker/worker_storage_partition.h"
 #include "content/common/view_messages.h"
@@ -429,7 +429,7 @@ TEST_F(DevToolsManagerTest, TestObserver) {
       blink::WebContentSecurityPolicyTypeReport,
       browser_context()->GetResourceContext(),
       partition_id);
-  EmbeddedWorkerDevToolsManager::GetInstance()->SharedWorkerCreated(
+  SharedWorkerDevToolsManager::GetInstance()->WorkerCreated(
       1, 1, shared_worker);
   contents()->NavigateAndCommit(url2);
 
@@ -441,7 +441,7 @@ TEST_F(DevToolsManagerTest, TestObserver) {
             observer->hosts()[1]->GetType());
   EXPECT_EQ(shared_worker_url.spec(), observer->hosts()[1]->GetURL().spec());
 
-  EmbeddedWorkerDevToolsManager::GetInstance()->WorkerDestroyed(1, 1);
+  SharedWorkerDevToolsManager::GetInstance()->WorkerDestroyed(1, 1);
   scheduler.Run();
   EXPECT_EQ(4, observer->updates_count());
   ASSERT_EQ(1u, observer->hosts().size());
diff --git a/content/browser/devtools/embedded_worker_devtools_manager.cc b/content/browser/devtools/embedded_worker_devtools_manager.cc
deleted file mode 100644
index f51cd2b..0000000
--- a/content/browser/devtools/embedded_worker_devtools_manager.cc
+++ /dev/null
@@ -1,213 +0,0 @@
-// Copyright 2014 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/embedded_worker_devtools_manager.h"
-
-#include "content/browser/devtools/devtools_manager.h"
-#include "content/browser/devtools/ipc_devtools_agent_host.h"
-#include "content/browser/devtools/service_worker_devtools_agent_host.h"
-#include "content/browser/devtools/shared_worker_devtools_agent_host.h"
-#include "content/browser/shared_worker/shared_worker_instance.h"
-#include "content/common/devtools_messages.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/render_process_host.h"
-#include "content/public/browser/worker_service.h"
-#include "ipc/ipc_listener.h"
-
-namespace content {
-
-// Called on the UI thread.
-// static
-scoped_refptr<DevToolsAgentHost> DevToolsAgentHost::GetForWorker(
-    int worker_process_id,
-    int worker_route_id) {
-  return EmbeddedWorkerDevToolsManager::GetInstance()
-      ->GetDevToolsAgentHostForWorker(worker_process_id, worker_route_id);
-}
-
-EmbeddedWorkerDevToolsManager::ServiceWorkerIdentifier::ServiceWorkerIdentifier(
-    const ServiceWorkerContextCore* context,
-    base::WeakPtr<ServiceWorkerContextCore> context_weak,
-    int64 version_id,
-    const GURL& url)
-    : context_(context),
-      context_weak_(context_weak),
-      version_id_(version_id),
-      url_(url) {
-}
-
-EmbeddedWorkerDevToolsManager::ServiceWorkerIdentifier::ServiceWorkerIdentifier(
-    const ServiceWorkerIdentifier& other)
-    : context_(other.context_),
-      context_weak_(other.context_weak_),
-      version_id_(other.version_id_),
-      url_(other.url_) {
-}
-
-EmbeddedWorkerDevToolsManager::
-ServiceWorkerIdentifier::~ServiceWorkerIdentifier() {
-}
-
-bool EmbeddedWorkerDevToolsManager::ServiceWorkerIdentifier::Matches(
-    const ServiceWorkerIdentifier& other) const {
-  return context_ == other.context_ && version_id_ == other.version_id_;
-}
-
-const ServiceWorkerContextCore*
-EmbeddedWorkerDevToolsManager::ServiceWorkerIdentifier::context() const {
-  return context_;
-}
-
-base::WeakPtr<ServiceWorkerContextCore>
-EmbeddedWorkerDevToolsManager::ServiceWorkerIdentifier::context_weak() const {
-  return context_weak_;
-}
-
-int64
-EmbeddedWorkerDevToolsManager::ServiceWorkerIdentifier::version_id() const {
-  return version_id_;
-}
-
-GURL EmbeddedWorkerDevToolsManager::ServiceWorkerIdentifier::url() const {
-  return url_;
-}
-
-// static
-EmbeddedWorkerDevToolsManager* EmbeddedWorkerDevToolsManager::GetInstance() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return Singleton<EmbeddedWorkerDevToolsManager>::get();
-}
-
-DevToolsAgentHostImpl*
-EmbeddedWorkerDevToolsManager::GetDevToolsAgentHostForWorker(
-    int worker_process_id,
-    int worker_route_id) {
-  AgentHostMap::iterator it = workers_.find(
-      WorkerId(worker_process_id, worker_route_id));
-  return it == workers_.end() ? NULL : it->second;
-}
-
-EmbeddedWorkerDevToolsManager::EmbeddedWorkerDevToolsManager()
-    : debug_service_worker_on_start_(false) {
-}
-
-EmbeddedWorkerDevToolsManager::~EmbeddedWorkerDevToolsManager() {
-}
-
-bool EmbeddedWorkerDevToolsManager::SharedWorkerCreated(
-    int worker_process_id,
-    int worker_route_id,
-    const SharedWorkerInstance& instance) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  const WorkerId id(worker_process_id, worker_route_id);
-  AgentHostMap::iterator it = FindExistingSharedWorkerAgentHost(instance);
-  if (it == workers_.end()) {
-    workers_[id] = new SharedWorkerDevToolsAgentHost(id, instance);
-    DevToolsManager::GetInstance()->AgentHostChanged(workers_[id]);
-    return false;
-  }
-  WorkerRestarted(id, it);
-  return true;
-}
-
-bool EmbeddedWorkerDevToolsManager::ServiceWorkerCreated(
-    int worker_process_id,
-    int worker_route_id,
-    const ServiceWorkerIdentifier& service_worker_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  const WorkerId id(worker_process_id, worker_route_id);
-  AgentHostMap::iterator it =
-      FindExistingServiceWorkerAgentHost(service_worker_id);
-  if (it == workers_.end()) {
-    workers_[id] = new ServiceWorkerDevToolsAgentHost(
-        id, service_worker_id, debug_service_worker_on_start_);
-    DevToolsManager::GetInstance()->AgentHostChanged(workers_[id]);
-    return debug_service_worker_on_start_;
-  }
-  WorkerRestarted(id, it);
-  return true;
-}
-
-void EmbeddedWorkerDevToolsManager::WorkerDestroyed(int worker_process_id,
-                                                    int worker_route_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  const WorkerId id(worker_process_id, worker_route_id);
-  AgentHostMap::iterator it = workers_.find(id);
-  DCHECK(it != workers_.end());
-  scoped_refptr<EmbeddedWorkerDevToolsAgentHost> agent_host(it->second);
-  agent_host->WorkerDestroyed();
-  DevToolsManager::GetInstance()->AgentHostChanged(agent_host);
-}
-
-void EmbeddedWorkerDevToolsManager::WorkerStopIgnored(int worker_process_id,
-                                                      int worker_route_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  // TODO(pfeldman): Show a console message to tell the user that UA didn't
-  // terminate the worker because devtools is attached.
-}
-
-void EmbeddedWorkerDevToolsManager::WorkerReadyForInspection(
-    int worker_process_id,
-    int worker_route_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  const WorkerId id(worker_process_id, worker_route_id);
-  AgentHostMap::iterator it = workers_.find(id);
-  DCHECK(it != workers_.end());
-  it->second->WorkerReadyForInspection();
-}
-
-void EmbeddedWorkerDevToolsManager::RemoveInspectedWorkerData(WorkerId id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  workers_.erase(id);
-}
-
-EmbeddedWorkerDevToolsManager::AgentHostMap::iterator
-EmbeddedWorkerDevToolsManager::FindExistingSharedWorkerAgentHost(
-    const SharedWorkerInstance& instance) {
-  AgentHostMap::iterator it = workers_.begin();
-  for (; it != workers_.end(); ++it) {
-    if (it->second->Matches(instance))
-      break;
-  }
-  return it;
-}
-
-EmbeddedWorkerDevToolsManager::AgentHostMap::iterator
-EmbeddedWorkerDevToolsManager::FindExistingServiceWorkerAgentHost(
-    const ServiceWorkerIdentifier& service_worker_id) {
-  AgentHostMap::iterator it = workers_.begin();
-  for (; it != workers_.end(); ++it) {
-    if (it->second->Matches(service_worker_id))
-      break;
-  }
-  return it;
-}
-
-DevToolsAgentHost::List
-EmbeddedWorkerDevToolsManager::GetOrCreateAllAgentHosts() {
-  DevToolsAgentHost::List result;
-  EmbeddedWorkerDevToolsManager* instance = GetInstance();
-  for (AgentHostMap::iterator it = instance->workers_.begin();
-      it != instance->workers_.end(); ++it) {
-    if (!it->second->IsTerminated())
-      result.push_back(it->second);
-  }
-  return result;
-}
-
-void EmbeddedWorkerDevToolsManager::WorkerRestarted(
-    const WorkerId& id,
-    const AgentHostMap::iterator& it) {
-  EmbeddedWorkerDevToolsAgentHost* agent_host = it->second;
-  agent_host->WorkerRestarted(id);
-  workers_.erase(it);
-  workers_[id] = agent_host;
-  DevToolsManager::GetInstance()->AgentHostChanged(agent_host);
-}
-
-void EmbeddedWorkerDevToolsManager::ResetForTesting() {
-  workers_.clear();
-}
-
-}  // namespace content
diff --git a/content/browser/devtools/embedded_worker_devtools_manager.h b/content/browser/devtools/embedded_worker_devtools_manager.h
deleted file mode 100644
index 694139f..0000000
--- a/content/browser/devtools/embedded_worker_devtools_manager.h
+++ /dev/null
@@ -1,120 +0,0 @@
-// Copyright 2014 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_DEVTOOLS_EMBEDDED_WORKER_DEVTOOLS_MANAGER_H_
-#define CONTENT_BROWSER_DEVTOOLS_EMBEDDED_WORKER_DEVTOOLS_MANAGER_H_
-
-#include <map>
-
-#include "base/basictypes.h"
-#include "base/gtest_prod_util.h"
-#include "base/memory/scoped_vector.h"
-#include "base/memory/singleton.h"
-#include "base/memory/weak_ptr.h"
-#include "base/strings/string16.h"
-#include "content/browser/shared_worker/shared_worker_instance.h"
-#include "content/common/content_export.h"
-
-namespace content {
-
-class DevToolsAgentHost;
-class DevToolsAgentHostImpl;
-class EmbeddedWorkerDevToolsAgentHost;
-class ServiceWorkerContextCore;
-
-// EmbeddedWorkerDevToolsManager is used instead of WorkerDevToolsManager when
-// "enable-embedded-shared-worker" flag is set.
-// This class lives on UI thread.
-class CONTENT_EXPORT EmbeddedWorkerDevToolsManager {
- public:
-  typedef std::pair<int, int> WorkerId;
-
-  class ServiceWorkerIdentifier {
-   public:
-    ServiceWorkerIdentifier(
-        const ServiceWorkerContextCore* context,
-        base::WeakPtr<ServiceWorkerContextCore> context_weak,
-        int64 version_id,
-        const GURL& url);
-    ServiceWorkerIdentifier(const ServiceWorkerIdentifier& other);
-    ~ServiceWorkerIdentifier();
-
-    bool Matches(const ServiceWorkerIdentifier& other) const;
-
-    const ServiceWorkerContextCore* context() const;
-    base::WeakPtr<ServiceWorkerContextCore> context_weak() const;
-    int64 version_id() const;
-    GURL url() const;
-
-   private:
-    const ServiceWorkerContextCore* const context_;
-    const base::WeakPtr<ServiceWorkerContextCore> context_weak_;
-    const int64 version_id_;
-    const GURL url_;
-  };
-
-  // Returns the EmbeddedWorkerDevToolsManager singleton.
-  static EmbeddedWorkerDevToolsManager* GetInstance();
-
-  DevToolsAgentHostImpl* GetDevToolsAgentHostForWorker(int worker_process_id,
-                                                   int worker_route_id);
-
-  std::vector<scoped_refptr<DevToolsAgentHost> > GetOrCreateAllAgentHosts();
-
-  // Returns true when the worker must be paused on start because a DevTool
-  // window for the same former SharedWorkerInstance is still opened.
-  bool SharedWorkerCreated(int worker_process_id,
-                           int worker_route_id,
-                           const SharedWorkerInstance& instance);
-  // Returns true when the worker must be paused on start because a DevTool
-  // window for the same former ServiceWorkerIdentifier is still opened or
-  // debug-on-start is enabled in chrome://serviceworker-internals.
-  bool ServiceWorkerCreated(int worker_process_id,
-                            int worker_route_id,
-                            const ServiceWorkerIdentifier& service_worker_id);
-  void WorkerReadyForInspection(int worker_process_id, int worker_route_id);
-  void WorkerDestroyed(int worker_process_id, int worker_route_id);
-  void WorkerStopIgnored(int worker_process_id, int worker_route_id);
-
-  void set_debug_service_worker_on_start(bool debug_on_start) {
-    debug_service_worker_on_start_ = debug_on_start;
-  }
-  bool debug_service_worker_on_start() const {
-    return debug_service_worker_on_start_;
-  }
-
- private:
-  friend struct DefaultSingletonTraits<EmbeddedWorkerDevToolsManager>;
-  friend class EmbeddedWorkerDevToolsAgentHost;
-  friend class EmbeddedWorkerDevToolsManagerTest;
-  FRIEND_TEST_ALL_PREFIXES(EmbeddedWorkerDevToolsManagerTest, BasicTest);
-  FRIEND_TEST_ALL_PREFIXES(EmbeddedWorkerDevToolsManagerTest, AttachTest);
-
-  typedef std::map<WorkerId, EmbeddedWorkerDevToolsAgentHost*> AgentHostMap;
-
-  EmbeddedWorkerDevToolsManager();
-  virtual ~EmbeddedWorkerDevToolsManager();
-
-  void RemoveInspectedWorkerData(WorkerId id);
-
-  AgentHostMap::iterator FindExistingSharedWorkerAgentHost(
-      const SharedWorkerInstance& instance);
-  AgentHostMap::iterator FindExistingServiceWorkerAgentHost(
-      const ServiceWorkerIdentifier& service_worker_id);
-
-  void WorkerRestarted(const WorkerId& id, const AgentHostMap::iterator& it);
-
-  // Resets to its initial state as if newly created.
-  void ResetForTesting();
-
-  AgentHostMap workers_;
-
-  bool debug_service_worker_on_start_;
-
-  DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerDevToolsManager);
-};
-
-}  // namespace content
-
-#endif  // CONTENT_BROWSER_DEVTOOLS_EMBEDDED_WORKER_DEVTOOLS_MANAGER_H_
diff --git a/content/browser/devtools/service_worker_devtools_agent_host.cc b/content/browser/devtools/service_worker_devtools_agent_host.cc
index 26ed56c..777b438 100644
--- a/content/browser/devtools/service_worker_devtools_agent_host.cc
+++ b/content/browser/devtools/service_worker_devtools_agent_host.cc
@@ -5,6 +5,7 @@
 #include "content/browser/devtools/service_worker_devtools_agent_host.h"
 
 #include "base/strings/stringprintf.h"
+#include "content/browser/devtools/service_worker_devtools_manager.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/public/browser/browser_thread.h"
@@ -41,7 +42,7 @@ ServiceWorkerDevToolsAgentHost::ServiceWorkerDevToolsAgentHost(
     WorkerId worker_id,
     const ServiceWorkerIdentifier& service_worker,
     bool debug_service_worker_on_start)
-    : EmbeddedWorkerDevToolsAgentHost(worker_id),
+    : WorkerDevToolsAgentHost(worker_id),
       service_worker_(new ServiceWorkerIdentifier(service_worker)) {
   if (debug_service_worker_on_start)
     set_state(WORKER_PAUSED_FOR_DEBUG_ON_START);
@@ -76,7 +77,7 @@ bool ServiceWorkerDevToolsAgentHost::Close() {
 }
 
 void ServiceWorkerDevToolsAgentHost::OnClientAttached() {
-  EmbeddedWorkerDevToolsAgentHost::OnClientAttached();
+  WorkerDevToolsAgentHost::OnClientAttached();
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
       base::Bind(&SetDevToolsAttachedOnIO,
                   service_worker_->context_weak(),
@@ -85,7 +86,7 @@ void ServiceWorkerDevToolsAgentHost::OnClientAttached() {
 }
 
 void ServiceWorkerDevToolsAgentHost::OnClientDetached() {
-  EmbeddedWorkerDevToolsAgentHost::OnClientDetached();
+  WorkerDevToolsAgentHost::OnClientDetached();
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
       base::Bind(&SetDevToolsAttachedOnIO,
                   service_worker_->context_weak(),
@@ -99,6 +100,8 @@ bool ServiceWorkerDevToolsAgentHost::Matches(
 }
 
 ServiceWorkerDevToolsAgentHost::~ServiceWorkerDevToolsAgentHost() {
+  ServiceWorkerDevToolsManager::GetInstance()->RemoveInspectedWorkerData(
+      worker_id());
 }
 
 }  // namespace content
diff --git a/content/browser/devtools/service_worker_devtools_agent_host.h b/content/browser/devtools/service_worker_devtools_agent_host.h
index b11cb4f..5c78d8a 100644
--- a/content/browser/devtools/service_worker_devtools_agent_host.h
+++ b/content/browser/devtools/service_worker_devtools_agent_host.h
@@ -5,12 +5,16 @@
 #ifndef CONTENT_BROWSER_DEVTOOLS_SERVICE_WORKER_DEVTOOLS_AGENT_HOST_H_
 #define CONTENT_BROWSER_DEVTOOLS_SERVICE_WORKER_DEVTOOLS_AGENT_HOST_H_
 
-#include "content/browser/devtools/embedded_worker_devtools_agent_host.h"
+#include "content/browser/devtools/service_worker_devtools_manager.h"
+#include "content/browser/devtools/worker_devtools_agent_host.h"
 
 namespace content {
 
-class ServiceWorkerDevToolsAgentHost : public EmbeddedWorkerDevToolsAgentHost {
+class ServiceWorkerDevToolsAgentHost : public WorkerDevToolsAgentHost {
  public:
+  typedef ServiceWorkerDevToolsManager::ServiceWorkerIdentifier
+      ServiceWorkerIdentifier;
+
   ServiceWorkerDevToolsAgentHost(WorkerId worker_id,
                                  const ServiceWorkerIdentifier& service_worker,
                                  bool debug_service_worker_on_start);
@@ -26,8 +30,7 @@ class ServiceWorkerDevToolsAgentHost : public EmbeddedWorkerDevToolsAgentHost {
   void OnClientAttached() override;
   void OnClientDetached() override;
 
-  // EmbeddedWorkerDevToolsAgentHost override.
-  bool Matches(const ServiceWorkerIdentifier& other) override;
+  bool Matches(const ServiceWorkerIdentifier& other);
 
  private:
   ~ServiceWorkerDevToolsAgentHost() override;
diff --git a/content/browser/devtools/service_worker_devtools_manager.cc b/content/browser/devtools/service_worker_devtools_manager.cc
new file mode 100644
index 0000000..18b3eb56f
--- /dev/null
+++ b/content/browser/devtools/service_worker_devtools_manager.cc
@@ -0,0 +1,97 @@
+// Copyright 2014 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/service_worker_devtools_manager.h"
+
+#include "content/browser/devtools/devtools_manager.h"
+#include "content/browser/devtools/ipc_devtools_agent_host.h"
+#include "content/browser/devtools/service_worker_devtools_agent_host.h"
+#include "content/browser/devtools/shared_worker_devtools_agent_host.h"
+#include "content/browser/shared_worker/shared_worker_instance.h"
+#include "content/common/devtools_messages.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/worker_service.h"
+#include "ipc/ipc_listener.h"
+
+namespace content {
+
+ServiceWorkerDevToolsManager::ServiceWorkerIdentifier::ServiceWorkerIdentifier(
+    const ServiceWorkerContextCore* context,
+    base::WeakPtr<ServiceWorkerContextCore> context_weak,
+    int64 version_id,
+    const GURL& url)
+    : context_(context),
+      context_weak_(context_weak),
+      version_id_(version_id),
+      url_(url) {
+}
+
+ServiceWorkerDevToolsManager::ServiceWorkerIdentifier::ServiceWorkerIdentifier(
+    const ServiceWorkerIdentifier& other)
+    : context_(other.context_),
+      context_weak_(other.context_weak_),
+      version_id_(other.version_id_),
+      url_(other.url_) {
+}
+
+ServiceWorkerDevToolsManager::
+ServiceWorkerIdentifier::~ServiceWorkerIdentifier() {
+}
+
+bool ServiceWorkerDevToolsManager::ServiceWorkerIdentifier::Matches(
+    const ServiceWorkerIdentifier& other) const {
+  return context_ == other.context_ && version_id_ == other.version_id_;
+}
+
+// static
+ServiceWorkerDevToolsManager* ServiceWorkerDevToolsManager::GetInstance() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  return Singleton<ServiceWorkerDevToolsManager>::get();
+}
+
+bool ServiceWorkerDevToolsManager::WorkerCreated(
+    int worker_process_id,
+    int worker_route_id,
+    const ServiceWorkerIdentifier& service_worker_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  const WorkerId id(worker_process_id, worker_route_id);
+  AgentHostMap::iterator it = FindExistingWorkerAgentHost(service_worker_id);
+  if (it == workers().end()) {
+    workers()[id] = new ServiceWorkerDevToolsAgentHost(
+        id, service_worker_id, debug_service_worker_on_start_);
+    DevToolsManager::GetInstance()->AgentHostChanged(workers()[id]);
+    return debug_service_worker_on_start_;
+  }
+  WorkerRestarted(id, it);
+  return true;
+}
+
+void ServiceWorkerDevToolsManager::WorkerStopIgnored(int worker_process_id,
+                                                      int worker_route_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  // TODO(pfeldman): Show a console message to tell the user that UA didn't
+  // terminate the worker because devtools is attached.
+}
+
+ServiceWorkerDevToolsManager::ServiceWorkerDevToolsManager()
+    : debug_service_worker_on_start_(false) {
+}
+
+ServiceWorkerDevToolsManager::~ServiceWorkerDevToolsManager() {
+}
+
+ServiceWorkerDevToolsManager::AgentHostMap::iterator
+ServiceWorkerDevToolsManager::FindExistingWorkerAgentHost(
+    const ServiceWorkerIdentifier& service_worker_id) {
+  AgentHostMap::iterator it = workers().begin();
+  for (; it != workers().end(); ++it) {
+    if (static_cast<ServiceWorkerDevToolsAgentHost*>(
+            it->second)->Matches(service_worker_id))
+      break;
+  }
+  return it;
+}
+
+}  // namespace content
diff --git a/content/browser/devtools/service_worker_devtools_manager.h b/content/browser/devtools/service_worker_devtools_manager.h
new file mode 100644
index 0000000..3024e59
--- /dev/null
+++ b/content/browser/devtools/service_worker_devtools_manager.h
@@ -0,0 +1,87 @@
+// Copyright 2014 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_DEVTOOLS_SERVICE_WORKER_DEVTOOLS_MANAGER_H_
+#define CONTENT_BROWSER_DEVTOOLS_SERVICE_WORKER_DEVTOOLS_MANAGER_H_
+
+#include <map>
+
+#include "base/basictypes.h"
+#include "base/memory/singleton.h"
+#include "base/memory/weak_ptr.h"
+#include "content/browser/devtools/worker_devtools_manager.h"
+#include "content/browser/shared_worker/shared_worker_instance.h"
+
+namespace content {
+
+class ServiceWorkerDevToolsAgentHost;
+class ServiceWorkerContextCore;
+
+// Manages WorkerDevToolsAgentHost's for Service Workers.
+// This class lives on UI thread.
+class CONTENT_EXPORT ServiceWorkerDevToolsManager
+    : public WorkerDevToolsManager {
+ public:
+  class ServiceWorkerIdentifier {
+   public:
+    ServiceWorkerIdentifier(
+        const ServiceWorkerContextCore* context,
+        base::WeakPtr<ServiceWorkerContextCore> context_weak,
+        int64 version_id,
+        const GURL& url);
+    ServiceWorkerIdentifier(const ServiceWorkerIdentifier& other);
+    ~ServiceWorkerIdentifier();
+
+    bool Matches(const ServiceWorkerIdentifier& other) const;
+
+    const ServiceWorkerContextCore* context() const { return context_; }
+    base::WeakPtr<ServiceWorkerContextCore> context_weak() const {
+      return context_weak_;
+    }
+    int64 version_id() const { return version_id_; }
+    GURL url() const { return url_; }
+
+   private:
+    const ServiceWorkerContextCore* const context_;
+    const base::WeakPtr<ServiceWorkerContextCore> context_weak_;
+    const int64 version_id_;
+    const GURL url_;
+  };
+
+  // Returns the ServiceWorkerDevToolsManager singleton.
+  static ServiceWorkerDevToolsManager* GetInstance();
+
+  // Returns true when the worker must be paused on start because a DevTool
+  // window for the same former ServiceWorkerIdentifier is still opened or
+  // debug-on-start is enabled in chrome://serviceworker-internals.
+  bool WorkerCreated(int worker_process_id,
+                     int worker_route_id,
+                     const ServiceWorkerIdentifier& service_worker_id);
+  void WorkerStopIgnored(int worker_process_id, int worker_route_id);
+
+  void set_debug_service_worker_on_start(bool debug_on_start) {
+    debug_service_worker_on_start_ = debug_on_start;
+  }
+  bool debug_service_worker_on_start() const {
+    return debug_service_worker_on_start_;
+  }
+
+ private:
+  friend struct DefaultSingletonTraits<ServiceWorkerDevToolsManager>;
+  friend class ServiceWorkerDevToolsAgentHost;
+
+  ServiceWorkerDevToolsManager();
+  ~ServiceWorkerDevToolsManager() override;
+
+  AgentHostMap::iterator FindExistingWorkerAgentHost(
+      const ServiceWorkerIdentifier& service_worker_id);
+
+  bool debug_service_worker_on_start_;
+
+  DISALLOW_COPY_AND_ASSIGN(ServiceWorkerDevToolsManager);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_SERVICE_WORKER_DEVTOOLS_MANAGER_H_
diff --git a/content/browser/devtools/shared_worker_devtools_agent_host.cc b/content/browser/devtools/shared_worker_devtools_agent_host.cc
index 61133a5..b823ea7 100644
--- a/content/browser/devtools/shared_worker_devtools_agent_host.cc
+++ b/content/browser/devtools/shared_worker_devtools_agent_host.cc
@@ -5,16 +5,17 @@
 #include "content/browser/devtools/shared_worker_devtools_agent_host.h"
 
 #include "base/strings/utf_string_conversions.h"
+#include "content/browser/devtools/shared_worker_devtools_manager.h"
+#include "content/browser/shared_worker/shared_worker_instance.h"
 #include "content/browser/shared_worker/shared_worker_service_impl.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/render_process_host.h"
 
 namespace content {
 
 namespace {
 
 void TerminateSharedWorkerOnIO(
-    EmbeddedWorkerDevToolsAgentHost::WorkerId worker_id) {
+    WorkerDevToolsAgentHost::WorkerId worker_id) {
   SharedWorkerServiceImpl::GetInstance()->TerminateWorker(
       worker_id.first, worker_id.second);
 }
@@ -24,7 +25,7 @@ void TerminateSharedWorkerOnIO(
 SharedWorkerDevToolsAgentHost::SharedWorkerDevToolsAgentHost(
     WorkerId worker_id,
     const SharedWorkerInstance& shared_worker)
-    : EmbeddedWorkerDevToolsAgentHost(worker_id),
+    : WorkerDevToolsAgentHost(worker_id),
       shared_worker_(new SharedWorkerInstance(shared_worker)) {
 }
 
@@ -56,6 +57,8 @@ bool SharedWorkerDevToolsAgentHost::Matches(
 }
 
 SharedWorkerDevToolsAgentHost::~SharedWorkerDevToolsAgentHost() {
+  SharedWorkerDevToolsManager::GetInstance()->RemoveInspectedWorkerData(
+      worker_id());
 }
 
 }  // namespace content
diff --git a/content/browser/devtools/shared_worker_devtools_agent_host.h b/content/browser/devtools/shared_worker_devtools_agent_host.h
index aadb209..5c9d0ab 100644
--- a/content/browser/devtools/shared_worker_devtools_agent_host.h
+++ b/content/browser/devtools/shared_worker_devtools_agent_host.h
@@ -5,13 +5,13 @@
 #ifndef CONTENT_BROWSER_DEVTOOLS_SHARED_WORKER_DEVTOOLS_AGENT_HOST_H_
 #define CONTENT_BROWSER_DEVTOOLS_SHARED_WORKER_DEVTOOLS_AGENT_HOST_H_
 
-#include "content/browser/devtools/embedded_worker_devtools_agent_host.h"
+#include "content/browser/devtools/worker_devtools_agent_host.h"
 
 namespace content {
 
 class SharedWorkerInstance;
 
-class SharedWorkerDevToolsAgentHost : public EmbeddedWorkerDevToolsAgentHost {
+class SharedWorkerDevToolsAgentHost : public WorkerDevToolsAgentHost {
  public:
   SharedWorkerDevToolsAgentHost(WorkerId worker_id,
                                 const SharedWorkerInstance& shared_worker);
@@ -23,10 +23,11 @@ class SharedWorkerDevToolsAgentHost : public EmbeddedWorkerDevToolsAgentHost {
   bool Activate() override;
   bool Close() override;
 
-  // EmbeddedWorkerDevToolsAgentHost override.
-  bool Matches(const SharedWorkerInstance& other) override;
+  bool Matches(const SharedWorkerInstance& other);
 
  private:
+  friend class SharedWorkerDevToolsManagerTest;
+
   ~SharedWorkerDevToolsAgentHost() override;
   scoped_ptr<SharedWorkerInstance> shared_worker_;
 
diff --git a/content/browser/devtools/shared_worker_devtools_manager.cc b/content/browser/devtools/shared_worker_devtools_manager.cc
new file mode 100644
index 0000000..cd4d196
--- /dev/null
+++ b/content/browser/devtools/shared_worker_devtools_manager.cc
@@ -0,0 +1,58 @@
+// Copyright 2014 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/shared_worker_devtools_manager.h"
+
+#include "content/browser/devtools/devtools_manager.h"
+#include "content/browser/devtools/shared_worker_devtools_agent_host.h"
+#include "content/browser/shared_worker/shared_worker_instance.h"
+#include "content/public/browser/browser_thread.h"
+
+namespace content {
+
+// static
+SharedWorkerDevToolsManager* SharedWorkerDevToolsManager::GetInstance() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  return Singleton<SharedWorkerDevToolsManager>::get();
+}
+
+bool SharedWorkerDevToolsManager::WorkerCreated(
+    int worker_process_id,
+    int worker_route_id,
+    const SharedWorkerInstance& instance) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  const WorkerId id(worker_process_id, worker_route_id);
+  AgentHostMap::iterator it = FindExistingWorkerAgentHost(instance);
+  if (it == workers().end()) {
+    workers()[id] = new SharedWorkerDevToolsAgentHost(id, instance);
+    DevToolsManager::GetInstance()->AgentHostChanged(workers()[id]);
+    return false;
+  }
+  WorkerRestarted(id, it);
+  return true;
+}
+
+SharedWorkerDevToolsManager::AgentHostMap::iterator
+SharedWorkerDevToolsManager::FindExistingWorkerAgentHost(
+    const SharedWorkerInstance& instance) {
+  AgentHostMap::iterator it = workers().begin();
+  for (; it != workers().end(); ++it) {
+    if (static_cast<SharedWorkerDevToolsAgentHost*>(
+            it->second)->Matches(instance))
+      break;
+  }
+  return it;
+}
+
+SharedWorkerDevToolsManager::SharedWorkerDevToolsManager() {
+}
+
+SharedWorkerDevToolsManager::~SharedWorkerDevToolsManager() {
+}
+
+void SharedWorkerDevToolsManager::ResetForTesting() {
+  workers().clear();
+}
+
+}  // namespace content
diff --git a/content/browser/devtools/shared_worker_devtools_manager.h b/content/browser/devtools/shared_worker_devtools_manager.h
new file mode 100644
index 0000000..6cad78f
--- /dev/null
+++ b/content/browser/devtools/shared_worker_devtools_manager.h
@@ -0,0 +1,53 @@
+// Copyright 2014 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_DEVTOOLS_SHARED_WORKER_DEVTOOLS_MANAGER_H_
+#define CONTENT_BROWSER_DEVTOOLS_SHARED_WORKER_DEVTOOLS_MANAGER_H_
+
+#include "base/basictypes.h"
+#include "base/gtest_prod_util.h"
+#include "base/memory/singleton.h"
+#include "content/browser/devtools/worker_devtools_manager.h"
+
+namespace content {
+
+class SharedWorkerDevToolsAgentHost;
+class SharedWorkerInstance;
+
+// Manages WorkerDevToolsAgentHost's for Shared Workers.
+// This class lives on UI thread.
+class CONTENT_EXPORT SharedWorkerDevToolsManager
+    : public WorkerDevToolsManager {
+ public:
+  // Returns the SharedWorkerDevToolsManager singleton.
+  static SharedWorkerDevToolsManager* GetInstance();
+
+  // Returns true when the worker must be paused on start because a DevTool
+  // window for the same former SharedWorkerInstance is still opened.
+  bool WorkerCreated(int worker_process_id,
+                     int worker_route_id,
+                     const SharedWorkerInstance& instance);
+
+ private:
+  friend struct DefaultSingletonTraits<SharedWorkerDevToolsManager>;
+  friend class SharedWorkerDevToolsAgentHost;
+  friend class SharedWorkerDevToolsManagerTest;
+  FRIEND_TEST_ALL_PREFIXES(SharedWorkerDevToolsManagerTest, BasicTest);
+  FRIEND_TEST_ALL_PREFIXES(SharedWorkerDevToolsManagerTest, AttachTest);
+
+  SharedWorkerDevToolsManager();
+  ~SharedWorkerDevToolsManager() override;
+
+  AgentHostMap::iterator FindExistingWorkerAgentHost(
+      const SharedWorkerInstance& instance);
+
+  // Resets to its initial state as if newly created.
+  void ResetForTesting();
+
+  DISALLOW_COPY_AND_ASSIGN(SharedWorkerDevToolsManager);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_SHARED_WORKER_DEVTOOLS_MANAGER_H_
diff --git a/content/browser/devtools/embedded_worker_devtools_manager_unittest.cc b/content/browser/devtools/shared_worker_devtools_manager_unittest.cc
index 35a0b30..b7d85e1 100644
--- a/content/browser/devtools/embedded_worker_devtools_manager_unittest.cc
+++ b/content/browser/devtools/shared_worker_devtools_manager_unittest.cc
@@ -2,14 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/devtools/embedded_worker_devtools_manager.h"
+#include "content/browser/devtools/shared_worker_devtools_manager.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/devtools/devtools_agent_host_impl.h"
-#include "content/browser/devtools/embedded_worker_devtools_agent_host.h"
+#include "content/browser/devtools/shared_worker_devtools_agent_host.h"
 #include "content/browser/shared_worker/shared_worker_instance.h"
 #include "content/browser/shared_worker/worker_storage_partition.h"
 #include "content/public/test/test_browser_context.h"
@@ -37,13 +37,13 @@ class TestDevToolsClientHost : public DevToolsAgentHostClient {
   scoped_refptr<DevToolsAgentHost> agent_host_;
   DISALLOW_COPY_AND_ASSIGN(TestDevToolsClientHost);
 };
-}
+}  // namespace
 
-class EmbeddedWorkerDevToolsManagerTest : public testing::Test {
+class SharedWorkerDevToolsManagerTest : public testing::Test {
  public:
-  typedef EmbeddedWorkerDevToolsAgentHost::WorkerState WorkerState;
+  typedef SharedWorkerDevToolsAgentHost::WorkerState WorkerState;
 
-  EmbeddedWorkerDevToolsManagerTest()
+  SharedWorkerDevToolsManagerTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         browser_context_(new TestBrowserContext()),
         partition_(
@@ -59,25 +59,25 @@ class EmbeddedWorkerDevToolsManagerTest : public testing::Test {
 
  protected:
   void SetUp() override {
-    manager_ = EmbeddedWorkerDevToolsManager::GetInstance();
+    manager_ = SharedWorkerDevToolsManager::GetInstance();
   }
   void TearDown() override {
-    EmbeddedWorkerDevToolsManager::GetInstance()->ResetForTesting();
+    SharedWorkerDevToolsManager::GetInstance()->ResetForTesting();
   }
 
   void CheckWorkerState(int worker_process_id,
                         int worker_route_id,
                         WorkerState state) {
-    const EmbeddedWorkerDevToolsManager::WorkerId id(worker_process_id,
+    const SharedWorkerDevToolsManager::WorkerId id(worker_process_id,
                                                      worker_route_id);
-    EmbeddedWorkerDevToolsManager::AgentHostMap::iterator it =
-        manager_->workers_.find(id);
+    SharedWorkerDevToolsManager::AgentHostMap::iterator it =
+        manager_->workers().find(id);
     EXPECT_TRUE(manager_->workers_.end() != it);
     EXPECT_EQ(state, it->second->state_);
   }
 
   void CheckWorkerNotExist(int worker_process_id, int worker_route_id) {
-    const EmbeddedWorkerDevToolsManager::WorkerId id(worker_process_id,
+    const SharedWorkerDevToolsManager::WorkerId id(worker_process_id,
                                                      worker_route_id);
     EXPECT_TRUE(manager_->workers_.end() == manager_->workers_.find(id));
   }
@@ -91,10 +91,10 @@ class EmbeddedWorkerDevToolsManagerTest : public testing::Test {
   scoped_ptr<TestBrowserContext> browser_context_;
   scoped_ptr<WorkerStoragePartition> partition_;
   const WorkerStoragePartitionId partition_id_;
-  EmbeddedWorkerDevToolsManager* manager_;
+  SharedWorkerDevToolsManager* manager_;
 };
 
-TEST_F(EmbeddedWorkerDevToolsManagerTest, BasicTest) {
+TEST_F(SharedWorkerDevToolsManagerTest, BasicTest) {
   scoped_refptr<DevToolsAgentHostImpl> agent_host;
 
   SharedWorkerInstance instance1(GURL("http://example.com/w.js"),
@@ -109,7 +109,7 @@ TEST_F(EmbeddedWorkerDevToolsManagerTest, BasicTest) {
 
   // Created -> Started -> Destroyed
   CheckWorkerNotExist(1, 1);
-  manager_->SharedWorkerCreated(1, 1, instance1);
+  manager_->WorkerCreated(1, 1, instance1);
   CheckWorkerState(1, 1, WorkerState::WORKER_UNINSPECTED);
   manager_->WorkerReadyForInspection(1, 1);
   CheckWorkerState(1, 1, WorkerState::WORKER_UNINSPECTED);
@@ -118,7 +118,7 @@ TEST_F(EmbeddedWorkerDevToolsManagerTest, BasicTest) {
 
   // Created -> GetDevToolsAgentHost -> Started -> Destroyed
   CheckWorkerNotExist(1, 2);
-  manager_->SharedWorkerCreated(1, 2, instance1);
+  manager_->WorkerCreated(1, 2, instance1);
   CheckWorkerState(1, 2, WorkerState::WORKER_UNINSPECTED);
   agent_host = manager_->GetDevToolsAgentHostForWorker(1, 2);
   EXPECT_TRUE(agent_host.get());
@@ -133,7 +133,7 @@ TEST_F(EmbeddedWorkerDevToolsManagerTest, BasicTest) {
 
   // Created -> Started -> GetDevToolsAgentHost -> Destroyed
   CheckWorkerNotExist(1, 3);
-  manager_->SharedWorkerCreated(1, 3, instance1);
+  manager_->WorkerCreated(1, 3, instance1);
   CheckWorkerState(1, 3, WorkerState::WORKER_UNINSPECTED);
   manager_->WorkerReadyForInspection(1, 3);
   CheckWorkerState(1, 3, WorkerState::WORKER_UNINSPECTED);
@@ -147,14 +147,14 @@ TEST_F(EmbeddedWorkerDevToolsManagerTest, BasicTest) {
 
   // Created -> Destroyed
   CheckWorkerNotExist(1, 4);
-  manager_->SharedWorkerCreated(1, 4, instance1);
+  manager_->WorkerCreated(1, 4, instance1);
   CheckWorkerState(1, 4, WorkerState::WORKER_UNINSPECTED);
   manager_->WorkerDestroyed(1, 4);
   CheckWorkerNotExist(1, 4);
 
   // Created -> GetDevToolsAgentHost -> Destroyed
   CheckWorkerNotExist(1, 5);
-  manager_->SharedWorkerCreated(1, 5, instance1);
+  manager_->WorkerCreated(1, 5, instance1);
   CheckWorkerState(1, 5, WorkerState::WORKER_UNINSPECTED);
   agent_host = manager_->GetDevToolsAgentHostForWorker(1, 5);
   EXPECT_TRUE(agent_host.get());
@@ -166,7 +166,7 @@ TEST_F(EmbeddedWorkerDevToolsManagerTest, BasicTest) {
 
   // Created -> GetDevToolsAgentHost -> Free agent_host -> Destroyed
   CheckWorkerNotExist(1, 6);
-  manager_->SharedWorkerCreated(1, 6, instance1);
+  manager_->WorkerCreated(1, 6, instance1);
   CheckWorkerState(1, 6, WorkerState::WORKER_UNINSPECTED);
   agent_host = manager_->GetDevToolsAgentHostForWorker(1, 6);
   EXPECT_TRUE(agent_host.get());
@@ -176,7 +176,7 @@ TEST_F(EmbeddedWorkerDevToolsManagerTest, BasicTest) {
   CheckWorkerNotExist(1, 6);
 }
 
-TEST_F(EmbeddedWorkerDevToolsManagerTest, AttachTest) {
+TEST_F(SharedWorkerDevToolsManagerTest, AttachTest) {
   scoped_refptr<DevToolsAgentHostImpl> agent_host1;
   scoped_refptr<DevToolsAgentHostImpl> agent_host2;
 
@@ -196,7 +196,7 @@ TEST_F(EmbeddedWorkerDevToolsManagerTest, AttachTest) {
   // Created -> GetDevToolsAgentHost -> Register -> Started -> Destroyed
   scoped_ptr<TestDevToolsClientHost> client_host1(new TestDevToolsClientHost());
   CheckWorkerNotExist(2, 1);
-  manager_->SharedWorkerCreated(2, 1, instance1);
+  manager_->WorkerCreated(2, 1, instance1);
   CheckWorkerState(2, 1, WorkerState::WORKER_UNINSPECTED);
   agent_host1 = manager_->GetDevToolsAgentHostForWorker(2, 1);
   EXPECT_TRUE(agent_host1.get());
@@ -212,7 +212,7 @@ TEST_F(EmbeddedWorkerDevToolsManagerTest, AttachTest) {
 
   // Created -> Started -> GetDevToolsAgentHost -> Register -> Destroyed
   scoped_ptr<TestDevToolsClientHost> client_host2(new TestDevToolsClientHost());
-  manager_->SharedWorkerCreated(2, 2, instance2);
+  manager_->WorkerCreated(2, 2, instance2);
   CheckWorkerState(2, 2, WorkerState::WORKER_UNINSPECTED);
   manager_->WorkerReadyForInspection(2, 2);
   CheckWorkerState(2, 2, WorkerState::WORKER_UNINSPECTED);
@@ -229,7 +229,7 @@ TEST_F(EmbeddedWorkerDevToolsManagerTest, AttachTest) {
 
   // Re-created -> Started -> ClientHostClosing -> Destroyed
   CheckWorkerState(2, 1, WorkerState::WORKER_TERMINATED);
-  manager_->SharedWorkerCreated(2, 3, instance1);
+  manager_->WorkerCreated(2, 3, instance1);
   CheckWorkerNotExist(2, 1);
   CheckWorkerState(2, 3, WorkerState::WORKER_PAUSED_FOR_REATTACH);
   EXPECT_EQ(agent_host1.get(), manager_->GetDevToolsAgentHostForWorker(2, 3));
@@ -243,7 +243,7 @@ TEST_F(EmbeddedWorkerDevToolsManagerTest, AttachTest) {
 
   // Re-created -> Destroyed
   CheckWorkerState(2, 2, WorkerState::WORKER_TERMINATED);
-  manager_->SharedWorkerCreated(2, 4, instance2);
+  manager_->WorkerCreated(2, 4, instance2);
   CheckWorkerNotExist(2, 2);
   CheckWorkerState(2, 4, WorkerState::WORKER_PAUSED_FOR_REATTACH);
   EXPECT_EQ(agent_host2.get(), manager_->GetDevToolsAgentHostForWorker(2, 4));
@@ -252,7 +252,7 @@ TEST_F(EmbeddedWorkerDevToolsManagerTest, AttachTest) {
   CheckWorkerState(2, 4, WorkerState::WORKER_TERMINATED);
 
   // Re-created -> ClientHostClosing -> Destroyed
-  manager_->SharedWorkerCreated(2, 5, instance2);
+  manager_->WorkerCreated(2, 5, instance2);
   CheckWorkerNotExist(2, 2);
   CheckWorkerState(2, 5, WorkerState::WORKER_PAUSED_FOR_REATTACH);
   EXPECT_EQ(agent_host2.get(), manager_->GetDevToolsAgentHostForWorker(2, 5));
@@ -264,7 +264,7 @@ TEST_F(EmbeddedWorkerDevToolsManagerTest, AttachTest) {
   CheckWorkerCount(0);
 }
 
-TEST_F(EmbeddedWorkerDevToolsManagerTest, ReattachTest) {
+TEST_F(SharedWorkerDevToolsManagerTest, ReattachTest) {
   SharedWorkerInstance instance(GURL("http://example.com/w3.js"),
                                 base::string16(),
                                 base::string16(),
@@ -273,7 +273,7 @@ TEST_F(EmbeddedWorkerDevToolsManagerTest, ReattachTest) {
                                 partition_id_);
   scoped_ptr<TestDevToolsClientHost> client_host(new TestDevToolsClientHost());
   // Created -> GetDevToolsAgentHost -> Register -> Destroyed
-  manager_->SharedWorkerCreated(3, 1, instance);
+  manager_->WorkerCreated(3, 1, instance);
   CheckWorkerState(3, 1, WorkerState::WORKER_UNINSPECTED);
   scoped_refptr<DevToolsAgentHost> agent_host(
       manager_->GetDevToolsAgentHostForWorker(3, 1));
@@ -286,7 +286,7 @@ TEST_F(EmbeddedWorkerDevToolsManagerTest, ReattachTest) {
   // ClientHostClosing -> Re-created -> release agent_host -> Destroyed
   client_host->InspectAgentHost(NULL);
   CheckWorkerState(3, 1, WorkerState::WORKER_TERMINATED);
-  manager_->SharedWorkerCreated(3, 2, instance);
+  manager_->WorkerCreated(3, 2, instance);
   CheckWorkerState(3, 2, WorkerState::WORKER_UNINSPECTED);
   agent_host = NULL;
   CheckWorkerState(3, 2, WorkerState::WORKER_UNINSPECTED);
diff --git a/content/browser/devtools/embedded_worker_devtools_agent_host.cc b/content/browser/devtools/worker_devtools_agent_host.cc
index 27b60fb..ceb9a79 100644
--- a/content/browser/devtools/embedded_worker_devtools_agent_host.cc
+++ b/content/browser/devtools/worker_devtools_agent_host.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/devtools/embedded_worker_devtools_agent_host.h"
+#include "content/browser/devtools/worker_devtools_agent_host.h"
 
 #include "content/browser/devtools/protocol/devtools_protocol_handler.h"
 #include "content/common/devtools_messages.h"
@@ -11,16 +11,16 @@
 
 namespace content {
 
-bool EmbeddedWorkerDevToolsAgentHost::IsWorker() const {
+bool WorkerDevToolsAgentHost::IsWorker() const {
   return true;
 }
 
-BrowserContext* EmbeddedWorkerDevToolsAgentHost::GetBrowserContext() {
+BrowserContext* WorkerDevToolsAgentHost::GetBrowserContext() {
   RenderProcessHost* rph = RenderProcessHost::FromID(worker_id_.first);
   return rph ? rph->GetBrowserContext() : nullptr;
 }
 
-void EmbeddedWorkerDevToolsAgentHost::SendMessageToAgent(
+void WorkerDevToolsAgentHost::SendMessageToAgent(
     IPC::Message* message_raw) {
   scoped_ptr<IPC::Message> message(message_raw);
   if (state_ != WORKER_INSPECTED)
@@ -31,7 +31,7 @@ void EmbeddedWorkerDevToolsAgentHost::SendMessageToAgent(
   }
 }
 
-void EmbeddedWorkerDevToolsAgentHost::Attach() {
+void WorkerDevToolsAgentHost::Attach() {
   if (state_ != WORKER_INSPECTED) {
     state_ = WORKER_INSPECTED;
     AttachToWorker();
@@ -39,11 +39,11 @@ void EmbeddedWorkerDevToolsAgentHost::Attach() {
   IPCDevToolsAgentHost::Attach();
 }
 
-void EmbeddedWorkerDevToolsAgentHost::OnClientAttached() {
+void WorkerDevToolsAgentHost::OnClientAttached() {
   DevToolsAgentHostImpl::NotifyCallbacks(this, true);
 }
 
-void EmbeddedWorkerDevToolsAgentHost::OnClientDetached() {
+void WorkerDevToolsAgentHost::OnClientDetached() {
   if (state_ == WORKER_INSPECTED) {
     state_ = WORKER_UNINSPECTED;
     DetachFromWorker();
@@ -53,11 +53,11 @@ void EmbeddedWorkerDevToolsAgentHost::OnClientDetached() {
   DevToolsAgentHostImpl::NotifyCallbacks(this, false);
 }
 
-bool EmbeddedWorkerDevToolsAgentHost::OnMessageReceived(
+bool WorkerDevToolsAgentHost::OnMessageReceived(
     const IPC::Message& msg) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerDevToolsAgentHost, msg)
+  IPC_BEGIN_MESSAGE_MAP(WorkerDevToolsAgentHost, msg)
   IPC_MESSAGE_HANDLER(DevToolsClientMsg_DispatchOnInspectorFrontend,
                       OnDispatchOnInspectorFrontend)
   IPC_MESSAGE_HANDLER(DevToolsHostMsg_SaveAgentRuntimeState,
@@ -67,7 +67,7 @@ bool EmbeddedWorkerDevToolsAgentHost::OnMessageReceived(
   return handled;
 }
 
-void EmbeddedWorkerDevToolsAgentHost::WorkerReadyForInspection() {
+void WorkerDevToolsAgentHost::WorkerReadyForInspection() {
   if (state_ == WORKER_PAUSED_FOR_DEBUG_ON_START) {
     RenderProcessHost* rph = RenderProcessHost::FromID(worker_id_.first);
     Inspect(rph->GetBrowserContext());
@@ -79,20 +79,20 @@ void EmbeddedWorkerDevToolsAgentHost::WorkerReadyForInspection() {
   }
 }
 
-void EmbeddedWorkerDevToolsAgentHost::WorkerRestarted(WorkerId worker_id) {
+void WorkerDevToolsAgentHost::WorkerRestarted(WorkerId worker_id) {
   DCHECK_EQ(WORKER_TERMINATED, state_);
   state_ = IsAttached() ? WORKER_PAUSED_FOR_REATTACH : WORKER_UNINSPECTED;
   worker_id_ = worker_id;
   WorkerCreated();
 }
 
-void EmbeddedWorkerDevToolsAgentHost::WorkerDestroyed() {
+void WorkerDevToolsAgentHost::WorkerDestroyed() {
   DCHECK_NE(WORKER_TERMINATED, state_);
   if (state_ == WORKER_INSPECTED) {
     DCHECK(IsAttached());
     // Client host is debugging this worker agent host.
     base::Callback<void(const std::string&)> raw_message_callback(
-        base::Bind(&EmbeddedWorkerDevToolsAgentHost::SendMessageToClient,
+        base::Bind(&WorkerDevToolsAgentHost::SendMessageToClient,
                 base::Unretained(this)));
     devtools::worker::Client worker(raw_message_callback);
     worker.DisconnectedFromWorker(
@@ -103,48 +103,36 @@ void EmbeddedWorkerDevToolsAgentHost::WorkerDestroyed() {
   Release();  // Balanced in WorkerCreated().
 }
 
-bool EmbeddedWorkerDevToolsAgentHost::IsTerminated() {
+bool WorkerDevToolsAgentHost::IsTerminated() {
   return state_ == WORKER_TERMINATED;
 }
 
-bool EmbeddedWorkerDevToolsAgentHost::Matches(
-    const SharedWorkerInstance& other) {
-  return false;
-}
-
-bool EmbeddedWorkerDevToolsAgentHost::Matches(
-    const ServiceWorkerIdentifier& other) {
-  return false;
-}
-
-EmbeddedWorkerDevToolsAgentHost::EmbeddedWorkerDevToolsAgentHost(
+WorkerDevToolsAgentHost::WorkerDevToolsAgentHost(
     WorkerId worker_id)
     : state_(WORKER_UNINSPECTED),
       worker_id_(worker_id) {
   WorkerCreated();
 }
 
-EmbeddedWorkerDevToolsAgentHost::~EmbeddedWorkerDevToolsAgentHost() {
+WorkerDevToolsAgentHost::~WorkerDevToolsAgentHost() {
   DCHECK_EQ(WORKER_TERMINATED, state_);
-  EmbeddedWorkerDevToolsManager::GetInstance()->RemoveInspectedWorkerData(
-      worker_id_);
 }
 
-void EmbeddedWorkerDevToolsAgentHost::AttachToWorker() {
+void WorkerDevToolsAgentHost::AttachToWorker() {
   if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first))
     host->AddRoute(worker_id_.second, this);
 }
 
-void EmbeddedWorkerDevToolsAgentHost::DetachFromWorker() {
+void WorkerDevToolsAgentHost::DetachFromWorker() {
   if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first))
     host->RemoveRoute(worker_id_.second);
 }
 
-void EmbeddedWorkerDevToolsAgentHost::WorkerCreated() {
+void WorkerDevToolsAgentHost::WorkerCreated() {
   AddRef();  // Balanced in WorkerDestroyed()
 }
 
-void EmbeddedWorkerDevToolsAgentHost::OnDispatchOnInspectorFrontend(
+void WorkerDevToolsAgentHost::OnDispatchOnInspectorFrontend(
     const std::string& message,
     uint32 total_size) {
   if (!IsAttached())
@@ -153,7 +141,7 @@ void EmbeddedWorkerDevToolsAgentHost::OnDispatchOnInspectorFrontend(
   ProcessChunkedMessageFromAgent(message, total_size);
 }
 
-void EmbeddedWorkerDevToolsAgentHost::OnSaveAgentRuntimeState(
+void WorkerDevToolsAgentHost::OnSaveAgentRuntimeState(
     const std::string& state) {
   saved_agent_state_ = state;
 }
diff --git a/content/browser/devtools/embedded_worker_devtools_agent_host.h b/content/browser/devtools/worker_devtools_agent_host.h
index 45dccdb..9a55c24 100644
--- a/content/browser/devtools/embedded_worker_devtools_agent_host.h
+++ b/content/browser/devtools/worker_devtools_agent_host.h
@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_DEVTOOLS_EMBEDDED_WORKER_DEVTOOLS_AGENT_HOST_H_
-#define CONTENT_BROWSER_DEVTOOLS_EMBEDDED_WORKER_DEVTOOLS_AGENT_HOST_H_
+#ifndef CONTENT_BROWSER_DEVTOOLS_WORKER_DEVTOOLS_AGENT_HOST_H_
+#define CONTENT_BROWSER_DEVTOOLS_WORKER_DEVTOOLS_AGENT_HOST_H_
 
-#include "content/browser/devtools/embedded_worker_devtools_manager.h"
 #include "content/browser/devtools/ipc_devtools_agent_host.h"
+#include "content/browser/devtools/worker_devtools_manager.h"
 #include "ipc/ipc_listener.h"
 
 namespace content {
@@ -14,12 +14,10 @@ namespace content {
 class BrowserContext;
 class SharedWorkerInstance;
 
-class EmbeddedWorkerDevToolsAgentHost : public IPCDevToolsAgentHost,
-                                        public IPC::Listener {
+class WorkerDevToolsAgentHost : public IPCDevToolsAgentHost,
+                                public IPC::Listener {
  public:
-  typedef EmbeddedWorkerDevToolsManager::WorkerId WorkerId;
-  typedef EmbeddedWorkerDevToolsManager::ServiceWorkerIdentifier
-      ServiceWorkerIdentifier;
+  typedef WorkerDevToolsManager::WorkerId WorkerId;
 
   // DevToolsAgentHost override.
   bool IsWorker() const override;
@@ -39,15 +37,9 @@ class EmbeddedWorkerDevToolsAgentHost : public IPCDevToolsAgentHost,
   void WorkerDestroyed();
   bool IsTerminated();
 
-  // TODO(kinuko): Remove these virtual methods after we split devtools manager.
-  virtual bool Matches(const SharedWorkerInstance& other);
-  virtual bool Matches(const ServiceWorkerIdentifier& other);
-
  protected:
-  friend class EmbeddedWorkerDevToolsManagerTest;
-
-  EmbeddedWorkerDevToolsAgentHost(WorkerId worker_id);
-  ~EmbeddedWorkerDevToolsAgentHost() override;
+  WorkerDevToolsAgentHost(WorkerId worker_id);
+  ~WorkerDevToolsAgentHost() override;
 
   enum WorkerState {
     WORKER_UNINSPECTED,
@@ -68,12 +60,14 @@ class EmbeddedWorkerDevToolsAgentHost : public IPCDevToolsAgentHost,
   const WorkerId& worker_id() const { return worker_id_; }
 
  private:
+  friend class SharedWorkerDevToolsManagerTest;
+
   WorkerState state_;
   WorkerId worker_id_;
   std::string saved_agent_state_;
-  DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerDevToolsAgentHost);
+  DISALLOW_COPY_AND_ASSIGN(WorkerDevToolsAgentHost);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_DEVTOOLS_EMBEDDED_WORKER_DEVTOOLS_AGENT_HOST_H_
+#endif  // CONTENT_BROWSER_DEVTOOLS_WORKER_DEVTOOLS_AGENT_HOST_H_
diff --git a/content/browser/devtools/worker_devtools_manager.cc b/content/browser/devtools/worker_devtools_manager.cc
new file mode 100644
index 0000000..ad21c9a
--- /dev/null
+++ b/content/browser/devtools/worker_devtools_manager.cc
@@ -0,0 +1,84 @@
+// Copyright 2014 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/worker_devtools_manager.h"
+
+#include "content/browser/devtools/devtools_manager.h"
+#include "content/browser/devtools/service_worker_devtools_manager.h"
+#include "content/browser/devtools/shared_worker_devtools_manager.h"
+#include "content/browser/devtools/worker_devtools_agent_host.h"
+#include "content/public/browser/browser_thread.h"
+
+namespace content {
+
+// Called on the UI thread.
+// static
+scoped_refptr<DevToolsAgentHost> DevToolsAgentHost::GetForWorker(
+    int worker_process_id,
+    int worker_route_id) {
+  if (scoped_refptr<DevToolsAgentHost> host =
+      SharedWorkerDevToolsManager::GetInstance()
+          ->GetDevToolsAgentHostForWorker(worker_process_id, worker_route_id)) {
+    return host;
+  }
+  return ServiceWorkerDevToolsManager::GetInstance()
+      ->GetDevToolsAgentHostForWorker(worker_process_id, worker_route_id);
+}
+
+DevToolsAgentHostImpl*
+WorkerDevToolsManager::GetDevToolsAgentHostForWorker(int worker_process_id,
+                                                     int worker_route_id) {
+  AgentHostMap::iterator it = workers_.find(
+      WorkerId(worker_process_id, worker_route_id));
+  return it == workers_.end() ? NULL : it->second;
+}
+
+void WorkerDevToolsManager::AddAllAgentHosts(DevToolsAgentHost::List* result) {
+  for (auto& worker : workers_) {
+    if (!worker.second->IsTerminated())
+      result->push_back(worker.second);
+  }
+}
+
+void WorkerDevToolsManager::WorkerDestroyed(int worker_process_id,
+                                            int worker_route_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  const WorkerId id(worker_process_id, worker_route_id);
+  AgentHostMap::iterator it = workers_.find(id);
+  DCHECK(it != workers_.end());
+  scoped_refptr<WorkerDevToolsAgentHost> agent_host(it->second);
+  agent_host->WorkerDestroyed();
+  DevToolsManager::GetInstance()->AgentHostChanged(agent_host);
+}
+
+void WorkerDevToolsManager::WorkerReadyForInspection(int worker_process_id,
+                                                     int worker_route_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  const WorkerId id(worker_process_id, worker_route_id);
+  AgentHostMap::iterator it = workers_.find(id);
+  DCHECK(it != workers_.end());
+  it->second->WorkerReadyForInspection();
+}
+
+WorkerDevToolsManager::WorkerDevToolsManager() {
+}
+
+WorkerDevToolsManager::~WorkerDevToolsManager() {
+}
+
+void WorkerDevToolsManager::RemoveInspectedWorkerData(WorkerId id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  workers_.erase(id);
+}
+
+void WorkerDevToolsManager::WorkerRestarted(const WorkerId& id,
+                                            const AgentHostMap::iterator& it) {
+  WorkerDevToolsAgentHost* agent_host = it->second;
+  agent_host->WorkerRestarted(id);
+  workers_.erase(it);
+  workers_[id] = agent_host;
+  DevToolsManager::GetInstance()->AgentHostChanged(agent_host);
+}
+
+}  // namespace content
diff --git a/content/browser/devtools/worker_devtools_manager.h b/content/browser/devtools/worker_devtools_manager.h
new file mode 100644
index 0000000..910fd40
--- /dev/null
+++ b/content/browser/devtools/worker_devtools_manager.h
@@ -0,0 +1,51 @@
+// Copyright 2014 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_DEVTOOLS_WORKER_DEVTOOLS_MANAGER_H_
+#define CONTENT_BROWSER_DEVTOOLS_WORKER_DEVTOOLS_MANAGER_H_
+
+#include <map>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/memory/ref_counted.h"
+#include "content/common/content_export.h"
+
+namespace content {
+
+class DevToolsAgentHost;
+class DevToolsAgentHostImpl;
+class WorkerDevToolsAgentHost;
+
+// A base class of SharedWorkerDevToolsManager and ServiceWorkerDevToolsManager,
+// provides common default implementation for them.
+// This class lives on UI thread.
+class CONTENT_EXPORT WorkerDevToolsManager {
+ public:
+  typedef std::pair<int, int> WorkerId;
+
+  DevToolsAgentHostImpl* GetDevToolsAgentHostForWorker(int worker_process_id,
+                                                       int worker_route_id);
+  void AddAllAgentHosts(std::vector<scoped_refptr<DevToolsAgentHost>>* result);
+  void WorkerReadyForInspection(int worker_process_id, int worker_route_id);
+  void WorkerDestroyed(int worker_process_id, int worker_route_id);
+
+ protected:
+  typedef std::map<WorkerId, WorkerDevToolsAgentHost*> AgentHostMap;
+  friend class SharedWorkerDevToolsManagerTest;
+
+  WorkerDevToolsManager();
+  virtual ~WorkerDevToolsManager();
+  void RemoveInspectedWorkerData(WorkerId id);
+  void WorkerRestarted(const WorkerId& id, const AgentHostMap::iterator& it);
+  AgentHostMap& workers() { return workers_; }
+
+ private:
+  AgentHostMap workers_;
+  DISALLOW_COPY_AND_ASSIGN(WorkerDevToolsManager);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_WORKER_DEVTOOLS_MANAGER_H_
diff --git a/content/browser/service_worker/embedded_worker_instance.cc b/content/browser/service_worker/embedded_worker_instance.cc
index 6bda822..07b14f6 100644
--- a/content/browser/service_worker/embedded_worker_instance.cc
+++ b/content/browser/service_worker/embedded_worker_instance.cc
@@ -9,7 +9,7 @@
 
 #include "base/bind_helpers.h"
 #include "base/debug/trace_event.h"
-#include "content/browser/devtools/embedded_worker_devtools_manager.h"
+#include "content/browser/devtools/service_worker_devtools_manager.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
@@ -42,7 +42,7 @@ void NotifyWorkerReadyForInspection(int worker_process_id,
                                        worker_route_id));
     return;
   }
-  EmbeddedWorkerDevToolsManager::GetInstance()->WorkerReadyForInspection(
+  ServiceWorkerDevToolsManager::GetInstance()->WorkerReadyForInspection(
       worker_process_id, worker_route_id);
 }
 
@@ -55,7 +55,7 @@ void NotifyWorkerDestroyed(int worker_process_id, int worker_route_id) {
         base::Bind(NotifyWorkerDestroyed, worker_process_id, worker_route_id));
     return;
   }
-  EmbeddedWorkerDevToolsManager::GetInstance()->WorkerDestroyed(
+  ServiceWorkerDevToolsManager::GetInstance()->WorkerDestroyed(
       worker_process_id, worker_route_id);
 }
 
@@ -69,7 +69,7 @@ void NotifyWorkerStopIgnored(int worker_process_id, int worker_route_id) {
                                        worker_route_id));
     return;
   }
-  EmbeddedWorkerDevToolsManager::GetInstance()->WorkerStopIgnored(
+  ServiceWorkerDevToolsManager::GetInstance()->WorkerStopIgnored(
       worker_process_id, worker_route_id);
 }
 
@@ -101,10 +101,10 @@ void RegisterToWorkerDevToolsManager(
     // |rph| may be NULL in unit tests.
     worker_devtools_agent_route_id = rph->GetNextRoutingID();
     wait_for_debugger =
-        EmbeddedWorkerDevToolsManager::GetInstance()->ServiceWorkerCreated(
+        ServiceWorkerDevToolsManager::GetInstance()->WorkerCreated(
             process_id,
             worker_devtools_agent_route_id,
-            EmbeddedWorkerDevToolsManager::ServiceWorkerIdentifier(
+            ServiceWorkerDevToolsManager::ServiceWorkerIdentifier(
                 service_worker_context,
                 service_worker_context_weak,
                 service_worker_version_id,
diff --git a/content/browser/service_worker/service_worker_internals_ui.cc b/content/browser/service_worker/service_worker_internals_ui.cc
index a7c8d71..f135806 100644
--- a/content/browser/service_worker/service_worker_internals_ui.cc
+++ b/content/browser/service_worker/service_worker_internals_ui.cc
@@ -12,7 +12,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "content/browser/devtools/devtools_agent_host_impl.h"
-#include "content/browser/devtools/embedded_worker_devtools_manager.h"
+#include "content/browser/devtools/service_worker_devtools_manager.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_registration.h"
@@ -457,7 +457,7 @@ ServiceWorkerInternalsUI::~ServiceWorkerInternalsUI() {
 void ServiceWorkerInternalsUI::GetOptions(const ListValue* args) {
   DictionaryValue options;
   options.SetBoolean("debug_on_start",
-                     EmbeddedWorkerDevToolsManager::GetInstance()
+                     ServiceWorkerDevToolsManager::GetInstance()
                          ->debug_service_worker_on_start());
   web_ui()->CallJavascriptFunction("serviceworker.onOptions", options);
 }
@@ -469,7 +469,7 @@ void ServiceWorkerInternalsUI::SetOption(const ListValue* args) {
       !args->GetBoolean(1, &option_boolean)) {
     return;
   }
-  EmbeddedWorkerDevToolsManager::GetInstance()
+  ServiceWorkerDevToolsManager::GetInstance()
       ->set_debug_service_worker_on_start(option_boolean);
 }
 
@@ -623,7 +623,7 @@ void ServiceWorkerInternalsUI::InspectWorker(const ListValue* args) {
   base::Callback<void(ServiceWorkerStatusCode)> callback =
       base::Bind(OperationCompleteCallback, AsWeakPtr(), callback_id);
   scoped_refptr<DevToolsAgentHostImpl> agent_host(
-      EmbeddedWorkerDevToolsManager::GetInstance()
+      ServiceWorkerDevToolsManager::GetInstance()
           ->GetDevToolsAgentHostForWorker(process_id, devtools_agent_route_id));
   if (!agent_host.get()) {
     callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND);
diff --git a/content/browser/shared_worker/shared_worker_host.cc b/content/browser/shared_worker/shared_worker_host.cc
index a823cc2..2b66849 100644
--- a/content/browser/shared_worker/shared_worker_host.cc
+++ b/content/browser/shared_worker/shared_worker_host.cc
@@ -5,7 +5,7 @@
 #include "content/browser/shared_worker/shared_worker_host.h"
 
 #include "base/metrics/histogram.h"
-#include "content/browser/devtools/embedded_worker_devtools_manager.h"
+#include "content/browser/devtools/shared_worker_devtools_manager.h"
 #include "content/browser/frame_host/render_frame_host_delegate.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/message_port_message_filter.h"
@@ -42,7 +42,7 @@ void NotifyWorkerReadyForInspection(int worker_process_id,
                                        worker_route_id));
     return;
   }
-  EmbeddedWorkerDevToolsManager::GetInstance()->WorkerReadyForInspection(
+  SharedWorkerDevToolsManager::GetInstance()->WorkerReadyForInspection(
       worker_process_id, worker_route_id);
 }
 
@@ -54,7 +54,7 @@ void NotifyWorkerDestroyed(int worker_process_id, int worker_route_id) {
         base::Bind(NotifyWorkerDestroyed, worker_process_id, worker_route_id));
     return;
   }
-  EmbeddedWorkerDevToolsManager::GetInstance()->WorkerDestroyed(
+  SharedWorkerDevToolsManager::GetInstance()->WorkerDestroyed(
       worker_process_id, worker_route_id);
 }
 
diff --git a/content/browser/shared_worker/shared_worker_instance.h b/content/browser/shared_worker/shared_worker_instance.h
index b7c5fdb..5d650e5 100644
--- a/content/browser/shared_worker/shared_worker_instance.h
+++ b/content/browser/shared_worker/shared_worker_instance.h
@@ -17,7 +17,7 @@ namespace content {
 class ResourceContext;
 
 // SharedWorkerInstance is copyable value-type data type. It could be passed to
-// the UI thread and be used for comparison in EmbeddedWorkerDevToolsManager.
+// the UI thread and be used for comparison in SharedWorkerDevToolsManager.
 class CONTENT_EXPORT SharedWorkerInstance {
  public:
   SharedWorkerInstance(const GURL& url,
diff --git a/content/browser/shared_worker/shared_worker_service_impl.cc b/content/browser/shared_worker/shared_worker_service_impl.cc
index b773127..0fbb221 100644
--- a/content/browser/shared_worker/shared_worker_service_impl.cc
+++ b/content/browser/shared_worker/shared_worker_service_impl.cc
@@ -11,7 +11,7 @@
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
-#include "content/browser/devtools/embedded_worker_devtools_manager.h"
+#include "content/browser/devtools/shared_worker_devtools_manager.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/shared_worker/shared_worker_host.h"
 #include "content/browser/shared_worker/shared_worker_instance.h"
@@ -198,7 +198,7 @@ class SharedWorkerServiceImpl::SharedWorkerReserver
     bool pause_on_start = false;
     if (is_new_worker_) {
       pause_on_start =
-          EmbeddedWorkerDevToolsManager::GetInstance()->SharedWorkerCreated(
+          SharedWorkerDevToolsManager::GetInstance()->WorkerCreated(
               worker_process_id_, worker_route_id_, instance_);
     }
     BrowserThread::PostTask(
diff --git a/content/content_browser.gypi b/content/content_browser.gypi
index 6f710f6..f0b7d06 100644
--- a/content/content_browser.gypi
+++ b/content/content_browser.gypi
@@ -450,10 +450,6 @@
       'browser/devtools/devtools_manager.h',
       'browser/devtools/devtools_netlog_observer.cc',
       'browser/devtools/devtools_netlog_observer.h',
-      'browser/devtools/embedded_worker_devtools_agent_host.cc',
-      'browser/devtools/embedded_worker_devtools_agent_host.h',
-      'browser/devtools/embedded_worker_devtools_manager.cc',
-      'browser/devtools/embedded_worker_devtools_manager.h',
       'browser/devtools/forwarding_agent_host.cc',
       'browser/devtools/forwarding_agent_host.h',
       'browser/devtools/ipc_devtools_agent_host.cc',
@@ -492,8 +488,16 @@
       'browser/devtools/render_view_devtools_agent_host.h',
       'browser/devtools/service_worker_devtools_agent_host.cc',
       'browser/devtools/service_worker_devtools_agent_host.h',
+      'browser/devtools/service_worker_devtools_manager.cc',
+      'browser/devtools/service_worker_devtools_manager.h',
       'browser/devtools/shared_worker_devtools_agent_host.cc',
       'browser/devtools/shared_worker_devtools_agent_host.h',
+      'browser/devtools/shared_worker_devtools_manager.cc',
+      'browser/devtools/shared_worker_devtools_manager.h',
+      'browser/devtools/worker_devtools_agent_host.cc',
+      'browser/devtools/worker_devtools_agent_host.h',
+      'browser/devtools/worker_devtools_manager.cc',
+      'browser/devtools/worker_devtools_manager.h',
       'browser/device_monitor_mac.h',
       'browser/device_monitor_mac.mm',
       'browser/device_monitor_udev.cc',
diff --git a/content/content_tests.gypi b/content/content_tests.gypi
index 08d985e..b45a4cd 100644
--- a/content/content_tests.gypi
+++ b/content/content_tests.gypi
@@ -454,9 +454,9 @@
         'browser/database_util_unittest.cc',
         'browser/device_sensors/data_fetcher_shared_memory_base_unittest.cc',
         'browser/device_sensors/sensor_manager_android_unittest.cc',
-        'browser/devtools/embedded_worker_devtools_manager_unittest.cc',
         'browser/devtools/devtools_http_handler_unittest.cc',
         'browser/devtools/devtools_manager_unittest.cc',
+        'browser/devtools/shared_worker_devtools_manager_unittest.cc',
         'browser/dom_storage/dom_storage_area_unittest.cc',
         'browser/dom_storage/dom_storage_context_impl_unittest.cc',
         'browser/dom_storage/dom_storage_database_unittest.cc',