Rename SharedWorkerDevToolsManager to EmbeddedWorkerDevToolsManager.

EmbeddedWorkerDevToolsManager will be used not only for SharedWorker but also for ServiceWorker.

BUG=358657

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

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

9 files changed, 126 insertions, 120 deletions

diff --git a/content/browser/devtools/shared_worker_devtools_manager.cc b/content/browser/devtools/embedded_worker_devtools_manager.cc
index 0563773..b08ba88 100644
--- a/content/browser/devtools/shared_worker_devtools_manager.cc
+++ b/content/browser/devtools/embedded_worker_devtools_manager.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/shared_worker_devtools_manager.h"
+#include "content/browser/devtools/embedded_worker_devtools_manager.h"
 
 #include "content/browser/devtools/devtools_manager_impl.h"
 #include "content/browser/devtools/devtools_protocol.h"
@@ -19,8 +19,9 @@ namespace content {
 
 namespace {
 
-bool SendMessageToWorker(const SharedWorkerDevToolsManager::WorkerId& worker_id,
-                         IPC::Message* message) {
+bool SendMessageToWorker(
+    const EmbeddedWorkerDevToolsManager::WorkerId& worker_id,
+    IPC::Message* message) {
   RenderProcessHost* host = RenderProcessHost::FromID(worker_id.first);
   if (!host) {
     delete message;
@@ -33,11 +34,11 @@ bool SendMessageToWorker(const SharedWorkerDevToolsManager::WorkerId& worker_id,
 
 }  // namespace
 
-class SharedWorkerDevToolsManager::SharedWorkerDevToolsAgentHost
+class EmbeddedWorkerDevToolsManager::EmbeddedWorkerDevToolsAgentHost
     : public IPCDevToolsAgentHost,
       public IPC::Listener {
  public:
-  explicit SharedWorkerDevToolsAgentHost(WorkerId worker_id)
+  explicit EmbeddedWorkerDevToolsAgentHost(WorkerId worker_id)
       : worker_id_(worker_id), worker_attached_(true) {
     AddRef();
     if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first))
@@ -58,7 +59,7 @@ class SharedWorkerDevToolsManager::SharedWorkerDevToolsAgentHost
   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     bool handled = true;
-    IPC_BEGIN_MESSAGE_MAP(SharedWorkerDevToolsAgentHost, msg)
+    IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerDevToolsAgentHost, msg)
     IPC_MESSAGE_HANDLER(DevToolsClientMsg_DispatchOnInspectorFrontend,
                         OnDispatchOnInspectorFrontend)
     IPC_MESSAGE_HANDLER(DevToolsHostMsg_SaveAgentRuntimeState,
@@ -89,9 +90,10 @@ class SharedWorkerDevToolsManager::SharedWorkerDevToolsAgentHost
   WorkerId worker_id() const { return worker_id_; }
 
  private:
-  virtual ~SharedWorkerDevToolsAgentHost() {
+  virtual ~EmbeddedWorkerDevToolsAgentHost() {
     CHECK(!worker_attached_);
-    SharedWorkerDevToolsManager::GetInstance()->RemoveInspectedWorkerData(this);
+    EmbeddedWorkerDevToolsManager::GetInstance()->RemoveInspectedWorkerData(
+        this);
   }
 
   void OnDispatchOnInspectorFrontend(const std::string& message) {
@@ -104,16 +106,16 @@ class SharedWorkerDevToolsManager::SharedWorkerDevToolsAgentHost
   WorkerId worker_id_;
   bool worker_attached_;
   std::string state_;
-  DISALLOW_COPY_AND_ASSIGN(SharedWorkerDevToolsAgentHost);
+  DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerDevToolsAgentHost);
 };
 
 // static
-SharedWorkerDevToolsManager* SharedWorkerDevToolsManager::GetInstance() {
+EmbeddedWorkerDevToolsManager* EmbeddedWorkerDevToolsManager::GetInstance() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return Singleton<SharedWorkerDevToolsManager>::get();
+  return Singleton<EmbeddedWorkerDevToolsManager>::get();
 }
 
-DevToolsAgentHost* SharedWorkerDevToolsManager::GetDevToolsAgentHostForWorker(
+DevToolsAgentHost* EmbeddedWorkerDevToolsManager::GetDevToolsAgentHostForWorker(
     int worker_process_id,
     int worker_route_id) {
   WorkerId id(worker_process_id, worker_route_id);
@@ -126,24 +128,26 @@ DevToolsAgentHost* SharedWorkerDevToolsManager::GetDevToolsAgentHostForWorker(
   if (info->state() != WORKER_UNINSPECTED)
     return info->agent_host();
 
-  SharedWorkerDevToolsAgentHost* agent_host =
-      new SharedWorkerDevToolsAgentHost(id);
+  EmbeddedWorkerDevToolsAgentHost* agent_host =
+      new EmbeddedWorkerDevToolsAgentHost(id);
   info->set_agent_host(agent_host);
   info->set_state(WORKER_INSPECTED);
   return agent_host;
 }
 
-SharedWorkerDevToolsManager::SharedWorkerDevToolsManager() {}
+EmbeddedWorkerDevToolsManager::EmbeddedWorkerDevToolsManager() {
+}
 
-SharedWorkerDevToolsManager::~SharedWorkerDevToolsManager() {}
+EmbeddedWorkerDevToolsManager::~EmbeddedWorkerDevToolsManager() {
+}
 
-bool SharedWorkerDevToolsManager::WorkerCreated(
+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);
-  WorkerInfoMap::iterator it = FindExistingWorkerInfo(instance);
+  WorkerInfoMap::iterator it = FindExistingSharedWorkerInfo(instance);
   if (it == workers_.end()) {
     scoped_ptr<WorkerInfo> info(new WorkerInfo(instance));
     workers_.set(id, info.Pass());
@@ -156,8 +160,8 @@ bool SharedWorkerDevToolsManager::WorkerCreated(
   return true;
 }
 
-void SharedWorkerDevToolsManager::WorkerDestroyed(int worker_process_id,
-                                                  int worker_route_id) {
+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);
   WorkerInfoMap::iterator it = workers_.find(id);
@@ -168,7 +172,7 @@ void SharedWorkerDevToolsManager::WorkerDestroyed(int worker_process_id,
       workers_.erase(it);
       break;
     case WORKER_INSPECTED: {
-      SharedWorkerDevToolsAgentHost* agent_host = info->agent_host();
+      EmbeddedWorkerDevToolsAgentHost* agent_host = info->agent_host();
       if (!agent_host->IsAttached()) {
         scoped_ptr<WorkerInfo> worker_info = workers_.take_and_erase(it);
         agent_host->DetachFromWorker();
@@ -198,8 +202,8 @@ void SharedWorkerDevToolsManager::WorkerDestroyed(int worker_process_id,
   }
 }
 
-void SharedWorkerDevToolsManager::WorkerContextStarted(int worker_process_id,
-                                                       int worker_route_id) {
+void EmbeddedWorkerDevToolsManager::WorkerContextStarted(int worker_process_id,
+                                                         int worker_route_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   const WorkerId id(worker_process_id, worker_route_id);
   WorkerInfoMap::iterator it = workers_.find(id);
@@ -211,8 +215,8 @@ void SharedWorkerDevToolsManager::WorkerContextStarted(int worker_process_id,
   info->set_state(WORKER_INSPECTED);
 }
 
-void SharedWorkerDevToolsManager::RemoveInspectedWorkerData(
-    SharedWorkerDevToolsAgentHost* agent_host) {
+void EmbeddedWorkerDevToolsManager::RemoveInspectedWorkerData(
+    EmbeddedWorkerDevToolsAgentHost* agent_host) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   const WorkerId id(agent_host->worker_id());
   scoped_ptr<WorkerInfo> worker_info = workers_.take_and_erase(id);
@@ -234,8 +238,8 @@ void SharedWorkerDevToolsManager::RemoveInspectedWorkerData(
   }
 }
 
-SharedWorkerDevToolsManager::WorkerInfoMap::iterator
-SharedWorkerDevToolsManager::FindExistingWorkerInfo(
+EmbeddedWorkerDevToolsManager::WorkerInfoMap::iterator
+EmbeddedWorkerDevToolsManager::FindExistingSharedWorkerInfo(
     const SharedWorkerInstance& instance) {
   WorkerInfoMap::iterator it = workers_.begin();
   for (; it != workers_.end(); ++it) {
@@ -245,6 +249,8 @@ SharedWorkerDevToolsManager::FindExistingWorkerInfo(
   return it;
 }
 
-void SharedWorkerDevToolsManager::ResetForTesting() { workers_.clear(); }
+void EmbeddedWorkerDevToolsManager::ResetForTesting() {
+  workers_.clear();
+}
 
 }  // namespace content
diff --git a/content/browser/devtools/shared_worker_devtools_manager.h b/content/browser/devtools/embedded_worker_devtools_manager.h
index 4b23821..8a07e5b 100644
--- a/content/browser/devtools/shared_worker_devtools_manager.h
+++ b/content/browser/devtools/embedded_worker_devtools_manager.h
@@ -2,8 +2,8 @@
 // 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_
+#ifndef CONTENT_BROWSER_DEVTOOLS_EMBEDDED_WORKER_DEVTOOLS_MANAGER_H_
+#define CONTENT_BROWSER_DEVTOOLS_EMBEDDED_WORKER_DEVTOOLS_MANAGER_H_
 
 #include "base/basictypes.h"
 #include "base/containers/scoped_ptr_hash_map.h"
@@ -19,32 +19,32 @@ class GURL;
 namespace content {
 class DevToolsAgentHost;
 
-// SharedWorkerDevToolsManager is used instead of WorkerDevToolsManager when
+// EmbeddedWorkerDevToolsManager is used instead of WorkerDevToolsManager when
 // "enable-embedded-shared-worker" flag is set.
 // This class lives on UI thread.
-class CONTENT_EXPORT SharedWorkerDevToolsManager {
+class CONTENT_EXPORT EmbeddedWorkerDevToolsManager {
  public:
   typedef std::pair<int, int> WorkerId;
-  class SharedWorkerDevToolsAgentHost;
+  class EmbeddedWorkerDevToolsAgentHost;
 
-  // Returns the SharedWorkerDevToolsManager singleton.
-  static SharedWorkerDevToolsManager* GetInstance();
+  // Returns the EmbeddedWorkerDevToolsManager singleton.
+  static EmbeddedWorkerDevToolsManager* GetInstance();
 
   DevToolsAgentHost* GetDevToolsAgentHostForWorker(int worker_process_id,
                                                    int worker_route_id);
 
   // Returns true when the worker must be paused on start.
-  bool WorkerCreated(int worker_process_id,
-                     int worker_route_id,
-                     const SharedWorkerInstance& instance);
+  bool SharedWorkerCreated(int worker_process_id,
+                           int worker_route_id,
+                           const SharedWorkerInstance& instance);
   void WorkerDestroyed(int worker_process_id, int worker_route_id);
   void WorkerContextStarted(int worker_process_id, int worker_route_id);
 
  private:
-  friend struct DefaultSingletonTraits<SharedWorkerDevToolsManager>;
-  friend class SharedWorkerDevToolsManagerTest;
-  FRIEND_TEST_ALL_PREFIXES(SharedWorkerDevToolsManagerTest, BasicTest);
-  FRIEND_TEST_ALL_PREFIXES(SharedWorkerDevToolsManagerTest, AttachTest);
+  friend struct DefaultSingletonTraits<EmbeddedWorkerDevToolsManager>;
+  friend class EmbeddedWorkerDevToolsManagerTest;
+  FRIEND_TEST_ALL_PREFIXES(EmbeddedWorkerDevToolsManagerTest, BasicTest);
+  FRIEND_TEST_ALL_PREFIXES(EmbeddedWorkerDevToolsManagerTest, AttachTest);
 
   enum WorkerState {
     WORKER_UNINSPECTED,
@@ -61,25 +61,25 @@ class CONTENT_EXPORT SharedWorkerDevToolsManager {
     const SharedWorkerInstance& instance() const { return instance_; }
     WorkerState state() { return state_; }
     void set_state(WorkerState new_state) { state_ = new_state; }
-    SharedWorkerDevToolsAgentHost* agent_host() { return agent_host_; }
-    void set_agent_host(SharedWorkerDevToolsAgentHost* agent_host) {
+    EmbeddedWorkerDevToolsAgentHost* agent_host() { return agent_host_; }
+    void set_agent_host(EmbeddedWorkerDevToolsAgentHost* agent_host) {
       agent_host_ = agent_host;
     }
 
    private:
     const SharedWorkerInstance instance_;
     WorkerState state_;
-    SharedWorkerDevToolsAgentHost* agent_host_;
+    EmbeddedWorkerDevToolsAgentHost* agent_host_;
   };
 
   typedef base::ScopedPtrHashMap<WorkerId, WorkerInfo> WorkerInfoMap;
 
-  SharedWorkerDevToolsManager();
-  virtual ~SharedWorkerDevToolsManager();
+  EmbeddedWorkerDevToolsManager();
+  virtual ~EmbeddedWorkerDevToolsManager();
 
-  void RemoveInspectedWorkerData(SharedWorkerDevToolsAgentHost* agent_host);
+  void RemoveInspectedWorkerData(EmbeddedWorkerDevToolsAgentHost* agent_host);
 
-  WorkerInfoMap::iterator FindExistingWorkerInfo(
+  WorkerInfoMap::iterator FindExistingSharedWorkerInfo(
       const SharedWorkerInstance& instance);
 
   // Resets to its initial state as if newly created.
@@ -87,9 +87,9 @@ class CONTENT_EXPORT SharedWorkerDevToolsManager {
 
   WorkerInfoMap workers_;
 
-  DISALLOW_COPY_AND_ASSIGN(SharedWorkerDevToolsManager);
+  DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerDevToolsManager);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_DEVTOOLS_SHARED_WORKER_DEVTOOLS_MANAGER_H_
+#endif  // CONTENT_BROWSER_DEVTOOLS_EMBEDDED_WORKER_DEVTOOLS_MANAGER_H_
diff --git a/content/browser/devtools/shared_worker_devtools_manager_unittest.cc b/content/browser/devtools/embedded_worker_devtools_manager_unittest.cc
index 0f987b7..49a6144 100644
--- a/content/browser/devtools/shared_worker_devtools_manager_unittest.cc
+++ b/content/browser/devtools/embedded_worker_devtools_manager_unittest.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/shared_worker_devtools_manager.h"
+#include "content/browser/devtools/embedded_worker_devtools_manager.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ -23,8 +23,8 @@ class TestDevToolsClientHost : public DevToolsClientHost {
  public:
   TestDevToolsClientHost() {}
   virtual ~TestDevToolsClientHost() {}
-  virtual void DispatchOnInspectorFrontend(const std::string& message)
-      OVERRIDE {}
+  virtual void DispatchOnInspectorFrontend(
+      const std::string& message) OVERRIDE {}
   virtual void InspectedContentsClosing() OVERRIDE {}
   virtual void ReplacedWithAnotherClient() OVERRIDE {}
 
@@ -33,9 +33,9 @@ class TestDevToolsClientHost : public DevToolsClientHost {
 };
 }
 
-class SharedWorkerDevToolsManagerTest : public testing::Test {
+class EmbeddedWorkerDevToolsManagerTest : public testing::Test {
  public:
-  SharedWorkerDevToolsManagerTest()
+  EmbeddedWorkerDevToolsManagerTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         browser_context_(new TestBrowserContext()),
         partition_(
@@ -51,26 +51,26 @@ class SharedWorkerDevToolsManagerTest : public testing::Test {
 
  protected:
   virtual void SetUp() OVERRIDE {
-    manager_ = SharedWorkerDevToolsManager::GetInstance();
+    manager_ = EmbeddedWorkerDevToolsManager::GetInstance();
   }
   virtual void TearDown() OVERRIDE {
-    SharedWorkerDevToolsManager::GetInstance()->ResetForTesting();
+    EmbeddedWorkerDevToolsManager::GetInstance()->ResetForTesting();
   }
 
   void CheckWorkerState(int worker_process_id,
                         int worker_route_id,
-                        SharedWorkerDevToolsManager::WorkerState state) {
-    const SharedWorkerDevToolsManager::WorkerId id(worker_process_id,
-                                                   worker_route_id);
-    SharedWorkerDevToolsManager::WorkerInfoMap::iterator it =
+                        EmbeddedWorkerDevToolsManager::WorkerState state) {
+    const EmbeddedWorkerDevToolsManager::WorkerId id(worker_process_id,
+                                                     worker_route_id);
+    EmbeddedWorkerDevToolsManager::WorkerInfoMap::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 SharedWorkerDevToolsManager::WorkerId id(worker_process_id,
-                                                   worker_route_id);
+    const EmbeddedWorkerDevToolsManager::WorkerId id(worker_process_id,
+                                                     worker_route_id);
     EXPECT_TRUE(manager_->workers_.end() == manager_->workers_.find(id));
   }
 
@@ -93,10 +93,10 @@ class SharedWorkerDevToolsManagerTest : public testing::Test {
   scoped_ptr<TestBrowserContext> browser_context_;
   scoped_ptr<WorkerStoragePartition> partition_;
   const WorkerStoragePartitionId partition_id_;
-  SharedWorkerDevToolsManager* manager_;
+  EmbeddedWorkerDevToolsManager* manager_;
 };
 
-TEST_F(SharedWorkerDevToolsManagerTest, BasicTest) {
+TEST_F(EmbeddedWorkerDevToolsManagerTest, BasicTest) {
   scoped_refptr<DevToolsAgentHost> agent_host;
 
   SharedWorkerInstance instance1(GURL("http://example.com/w.js"),
@@ -111,71 +111,71 @@ TEST_F(SharedWorkerDevToolsManagerTest, BasicTest) {
 
   // Created -> Started -> Destroyed
   CheckWorkerNotExist(1, 1);
-  manager_->WorkerCreated(1, 1, instance1);
-  CheckWorkerState(1, 1, SharedWorkerDevToolsManager::WORKER_UNINSPECTED);
+  manager_->SharedWorkerCreated(1, 1, instance1);
+  CheckWorkerState(1, 1, EmbeddedWorkerDevToolsManager::WORKER_UNINSPECTED);
   manager_->WorkerContextStarted(1, 1);
-  CheckWorkerState(1, 1, SharedWorkerDevToolsManager::WORKER_UNINSPECTED);
+  CheckWorkerState(1, 1, EmbeddedWorkerDevToolsManager::WORKER_UNINSPECTED);
   manager_->WorkerDestroyed(1, 1);
   CheckWorkerNotExist(1, 1);
 
   // Created -> GetDevToolsAgentHost -> Started -> Destroyed
   CheckWorkerNotExist(1, 2);
-  manager_->WorkerCreated(1, 2, instance1);
-  CheckWorkerState(1, 2, SharedWorkerDevToolsManager::WORKER_UNINSPECTED);
+  manager_->SharedWorkerCreated(1, 2, instance1);
+  CheckWorkerState(1, 2, EmbeddedWorkerDevToolsManager::WORKER_UNINSPECTED);
   agent_host = manager_->GetDevToolsAgentHostForWorker(1, 2);
   EXPECT_TRUE(agent_host.get());
-  CheckWorkerState(1, 2, SharedWorkerDevToolsManager::WORKER_INSPECTED);
+  CheckWorkerState(1, 2, EmbeddedWorkerDevToolsManager::WORKER_INSPECTED);
   EXPECT_EQ(agent_host.get(), manager_->GetDevToolsAgentHostForWorker(1, 2));
   manager_->WorkerContextStarted(1, 2);
-  CheckWorkerState(1, 2, SharedWorkerDevToolsManager::WORKER_INSPECTED);
+  CheckWorkerState(1, 2, EmbeddedWorkerDevToolsManager::WORKER_INSPECTED);
   manager_->WorkerDestroyed(1, 2);
   CheckWorkerNotExist(1, 2);
   agent_host = NULL;
 
   // Created -> Started -> GetDevToolsAgentHost -> Destroyed
   CheckWorkerNotExist(1, 3);
-  manager_->WorkerCreated(1, 3, instance1);
-  CheckWorkerState(1, 3, SharedWorkerDevToolsManager::WORKER_UNINSPECTED);
+  manager_->SharedWorkerCreated(1, 3, instance1);
+  CheckWorkerState(1, 3, EmbeddedWorkerDevToolsManager::WORKER_UNINSPECTED);
   manager_->WorkerContextStarted(1, 3);
-  CheckWorkerState(1, 3, SharedWorkerDevToolsManager::WORKER_UNINSPECTED);
+  CheckWorkerState(1, 3, EmbeddedWorkerDevToolsManager::WORKER_UNINSPECTED);
   agent_host = manager_->GetDevToolsAgentHostForWorker(1, 3);
   EXPECT_TRUE(agent_host.get());
-  CheckWorkerState(1, 3, SharedWorkerDevToolsManager::WORKER_INSPECTED);
+  CheckWorkerState(1, 3, EmbeddedWorkerDevToolsManager::WORKER_INSPECTED);
   manager_->WorkerDestroyed(1, 3);
   CheckWorkerNotExist(1, 3);
   agent_host = NULL;
 
   // Created -> Destroyed
   CheckWorkerNotExist(1, 4);
-  manager_->WorkerCreated(1, 4, instance1);
-  CheckWorkerState(1, 4, SharedWorkerDevToolsManager::WORKER_UNINSPECTED);
+  manager_->SharedWorkerCreated(1, 4, instance1);
+  CheckWorkerState(1, 4, EmbeddedWorkerDevToolsManager::WORKER_UNINSPECTED);
   manager_->WorkerDestroyed(1, 4);
   CheckWorkerNotExist(1, 4);
 
   // Created -> GetDevToolsAgentHost -> Destroyed
   CheckWorkerNotExist(1, 5);
-  manager_->WorkerCreated(1, 5, instance1);
-  CheckWorkerState(1, 5, SharedWorkerDevToolsManager::WORKER_UNINSPECTED);
+  manager_->SharedWorkerCreated(1, 5, instance1);
+  CheckWorkerState(1, 5, EmbeddedWorkerDevToolsManager::WORKER_UNINSPECTED);
   agent_host = manager_->GetDevToolsAgentHostForWorker(1, 5);
   EXPECT_TRUE(agent_host.get());
-  CheckWorkerState(1, 5, SharedWorkerDevToolsManager::WORKER_INSPECTED);
+  CheckWorkerState(1, 5, EmbeddedWorkerDevToolsManager::WORKER_INSPECTED);
   manager_->WorkerDestroyed(1, 5);
   CheckWorkerNotExist(1, 5);
   agent_host = NULL;
 
   // Created -> GetDevToolsAgentHost -> Free agent_host -> Destroyed
   CheckWorkerNotExist(1, 6);
-  manager_->WorkerCreated(1, 6, instance1);
-  CheckWorkerState(1, 6, SharedWorkerDevToolsManager::WORKER_UNINSPECTED);
+  manager_->SharedWorkerCreated(1, 6, instance1);
+  CheckWorkerState(1, 6, EmbeddedWorkerDevToolsManager::WORKER_UNINSPECTED);
   agent_host = manager_->GetDevToolsAgentHostForWorker(1, 6);
   EXPECT_TRUE(agent_host.get());
-  CheckWorkerState(1, 6, SharedWorkerDevToolsManager::WORKER_INSPECTED);
+  CheckWorkerState(1, 6, EmbeddedWorkerDevToolsManager::WORKER_INSPECTED);
   agent_host = NULL;
   manager_->WorkerDestroyed(1, 6);
   CheckWorkerNotExist(1, 6);
 }
 
-TEST_F(SharedWorkerDevToolsManagerTest, AttachTest) {
+TEST_F(EmbeddedWorkerDevToolsManagerTest, AttachTest) {
   scoped_refptr<DevToolsAgentHost> agent_host1;
   scoped_refptr<DevToolsAgentHost> agent_host2;
 
@@ -195,64 +195,64 @@ TEST_F(SharedWorkerDevToolsManagerTest, AttachTest) {
   // Created -> GetDevToolsAgentHost -> Register -> Started -> Destroyed
   scoped_ptr<TestDevToolsClientHost> client_host1(new TestDevToolsClientHost());
   CheckWorkerNotExist(2, 1);
-  manager_->WorkerCreated(2, 1, instance1);
-  CheckWorkerState(2, 1, SharedWorkerDevToolsManager::WORKER_UNINSPECTED);
+  manager_->SharedWorkerCreated(2, 1, instance1);
+  CheckWorkerState(2, 1, EmbeddedWorkerDevToolsManager::WORKER_UNINSPECTED);
   agent_host1 = manager_->GetDevToolsAgentHostForWorker(2, 1);
   EXPECT_TRUE(agent_host1.get());
-  CheckWorkerState(2, 1, SharedWorkerDevToolsManager::WORKER_INSPECTED);
+  CheckWorkerState(2, 1, EmbeddedWorkerDevToolsManager::WORKER_INSPECTED);
   EXPECT_EQ(agent_host1.get(), manager_->GetDevToolsAgentHostForWorker(2, 1));
   RegisterDevToolsClientHostFor(agent_host1.get(), client_host1.get());
-  CheckWorkerState(2, 1, SharedWorkerDevToolsManager::WORKER_INSPECTED);
+  CheckWorkerState(2, 1, EmbeddedWorkerDevToolsManager::WORKER_INSPECTED);
   manager_->WorkerContextStarted(2, 1);
-  CheckWorkerState(2, 1, SharedWorkerDevToolsManager::WORKER_INSPECTED);
+  CheckWorkerState(2, 1, EmbeddedWorkerDevToolsManager::WORKER_INSPECTED);
   manager_->WorkerDestroyed(2, 1);
-  CheckWorkerState(2, 1, SharedWorkerDevToolsManager::WORKER_TERMINATED);
+  CheckWorkerState(2, 1, EmbeddedWorkerDevToolsManager::WORKER_TERMINATED);
   EXPECT_EQ(agent_host1.get(), manager_->GetDevToolsAgentHostForWorker(2, 1));
 
   // Created -> Started -> GetDevToolsAgentHost -> Register -> Destroyed
   scoped_ptr<TestDevToolsClientHost> client_host2(new TestDevToolsClientHost());
-  manager_->WorkerCreated(2, 2, instance2);
-  CheckWorkerState(2, 2, SharedWorkerDevToolsManager::WORKER_UNINSPECTED);
+  manager_->SharedWorkerCreated(2, 2, instance2);
+  CheckWorkerState(2, 2, EmbeddedWorkerDevToolsManager::WORKER_UNINSPECTED);
   manager_->WorkerContextStarted(2, 2);
-  CheckWorkerState(2, 2, SharedWorkerDevToolsManager::WORKER_UNINSPECTED);
+  CheckWorkerState(2, 2, EmbeddedWorkerDevToolsManager::WORKER_UNINSPECTED);
   agent_host2 = manager_->GetDevToolsAgentHostForWorker(2, 2);
   EXPECT_TRUE(agent_host2.get());
   EXPECT_NE(agent_host1.get(), agent_host2.get());
   EXPECT_EQ(agent_host2.get(), manager_->GetDevToolsAgentHostForWorker(2, 2));
-  CheckWorkerState(2, 2, SharedWorkerDevToolsManager::WORKER_INSPECTED);
+  CheckWorkerState(2, 2, EmbeddedWorkerDevToolsManager::WORKER_INSPECTED);
   RegisterDevToolsClientHostFor(agent_host2.get(), client_host2.get());
-  CheckWorkerState(2, 2, SharedWorkerDevToolsManager::WORKER_INSPECTED);
+  CheckWorkerState(2, 2, EmbeddedWorkerDevToolsManager::WORKER_INSPECTED);
   manager_->WorkerDestroyed(2, 2);
-  CheckWorkerState(2, 2, SharedWorkerDevToolsManager::WORKER_TERMINATED);
+  CheckWorkerState(2, 2, EmbeddedWorkerDevToolsManager::WORKER_TERMINATED);
   EXPECT_EQ(agent_host2.get(), manager_->GetDevToolsAgentHostForWorker(2, 2));
 
   // Re-created -> Started -> ClientHostClosing -> Destroyed
-  CheckWorkerState(2, 1, SharedWorkerDevToolsManager::WORKER_TERMINATED);
-  manager_->WorkerCreated(2, 3, instance1);
+  CheckWorkerState(2, 1, EmbeddedWorkerDevToolsManager::WORKER_TERMINATED);
+  manager_->SharedWorkerCreated(2, 3, instance1);
   CheckWorkerNotExist(2, 1);
-  CheckWorkerState(2, 3, SharedWorkerDevToolsManager::WORKER_PAUSED);
+  CheckWorkerState(2, 3, EmbeddedWorkerDevToolsManager::WORKER_PAUSED);
   EXPECT_EQ(agent_host1.get(), manager_->GetDevToolsAgentHostForWorker(2, 3));
   manager_->WorkerContextStarted(2, 3);
-  CheckWorkerState(2, 3, SharedWorkerDevToolsManager::WORKER_INSPECTED);
+  CheckWorkerState(2, 3, EmbeddedWorkerDevToolsManager::WORKER_INSPECTED);
   ClientHostClosing(client_host1.get());
   manager_->WorkerDestroyed(2, 3);
   CheckWorkerNotExist(2, 3);
   agent_host1 = NULL;
 
   // Re-created -> Destroyed
-  CheckWorkerState(2, 2, SharedWorkerDevToolsManager::WORKER_TERMINATED);
-  manager_->WorkerCreated(2, 4, instance2);
+  CheckWorkerState(2, 2, EmbeddedWorkerDevToolsManager::WORKER_TERMINATED);
+  manager_->SharedWorkerCreated(2, 4, instance2);
   CheckWorkerNotExist(2, 2);
-  CheckWorkerState(2, 4, SharedWorkerDevToolsManager::WORKER_PAUSED);
+  CheckWorkerState(2, 4, EmbeddedWorkerDevToolsManager::WORKER_PAUSED);
   EXPECT_EQ(agent_host2.get(), manager_->GetDevToolsAgentHostForWorker(2, 4));
   manager_->WorkerDestroyed(2, 4);
   CheckWorkerNotExist(2, 4);
-  CheckWorkerState(2, 2, SharedWorkerDevToolsManager::WORKER_TERMINATED);
+  CheckWorkerState(2, 2, EmbeddedWorkerDevToolsManager::WORKER_TERMINATED);
 
   // Re-created -> ClientHostClosing -> Destroyed
-  manager_->WorkerCreated(2, 5, instance2);
+  manager_->SharedWorkerCreated(2, 5, instance2);
   CheckWorkerNotExist(2, 2);
-  CheckWorkerState(2, 5, SharedWorkerDevToolsManager::WORKER_PAUSED);
+  CheckWorkerState(2, 5, EmbeddedWorkerDevToolsManager::WORKER_PAUSED);
   EXPECT_EQ(agent_host2.get(), manager_->GetDevToolsAgentHostForWorker(2, 5));
   ClientHostClosing(client_host2.get());
   CheckWorkerCount(1);
diff --git a/content/browser/devtools/worker_devtools_manager.cc b/content/browser/devtools/worker_devtools_manager.cc
index a05a04a..0658c35 100644
--- a/content/browser/devtools/worker_devtools_manager.cc
+++ b/content/browser/devtools/worker_devtools_manager.cc
@@ -12,8 +12,8 @@
 #include "content/browser/devtools/devtools_manager_impl.h"
 #include "content/browser/devtools/devtools_protocol.h"
 #include "content/browser/devtools/devtools_protocol_constants.h"
+#include "content/browser/devtools/embedded_worker_devtools_manager.h"
 #include "content/browser/devtools/ipc_devtools_agent_host.h"
-#include "content/browser/devtools/shared_worker_devtools_manager.h"
 #include "content/browser/devtools/worker_devtools_message_filter.h"
 #include "content/browser/worker_host/worker_service_impl.h"
 #include "content/common/devtools_messages.h"
@@ -29,7 +29,7 @@ scoped_refptr<DevToolsAgentHost> DevToolsAgentHost::GetForWorker(
     int worker_process_id,
     int worker_route_id) {
   if (WorkerService::EmbeddedSharedWorkerEnabled()) {
-    return SharedWorkerDevToolsManager::GetInstance()
+    return EmbeddedWorkerDevToolsManager::GetInstance()
         ->GetDevToolsAgentHostForWorker(worker_process_id, worker_route_id);
   } else {
     return WorkerDevToolsManager::GetDevToolsAgentHostForWorker(
diff --git a/content/browser/shared_worker/shared_worker_host.cc b/content/browser/shared_worker/shared_worker_host.cc
index 18936f3..6f6e4207 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/shared_worker_devtools_manager.h"
+#include "content/browser/devtools/embedded_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_service.h"
@@ -33,14 +33,14 @@ void WorkerCrashCallback(int render_process_unique_id, int render_frame_id) {
 
 void NotifyWorkerScriptLoadedOnUI(int worker_process_id, int worker_route_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  SharedWorkerDevToolsManager::GetInstance()->WorkerContextStarted(
+  EmbeddedWorkerDevToolsManager::GetInstance()->WorkerContextStarted(
       worker_process_id, worker_route_id);
 }
 
 void NotifyWorkerDestroyedOnUI(int worker_process_id, int worker_route_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  SharedWorkerDevToolsManager::GetInstance()->WorkerDestroyed(worker_process_id,
-                                                              worker_route_id);
+  EmbeddedWorkerDevToolsManager::GetInstance()->WorkerDestroyed(
+      worker_process_id, worker_route_id);
 }
 
 }  // namespace
diff --git a/content/browser/shared_worker/shared_worker_instance.h b/content/browser/shared_worker/shared_worker_instance.h
index e68c9a4..2785c40 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 SharedWorkerDevToolsManager.
+// the UI thread and be used for comparison in EmbeddedWorkerDevToolsManager.
 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 aa97e44..4a689fa 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/shared_worker_devtools_manager.h"
+#include "content/browser/devtools/embedded_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"
@@ -193,7 +193,7 @@ class SharedWorkerServiceImpl::SharedWorkerReserver
     bool pause_on_start = false;
     if (is_new_worker_) {
       pause_on_start =
-          SharedWorkerDevToolsManager::GetInstance()->WorkerCreated(
+          EmbeddedWorkerDevToolsManager::GetInstance()->SharedWorkerCreated(
               worker_process_id_, worker_route_id_, instance_);
     }
     BrowserThread::PostTask(
diff --git a/content/content_browser.gypi b/content/content_browser.gypi
index f6e67b7..58e8d48 100644
--- a/content/content_browser.gypi
+++ b/content/content_browser.gypi
@@ -408,12 +408,12 @@
     'browser/devtools/devtools_tracing_handler.cc',
     'browser/devtools/ipc_devtools_agent_host.cc',
     'browser/devtools/ipc_devtools_agent_host.h',
+    'browser/devtools/embedded_worker_devtools_manager.cc',
+    'browser/devtools/embedded_worker_devtools_manager.h',
     'browser/devtools/render_view_devtools_agent_host.cc',
     'browser/devtools/render_view_devtools_agent_host.h',
     'browser/devtools/renderer_overrides_handler.cc',
     'browser/devtools/renderer_overrides_handler.h',
-    'browser/devtools/shared_worker_devtools_manager.cc',
-    'browser/devtools/shared_worker_devtools_manager.h',
     'browser/devtools/tethering_handler.h',
     'browser/devtools/tethering_handler.cc',
     'browser/devtools/worker_devtools_manager.cc',
diff --git a/content/content_tests.gypi b/content/content_tests.gypi
index 66d6679..0d75120 100644
--- a/content/content_tests.gypi
+++ b/content/content_tests.gypi
@@ -396,9 +396,9 @@
         'browser/database_tracker_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',