Define DevTools content API

content/browser/debugger/worker_devtools_manager.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/debugger/worker_devtools_manager.h"
 
 #include <list>
 #include <map>
 
 #include "base/bind.h"
 #include "content/browser/debugger/devtools_agent_host.h"
-#include "content/browser/debugger/devtools_manager.h"
+#include "content/browser/debugger/devtools_manager_impl.h"
 #include "content/browser/debugger/worker_devtools_message_filter.h"
 #include "content/browser/worker_host/worker_process_host.h"
 #include "content/browser/worker_host/worker_service.h"
 #include "content/common/devtools_messages.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/devtools_agent_host_registry.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDevToolsAgent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 
 using content::BrowserThread;
 
+namespace content {
+
+// Called on the UI thread.
+// static
+DevToolsAgentHost* DevToolsAgentHostRegistry::GetDevToolsAgentHostForWorker(
+    int worker_process_id,
+    int worker_route_id) {
+  return WorkerDevToolsManager::GetDevToolsAgentHostForWorker(
+      worker_process_id,
+      worker_route_id);
+}
+
 class WorkerDevToolsManager::AgentHosts
     : private content::NotificationObserver {
 public:
   static void Add(WorkerId id, WorkerDevToolsAgentHost* host) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!instance_)
       instance_ = new AgentHosts();
     instance_->map_[id] = host;
   }
   static void Remove(WorkerId id) {
@@ skipping 119 matching lines @@
     RemovePendingWorkerData(old_id);
   }
 
   static void WorkerDestroyed(WorkerId id) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     WorkerDevToolsAgentHost* agent = AgentHosts::GetAgentHost(id);
     if (!agent) {
       RemovePendingWorkerData(id);
       return;
     }
-    DevToolsManager::GetInstance()->ForwardToDevToolsClient(agent,
-        DevToolsClientMsg_DispatchOnInspectorFrontend(MSG_ROUTING_NONE,
-            WebKit::WebDevToolsAgent::disconnectEventAsText().utf8()));
-    int cookie = DevToolsManager::GetInstance()->DetachClientHost(agent);
+    DevToolsManagerImpl::GetInstance()->DispatchOnInspectorFrontend(
+        agent,
+        WebKit::WebDevToolsAgent::disconnectEventAsText().utf8());
+    int cookie = DevToolsManagerImpl::GetInstance()->DetachClientHost(agent);
     if (cookie == -1) {
       RemovePendingWorkerData(id);
       return;
     }
     if (!instance_)
       new DetachedClientHosts();
     instance_->worker_id_to_cookie_[id] = cookie;
   }
 
  private:
   DetachedClientHosts() {
     instance_ = this;
   }
   ~DetachedClientHosts() {
     instance_ = NULL;
   }
 
   bool ReattachClient(WorkerId old_id, WorkerId new_id) {
     WorkerIdToCookieMap::iterator it = worker_id_to_cookie_.find(old_id);
     if (it == worker_id_to_cookie_.end())
       return false;
     DevToolsAgentHost* agent =
         WorkerDevToolsManager::GetDevToolsAgentHostForWorker(
             new_id.first,
             new_id.second);
-    DevToolsManager::GetInstance()->AttachClientHost(
+    DevToolsManagerImpl::GetInstance()->AttachClientHost(
         it->second,
         agent);
     worker_id_to_cookie_.erase(it);
     if (worker_id_to_cookie_.empty())
       delete this;
     return true;
   }
 
   static void RemovePendingWorkerData(WorkerId id) {
     BrowserThread::PostTask(
@@ skipping 171 matching lines @@
         return;
       }
     }
   }
   NotifyWorkerDestroyedOnIOThread(worker_process_id, worker_route_id);
 }
 
 void WorkerDevToolsManager::ForwardToDevToolsClient(
     int worker_process_id,
     int worker_route_id,
-    const IPC::Message& message) {
+    const std::string& message) {
   if (FindInspectedWorker(worker_process_id, worker_route_id) ==
           inspected_workers_.end()) {
       NOTREACHED();
       return;
   }
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &ForwardToDevToolsClientOnUIThread,
           worker_process_id,
@@ skipping 24 matching lines @@
     return;
   IPC::Message* msg = new IPC::Message(message);
   msg->set_routing_id(worker_route_id);
   it->host->Send(msg);
 }
 
 // static
 void WorkerDevToolsManager::ForwardToDevToolsClientOnUIThread(
     int worker_process_id,
     int worker_route_id,
-    const IPC::Message& message) {
+    const std::string& message) {
   WorkerDevToolsAgentHost* agent_host = AgentHosts::GetAgentHost(WorkerId(
       worker_process_id,
       worker_route_id));
   if (!agent_host)
     return;
-  DevToolsManager::GetInstance()->ForwardToDevToolsClient(agent_host, message);
+  DevToolsManagerImpl::GetInstance()->DispatchOnInspectorFrontend(agent_host,
+                                                                  message);
 }
 
 // static
 void WorkerDevToolsManager::SaveAgentRuntimeStateOnUIThread(
     int worker_process_id,
     int worker_route_id,
     const std::string& state) {
   WorkerDevToolsAgentHost* agent_host = AgentHosts::GetAgentHost(WorkerId(
       worker_process_id,
       worker_route_id));
   if (!agent_host)
     return;
-  DevToolsManager::GetInstance()->SaveAgentRuntimeState(agent_host, state);
+  DevToolsManagerImpl::GetInstance()->SaveAgentRuntimeState(agent_host, state);
 }
 
 // static
 void WorkerDevToolsManager::NotifyWorkerDestroyedOnIOThread(
     int worker_process_id,
     int worker_route_id) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &WorkerDevToolsManager::NotifyWorkerDestroyedOnUIThread,
           worker_process_id,
           worker_route_id));
 }
 
 // static
 void WorkerDevToolsManager::NotifyWorkerDestroyedOnUIThread(
     int worker_process_id,
     int worker_route_id) {
   WorkerDevToolsAgentHost* host =
       AgentHosts::GetAgentHost(WorkerId(worker_process_id, worker_route_id));
   if (host)
     host->WorkerDestroyed();
 }
 
 // static
 void WorkerDevToolsManager::SendResumeToWorker(const WorkerId& id) {
   if (WorkerProcessHost* process = FindWorkerProcess(id.first))
     process->Send(new DevToolsAgentMsg_ResumeWorkerContext(id.second));
 }
+
+}  // namespace