Define DevTools content API

content/browser/debugger/devtools_http_protocol_handler.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/devtools_http_protocol_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
-#include "content/browser/debugger/devtools_client_host.h"
-#include "content/browser/debugger/devtools_manager.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_observer.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/devtools_client_host.h"
+#include "content/public/browser/devtools_manager.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/escape.h"
 #include "net/base/io_buffer.h"
 #include "net/server/http_server_request_info.h"
 #include "net/url_request/url_request_context.h"
 
 using content::BrowserThread;
+using content::DevToolsAgentHost;
+using content::DevToolsAgentHostRegistry;
+using content::DevToolsClientHost;
+using content::DevToolsManager;
 
 const int kBufferSize = 16 * 1024;
 
 namespace {
 
 // An internal implementation of DevToolsClientHost that delegates
 // messages sent for DevToolsClient to a DebuggerShell instance.
 class DevToolsClientHostImpl : public DevToolsClientHost {
  public:
   DevToolsClientHostImpl(
       net::HttpServer* server,
       int connection_id)
       : server_(server),
         connection_id_(connection_id) {
   }
   ~DevToolsClientHostImpl() {}
 
   // DevToolsClientHost interface
   virtual void InspectedTabClosing() {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&net::HttpServer::Close, server_, connection_id_));
   }
 
-  virtual void SendMessageToClient(const IPC::Message& msg) {
-    IPC_BEGIN_MESSAGE_MAP(DevToolsClientHostImpl, msg)
-      IPC_MESSAGE_HANDLER(DevToolsClientMsg_DispatchOnInspectorFrontend,
-                          OnDispatchOnInspectorFrontend);
-      IPC_MESSAGE_UNHANDLED_ERROR()
-    IPC_END_MESSAGE_MAP()
-  }
-
-  virtual void TabReplaced(TabContents* new_tab) {
-  }
-
-  void NotifyCloseListener() {
-    DevToolsClientHost::NotifyCloseListener();
-  }
- private:
-  // Message handling routines
-  void OnDispatchOnInspectorFrontend(const std::string& data) {
+  virtual void DispatchOnInspectorFrontend(const std::string& data) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&net::HttpServer::SendOverWebSocket,
                    server_,
                    connection_id_,
                    data));
   }
 
+  virtual void TabReplaced(TabContents* new_tab) {
+  }
+
+ private:
   virtual void FrameNavigating(const std::string& url) {}
   net::HttpServer* server_;
   int connection_id_;
 };
 
 static int next_id = 1;
 
 class TabContentsIDHelper : public TabContentsObserver {
  public:
 
@@ skipping 196 matching lines @@
   for (Tabs::iterator it = inspectable_tabs.begin();
        it != inspectable_tabs.end(); ++it) {
 
     TabContents* tab_contents = *it;
     NavigationController& controller = tab_contents->controller();
 
     NavigationEntry* entry = controller.GetActiveEntry();
     if (entry == NULL || !entry->url().is_valid())
       continue;
 
+    DevToolsAgentHost* agent = DevToolsAgentHostRegistry::GetDevToolsAgentHost(
+        tab_contents->render_view_host());
     DevToolsClientHost* client_host = DevToolsManager::GetInstance()->
-        GetDevToolsClientHostFor(tab_contents->render_view_host());
+        GetDevToolsClientHostFor(agent);
     PageInfo page_info;
     page_info.id = TabContentsIDHelper::GetID(tab_contents);
     page_info.attached = client_host != NULL;
     page_info.url = entry->url().spec();
     page_info.title = UTF16ToUTF8(net::EscapeForHTML(entry->title()));
     page_info.thumbnail_url = "/thumb/" + entry->url().spec();
     page_info.favicon_url = entry->favicon().url().spec();
     page_list.push_back(page_info);
   }
   return page_list;
@@ skipping 49 matching lines @@
     return;
   }
 
   TabContents* tab_contents = TabContentsIDHelper::GetTabContents(id);
   if (tab_contents == NULL) {
     Send500(connection_id, "No such page id: " + page_id);
     return;
   }
 
   DevToolsManager* manager = DevToolsManager::GetInstance();
-  if (manager->GetDevToolsClientHostFor(tab_contents->render_view_host())) {
+  DevToolsAgentHost* agent = DevToolsAgentHostRegistry::GetDevToolsAgentHost(
+      tab_contents->render_view_host());
+  if (manager->GetDevToolsClientHostFor(agent)) {
     Send500(connection_id, "Page with given id is being inspected: " + page_id);
     return;
   }
 
   DevToolsClientHostImpl* client_host =
       new DevToolsClientHostImpl(server_, connection_id);
   connection_to_client_host_ui_[connection_id] = client_host;
 
-  manager->RegisterDevToolsClientHostFor(
-      tab_contents->render_view_host(),
-      client_host);
+  manager->RegisterDevToolsClientHostFor(agent, client_host);
 
   AcceptWebSocket(connection_id, request);
 }
 
 void DevToolsHttpProtocolHandler::OnWebSocketMessageUI(
     int connection_id,
     const std::string& data) {
   ConnectionToClientHostMap::iterator it =
       connection_to_client_host_ui_.find(connection_id);
   if (it == connection_to_client_host_ui_.end())
     return;
 
   DevToolsManager* manager = DevToolsManager::GetInstance();
-  manager->ForwardToDevToolsAgent(
-      it->second,
-      DevToolsAgentMsg_DispatchOnInspectorBackend(MSG_ROUTING_NONE, data));
+  manager->DispatchOnInspectorBackend(it->second, data);
 }
 
 void DevToolsHttpProtocolHandler::OnCloseUI(int connection_id) {
   ConnectionToClientHostMap::iterator it =
       connection_to_client_host_ui_.find(connection_id);
   if (it != connection_to_client_host_ui_.end()) {
     DevToolsClientHostImpl* client_host =
         static_cast<DevToolsClientHostImpl*>(it->second);
-    client_host->NotifyCloseListener();
+    DevToolsManager::GetInstance()->ClientHostClosing(client_host);
     delete client_host;
     connection_to_client_host_ui_.erase(connection_id);
   }
 }
 
 void DevToolsHttpProtocolHandler::OnResponseStarted(net::URLRequest* request) {
   RequestToSocketMap::iterator it = request_to_connection_io_.find(request);
   if (it == request_to_connection_io_.end())
     return;
 
@@ skipping 128 matching lines @@
 }
 
 void DevToolsHttpProtocolHandler::AcceptWebSocket(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&net::HttpServer::AcceptWebSocket, server_.get(),
                  connection_id, request));
 }