DevTools: remove the WorkerDevToolsManager base - implementations are diverging.

BUG=463892

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

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

content/browser/devtools/devtools_agent_host_impl.cc

@@ -43,6 +43,21 @@ DevToolsAgentHost::List DevToolsAgentHost::GetOrCreateAll() {
   return result;
 }
 
+// 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::DevToolsAgentHostImpl()
     : id_(base::GenerateGUID()),
       client_(NULL) {

content/browser/devtools/protocol/service_worker_handler.cc

@@ -4,7 +4,6 @@
 
 #include "content/browser/devtools/protocol/service_worker_handler.h"
 
-#include "content/browser/devtools/service_worker_devtools_manager.h"
 #include "content/public/browser/devtools_agent_host.h"
 
 namespace content {

content/browser/devtools/protocol/service_worker_handler.h

@@ -8,7 +8,7 @@
 #include <set>
 
 #include "content/browser/devtools/protocol/devtools_protocol_handler.h"
-#include "content/browser/devtools/worker_devtools_manager.h"
+#include "content/browser/devtools/service_worker_devtools_manager.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_agent_host_client.h"
 
@@ -17,7 +17,7 @@ namespace devtools {
 namespace service_worker {
 
 class ServiceWorkerHandler : public DevToolsAgentHostClient,
-                             public WorkerDevToolsManager::Observer {
+                             public ServiceWorkerDevToolsManager::Observer {
  public:
   typedef DevToolsProtocolClient::Response Response;
 

content/browser/devtools/service_worker_devtools_manager.cc

@@ -7,8 +7,6 @@
 #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/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/worker_service.h"
@@ -50,6 +48,23 @@ ServiceWorkerDevToolsManager* ServiceWorkerDevToolsManager::GetInstance() {
   return Singleton<ServiceWorkerDevToolsManager>::get();
 }
 
+DevToolsAgentHostImpl*
+ServiceWorkerDevToolsManager::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 ServiceWorkerDevToolsManager::AddAllAgentHosts(
+    DevToolsAgentHost::List* result) {
+  for (auto& worker : workers_) {
+    if (!worker.second->IsTerminated())
+      result->push_back(worker.second);
+  }
+}
+
 bool ServiceWorkerDevToolsManager::WorkerCreated(
     int worker_process_id,
     int worker_route_id,
@@ -57,16 +72,35 @@ bool ServiceWorkerDevToolsManager::WorkerCreated(
   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()) {
-    WorkerDevToolsManager::WorkerCreated(id,
-        new ServiceWorkerDevToolsAgentHost(id, service_worker_id,
-                                           debug_service_worker_on_start_));
+  if (it == workers_.end()) {
+    workers_[id] = new ServiceWorkerDevToolsAgentHost(
+        id, service_worker_id, debug_service_worker_on_start_);
+    scoped_refptr<WorkerDevToolsAgentHost> protector(workers_[id]);
+    FOR_EACH_OBSERVER(Observer, observer_list_,
+                      WorkerCreated(protector.get()));
+    DevToolsManager::GetInstance()->AgentHostChanged(protector.get());
     return debug_service_worker_on_start_;
   }
-  WorkerRestarted(id, it);
+
+  // Worker was restarted.
+  ServiceWorkerDevToolsAgentHost* agent_host = it->second;
+  agent_host->WorkerRestarted(id);
+  workers_.erase(it);
+  workers_[id] = agent_host;
+  DevToolsManager::GetInstance()->AgentHostChanged(agent_host);
+
   return it->second->IsAttached();
 }
 
+void ServiceWorkerDevToolsManager::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 ServiceWorkerDevToolsManager::WorkerStopIgnored(int worker_process_id,
                                                       int worker_route_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ -74,6 +108,31 @@ void ServiceWorkerDevToolsManager::WorkerStopIgnored(int worker_process_id,
   // terminate the worker because devtools is attached.
 }
 
+void ServiceWorkerDevToolsManager::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);
+  FOR_EACH_OBSERVER(Observer, observer_list_, WorkerDestroyed(it->second));
+  agent_host->WorkerDestroyed();
+  DevToolsManager::GetInstance()->AgentHostChanged(agent_host);
+}
+
+void ServiceWorkerDevToolsManager::RemoveInspectedWorkerData(WorkerId id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  workers_.erase(id);
+}
+
+void ServiceWorkerDevToolsManager::AddObserver(Observer* observer) {
+  observer_list_.AddObserver(observer);
+}
+
+void ServiceWorkerDevToolsManager::RemoveObserver(Observer* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
 ServiceWorkerDevToolsManager::ServiceWorkerDevToolsManager()
     : debug_service_worker_on_start_(false) {
 }
@@ -84,8 +143,8 @@ ServiceWorkerDevToolsManager::~ServiceWorkerDevToolsManager() {
 ServiceWorkerDevToolsManager::AgentHostMap::iterator
 ServiceWorkerDevToolsManager::FindExistingWorkerAgentHost(
     const ServiceWorkerIdentifier& service_worker_id) {
-  AgentHostMap::iterator it = workers().begin();
-  for (; it != workers().end(); ++it) {
+  AgentHostMap::iterator it = workers_.begin();
+  for (; it != workers_.end(); ++it) {
     if (static_cast<ServiceWorkerDevToolsAgentHost*>(
             it->second)->Matches(service_worker_id))
       break;
@@ -93,4 +152,8 @@ ServiceWorkerDevToolsManager::FindExistingWorkerAgentHost(
   return it;
 }
 
+void ServiceWorkerDevToolsManager::ResetForTesting() {
+  workers_.clear();
+}
+
 }  // namespace content

content/browser/devtools/service_worker_devtools_manager.h

@@ -10,19 +10,30 @@
 #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"
+#include "base/observer_list.h"
+#include "content/public/browser/devtools_agent_host.h"
 
 namespace content {
 
+class DevToolsAgentHostImpl;
 class ServiceWorkerDevToolsAgentHost;
 class ServiceWorkerContextCore;
 
 // Manages WorkerDevToolsAgentHost's for Service Workers.
 // This class lives on UI thread.
-class CONTENT_EXPORT ServiceWorkerDevToolsManager
-    : public WorkerDevToolsManager {
+class CONTENT_EXPORT ServiceWorkerDevToolsManager {
  public:
+  typedef std::pair<int, int> WorkerId;
+
+  class Observer {
+   public:
+    virtual void WorkerCreated(DevToolsAgentHost* host) {}
+    virtual void WorkerDestroyed(DevToolsAgentHost* host) {}
+
+   protected:
+    virtual ~Observer() {}
+  };
+
   class ServiceWorkerIdentifier {
    public:
     ServiceWorkerIdentifier(
@@ -52,13 +63,23 @@ class CONTENT_EXPORT ServiceWorkerDevToolsManager
   // Returns the ServiceWorkerDevToolsManager singleton.
   static ServiceWorkerDevToolsManager* GetInstance();
 
+  DevToolsAgentHostImpl* GetDevToolsAgentHostForWorker(int worker_process_id,
+                                                       int worker_route_id);
+  void AddAllAgentHosts(DevToolsAgentHost::List* result);
+
   // 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 WorkerReadyForInspection(int worker_process_id, int worker_route_id);
   void WorkerStopIgnored(int worker_process_id, int worker_route_id);
+  void WorkerDestroyed(int worker_process_id, int worker_route_id);
+  void RemoveInspectedWorkerData(WorkerId id);
+
+  void AddObserver(Observer* observer);
+  void RemoveObserver(Observer* observer);
 
   void set_debug_service_worker_on_start(bool debug_on_start) {
     debug_service_worker_on_start_ = debug_on_start;
@@ -71,12 +92,19 @@ class CONTENT_EXPORT ServiceWorkerDevToolsManager
   friend struct DefaultSingletonTraits<ServiceWorkerDevToolsManager>;
   friend class ServiceWorkerDevToolsAgentHost;
 
+  using AgentHostMap = std::map<WorkerId, ServiceWorkerDevToolsAgentHost*>;
+
   ServiceWorkerDevToolsManager();
-  ~ServiceWorkerDevToolsManager() override;
+  ~ServiceWorkerDevToolsManager();
 
   AgentHostMap::iterator FindExistingWorkerAgentHost(
       const ServiceWorkerIdentifier& service_worker_id);
 
+  // Resets to its initial state as if newly created.
+  void ResetForTesting();
+
+  ObserverList<Observer> observer_list_;
+  AgentHostMap workers_;
   bool debug_service_worker_on_start_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerDevToolsManager);

content/browser/devtools/shared_worker_devtools_manager.cc

@@ -17,39 +17,92 @@ SharedWorkerDevToolsManager* SharedWorkerDevToolsManager::GetInstance() {
   return Singleton<SharedWorkerDevToolsManager>::get();
 }
 
+DevToolsAgentHostImpl*
+SharedWorkerDevToolsManager::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 SharedWorkerDevToolsManager::AddAllAgentHosts(
+    DevToolsAgentHost::List* result) {
+  for (auto& worker : workers_) {
+    if (!worker.second->IsTerminated())
+      result->push_back(worker.second);
+  }
+}
+
 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()) {
-    WorkerDevToolsManager::WorkerCreated(
-        id,
-        new SharedWorkerDevToolsAgentHost(id, instance));
+  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);
+
+  // Worker restarted.
+  SharedWorkerDevToolsAgentHost* agent_host = it->second;
+  agent_host->WorkerRestarted(id);
+  workers_.erase(it);
+  workers_[id] = agent_host;
+  DevToolsManager::GetInstance()->AgentHostChanged(agent_host);
   return true;
 }
 
+void SharedWorkerDevToolsManager::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 SharedWorkerDevToolsManager::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<SharedWorkerDevToolsAgentHost> agent_host(it->second);
+  agent_host->WorkerDestroyed();
+  DevToolsManager::GetInstance()->AgentHostChanged(agent_host);
+}
+
+void SharedWorkerDevToolsManager::RemoveInspectedWorkerData(WorkerId id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  workers_.erase(id);
+}
+SharedWorkerDevToolsManager::SharedWorkerDevToolsManager() {
+}
+
+SharedWorkerDevToolsManager::~SharedWorkerDevToolsManager() {
+}
+
 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))
+  AgentHostMap::iterator it = workers_.begin();
+  for (; it != workers_.end(); ++it) {
+    if (it->second->Matches(instance))
       break;
   }
   return it;
 }
 
-SharedWorkerDevToolsManager::SharedWorkerDevToolsManager() {
+void SharedWorkerDevToolsManager::ResetForTesting() {
+  workers_.clear();
 }
 
-SharedWorkerDevToolsManager::~SharedWorkerDevToolsManager() {
-}
 
 }  // namespace content

content/browser/devtools/shared_worker_devtools_manager.h

@@ -5,29 +5,40 @@
 #ifndef CONTENT_BROWSER_DEVTOOLS_SHARED_WORKER_DEVTOOLS_MANAGER_H_
 #define CONTENT_BROWSER_DEVTOOLS_SHARED_WORKER_DEVTOOLS_MANAGER_H_
 
+#include <map>
+
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/singleton.h"
-#include "content/browser/devtools/worker_devtools_manager.h"
+#include "content/public/browser/devtools_agent_host.h"
 
 namespace content {
 
+class DevToolsAgentHostImpl;
 class SharedWorkerDevToolsAgentHost;
 class SharedWorkerInstance;
 
 // Manages WorkerDevToolsAgentHost's for Shared Workers.
 // This class lives on UI thread.
-class CONTENT_EXPORT SharedWorkerDevToolsManager
-    : public WorkerDevToolsManager {
+class CONTENT_EXPORT SharedWorkerDevToolsManager {
  public:
+  typedef std::pair<int, int> WorkerId;
+
   // Returns the SharedWorkerDevToolsManager singleton.
   static SharedWorkerDevToolsManager* GetInstance();
 
+  DevToolsAgentHostImpl* GetDevToolsAgentHostForWorker(int worker_process_id,
+                                                       int worker_route_id);
+  void AddAllAgentHosts(DevToolsAgentHost::List* result);
+
   // 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);
+  void WorkerReadyForInspection(int worker_process_id, int worker_route_id);
+  void WorkerDestroyed(int worker_process_id, int worker_route_id);
+  void RemoveInspectedWorkerData(WorkerId id);
 
  private:
   friend struct DefaultSingletonTraits<SharedWorkerDevToolsManager>;
@@ -36,12 +47,18 @@ class CONTENT_EXPORT SharedWorkerDevToolsManager
   FRIEND_TEST_ALL_PREFIXES(SharedWorkerDevToolsManagerTest, BasicTest);
   FRIEND_TEST_ALL_PREFIXES(SharedWorkerDevToolsManagerTest, AttachTest);
 
+  using AgentHostMap = std::map<WorkerId, SharedWorkerDevToolsAgentHost*>;
+
   SharedWorkerDevToolsManager();
-  ~SharedWorkerDevToolsManager() override;
+  ~SharedWorkerDevToolsManager();
 
   AgentHostMap::iterator FindExistingWorkerAgentHost(
       const SharedWorkerInstance& instance);
 
+  // Resets to its initial state as if newly created.
+  void ResetForTesting();
+
+  AgentHostMap workers_;
   DISALLOW_COPY_AND_ASSIGN(SharedWorkerDevToolsManager);
 };
 

content/browser/devtools/shared_worker_devtools_manager_unittest.cc

@@ -71,7 +71,7 @@ class SharedWorkerDevToolsManagerTest : public testing::Test {
     const SharedWorkerDevToolsManager::WorkerId id(worker_process_id,
                                                      worker_route_id);
     SharedWorkerDevToolsManager::AgentHostMap::iterator it =
-        manager_->workers().find(id);
+        manager_->workers_.find(id);
     EXPECT_TRUE(manager_->workers_.end() != it);
     EXPECT_EQ(state, it->second->state_);
   }

content/browser/devtools/worker_devtools_agent_host.h

@@ -6,7 +6,6 @@
 #define CONTENT_BROWSER_DEVTOOLS_WORKER_DEVTOOLS_AGENT_HOST_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 {
@@ -17,7 +16,7 @@ class SharedWorkerInstance;
 class WorkerDevToolsAgentHost : public IPCDevToolsAgentHost,
                                 public IPC::Listener {
  public:
-  typedef WorkerDevToolsManager::WorkerId WorkerId;
+  typedef std::pair<int, int> WorkerId;
 
   // DevToolsAgentHost override.
   bool IsWorker() const override;

content/browser/devtools/worker_devtools_manager.cc

-// 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);
-  FOR_EACH_OBSERVER(Observer, observer_list_, WorkerDestroyed(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();
-}
-
-void WorkerDevToolsManager::AddObserver(Observer* observer) {
-  observer_list_.AddObserver(observer);
-}
-
-void WorkerDevToolsManager::RemoveObserver(Observer* observer) {
-  observer_list_.RemoveObserver(observer);
-}
-
-WorkerDevToolsManager::WorkerDevToolsManager() {
-}
-
-WorkerDevToolsManager::~WorkerDevToolsManager() {
-}
-
-void WorkerDevToolsManager::RemoveInspectedWorkerData(WorkerId id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  workers_.erase(id);
-}
-
-void WorkerDevToolsManager::WorkerCreated(
-    const WorkerId& id,
-    WorkerDevToolsAgentHost* host) {
-  workers_[id] = host;
-  DevToolsManager::GetInstance()->AgentHostChanged(host);
-  scoped_refptr<WorkerDevToolsAgentHost> protector(host);
-  FOR_EACH_OBSERVER(Observer, observer_list_, WorkerCreated(host));
-}
-
-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);
-}
-
-void WorkerDevToolsManager::ResetForTesting() {
-  workers_.clear();
-}
-
-}  // namespace content

content/browser/devtools/worker_devtools_manager.h

-// 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 "base/observer_list.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;
-
-  class Observer {
-   public:
-    virtual void WorkerCreated(DevToolsAgentHost* host) {}
-    virtual void WorkerDestroyed(DevToolsAgentHost* host) {}
-
-   protected:
-    virtual ~Observer() {}
-  };
-
-  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);
-
-  void AddObserver(Observer* observer);
-  void RemoveObserver(Observer* observer);
-
- protected:
-  using AgentHostMap = std::map<WorkerId, WorkerDevToolsAgentHost*>;
-  friend class SharedWorkerDevToolsManagerTest;
-
-  WorkerDevToolsManager();
-  virtual ~WorkerDevToolsManager();
-  void RemoveInspectedWorkerData(WorkerId id);
-  void WorkerCreated(const WorkerId& id,
-                     WorkerDevToolsAgentHost* host);
-  void WorkerRestarted(const WorkerId& id, const AgentHostMap::iterator& it);
-  AgentHostMap& workers() { return workers_; }
-
- private:
-  // Resets to its initial state as if newly created.
-  void ResetForTesting();
-
-  ObserverList<Observer> observer_list_;
-  AgentHostMap workers_;
-  DISALLOW_COPY_AND_ASSIGN(WorkerDevToolsManager);
-};
-
-}  // namespace content
-
-#endif  // CONTENT_BROWSER_DEVTOOLS_WORKER_DEVTOOLS_MANAGER_H_

content/content_browser.gypi

@@ -545,8 +545,6 @@
       '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/dom_storage/dom_storage_area.cc',
       'browser/dom_storage/dom_storage_area.h',
       'browser/dom_storage/dom_storage_context_impl.cc',