Revert of [DevTools] Make DevTools clients talk directly to DevToolsAgentHost instead of using DevToolsManage…

content/browser/devtools/devtools_http_handler_impl.cc

 // Copyright (c) 2012 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/devtools_http_handler_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
 #include "content/browser/devtools/devtools_browser_target.h"
 #include "content/browser/devtools/devtools_protocol.h"
 #include "content/browser/devtools/devtools_protocol_constants.h"
 #include "content/browser/devtools/devtools_system_info_handler.h"
 #include "content/browser/devtools/devtools_tracing_handler.h"
 #include "content/browser/devtools/tethering_handler.h"
 #include "content/common/devtools_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
+#include "content/public/browser/devtools_client_host.h"
 #include "content/public/browser/devtools_http_handler_delegate.h"
+#include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/devtools_target.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/user_agent.h"
 #include "content/public/common/user_agent.h"
 #include "grit/devtools_resources_map.h"
 #include "net/base/escape.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
@@ skipping 20 matching lines @@
 const char kTargetParentIdField[] = "parentId";
 const char kTargetTypeField[] = "type";
 const char kTargetTitleField[] = "title";
 const char kTargetDescriptionField[] = "description";
 const char kTargetUrlField[] = "url";
 const char kTargetThumbnailUrlField[] = "thumbnailUrl";
 const char kTargetFaviconUrlField[] = "faviconUrl";
 const char kTargetWebSocketDebuggerUrlField[] = "webSocketDebuggerUrl";
 const char kTargetDevtoolsFrontendUrlField[] = "devtoolsFrontendUrl";
 
-// An internal implementation of DevToolsAgentHostClient that delegates
-// messages sent to a DebuggerShell instance.
-class DevToolsAgentHostClientImpl : public DevToolsAgentHostClient {
+// An internal implementation of DevToolsClientHost that delegates
+// messages sent for DevToolsClient to a DebuggerShell instance.
+class DevToolsClientHostImpl : public DevToolsClientHost {
  public:
-  DevToolsAgentHostClientImpl(base::MessageLoop* message_loop,
-                              net::HttpServer* server,
-                              int connection_id,
-                              DevToolsAgentHost* agent_host)
+  DevToolsClientHostImpl(base::MessageLoop* message_loop,
+                         net::HttpServer* server,
+                         int connection_id)
       : message_loop_(message_loop),
         server_(server),
         connection_id_(connection_id),
-        agent_host_(agent_host) {
-    agent_host_->AttachClient(this);
-  }
+        is_closed_(false),
+        detach_reason_("target_closed") {}
 
-  virtual ~DevToolsAgentHostClientImpl() {
-    if (agent_host_)
-      agent_host_->DetachClient();
-  }
+  virtual ~DevToolsClientHostImpl() {}
 
-  virtual void AgentHostClosed(
-      DevToolsAgentHost* agent_host,
-      bool replaced_with_another_client) OVERRIDE {
-    DCHECK(agent_host == agent_host_.get());
-    agent_host_ = NULL;
+  // DevToolsClientHost interface
+  virtual void InspectedContentsClosing() OVERRIDE {
+    if (is_closed_)
+      return;
+    is_closed_ = true;
 
     base::DictionaryValue notification;
     notification.SetString(
-        devtools::Inspector::detached::kParamReason,
-        replaced_with_another_client ?
-            "replaced_with_devtools" : "target_closed");
+        devtools::Inspector::detached::kParamReason, detach_reason_);
     std::string response = DevToolsProtocol::CreateNotification(
         devtools::Inspector::detached::kName,
         notification.DeepCopy())->Serialize();
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&net::HttpServer::SendOverWebSocket,
                    server_,
                    connection_id_,
                    response));
 
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&net::HttpServer::Close, server_, connection_id_));
   }
 
-  virtual void DispatchProtocolMessage(
-      DevToolsAgentHost* agent_host, const std::string& message) OVERRIDE {
-    DCHECK(agent_host == agent_host_.get());
+  virtual void DispatchOnInspectorFrontend(const std::string& data) OVERRIDE {
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&net::HttpServer::SendOverWebSocket,
                    server_,
                    connection_id_,
-                   message));
+                   data));
   }
 
-  void OnMessage(const std::string& message) {
-    if (agent_host_)
-      agent_host_->DispatchProtocolMessage(message);
+  virtual void ReplacedWithAnotherClient() OVERRIDE {
+    detach_reason_ = "replaced_with_devtools";
   }
 
  private:
   base::MessageLoop* message_loop_;
   net::HttpServer* server_;
   int connection_id_;
-  scoped_refptr<DevToolsAgentHost> agent_host_;
+  bool is_closed_;
+  std::string detach_reason_;
 };
 
 static bool TimeComparator(const DevToolsTarget* target1,
                            const DevToolsTarget* target2) {
   return target1->GetLastActivityTime() > target2->GetLastActivityTime();
 }
 
 }  // namespace
 
 // static
@@ skipping 465 matching lines @@
     Send500(connection_id, "No such target id: " + page_id);
     return;
   }
 
   if (agent->IsAttached()) {
     Send500(connection_id,
             "Target with given id is being inspected: " + page_id);
     return;
   }
 
-  DevToolsAgentHostClientImpl * client_host = new DevToolsAgentHostClientImpl(
-      thread_->message_loop(), server_.get(), connection_id, agent);
-  connection_to_client_ui_[connection_id] = client_host;
+  DevToolsClientHostImpl* client_host = new DevToolsClientHostImpl(
+      thread_->message_loop(), server_.get(), connection_id);
+  connection_to_client_host_ui_[connection_id] = client_host;
+
+  DevToolsManager::GetInstance()->
+      RegisterDevToolsClientHostFor(agent, client_host);
 
   AcceptWebSocket(connection_id, request);
 }
 
 void DevToolsHttpHandlerImpl::OnWebSocketMessageUI(
     int connection_id,
     const std::string& data) {
-  ConnectionToClientMap::iterator it =
-      connection_to_client_ui_.find(connection_id);
-  if (it == connection_to_client_ui_.end())
+  ConnectionToClientHostMap::iterator it =
+      connection_to_client_host_ui_.find(connection_id);
+  if (it == connection_to_client_host_ui_.end())
     return;
 
-  DevToolsAgentHostClientImpl* client =
-      static_cast<DevToolsAgentHostClientImpl*>(it->second);
-  client->OnMessage(data);
+  DevToolsManager* manager = DevToolsManager::GetInstance();
+  manager->DispatchOnInspectorBackend(it->second, data);
 }
 
 void DevToolsHttpHandlerImpl::OnCloseUI(int connection_id) {
-  ConnectionToClientMap::iterator it =
-      connection_to_client_ui_.find(connection_id);
-  if (it != connection_to_client_ui_.end()) {
-    DevToolsAgentHostClientImpl* client =
-        static_cast<DevToolsAgentHostClientImpl*>(it->second);
-    delete client;
-    connection_to_client_ui_.erase(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);
+    DevToolsManager::GetInstance()->ClientHostClosing(client_host);
+    delete client_host;
+    connection_to_client_host_ui_.erase(connection_id);
   }
 }
 
 DevToolsHttpHandlerImpl::DevToolsHttpHandlerImpl(
     const net::StreamListenSocketFactory* socket_factory,
     const std::string& frontend_url,
     DevToolsHttpHandlerDelegate* delegate,
     const base::FilePath& active_port_output_directory)
     : frontend_url_(frontend_url),
       socket_factory_(socket_factory),
@@ skipping 158 matching lines @@
         id.c_str(),
         host);
     dictionary->SetString(
         kTargetDevtoolsFrontendUrlField, devtools_frontend_url);
   }
 
   return dictionary;
 }
 
 }  // namespace content