[DevTools] Split DevToolsHttpHandler into two classes

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"
@@ skipping 53 matching lines @@
 const char kTargetDescriptionField[] = "description";
 const char kTargetUrlField[] = "url";
 const char kTargetThumbnailUrlField[] = "thumbnailUrl";
 const char kTargetFaviconUrlField[] = "faviconUrl";
 const char kTargetWebSocketDebuggerUrlField[] = "webSocketDebuggerUrl";
 const char kTargetDevtoolsFrontendUrlField[] = "devtoolsFrontendUrl";
 
 // Maximum write buffer size of devtools http/websocket connectinos.
 const int32 kSendBufferSizeForDevTools = 100 * 1024 * 1024;  // 100Mb
 
-// DevToolsAgentHostClientImpl -----------------------------------------------
+// Runs on FILE thread.
+static scoped_ptr<base::Thread> StartHandlerThread() {
+  scoped_ptr<base::Thread> thread(new base::Thread(kDevToolsHandlerThreadName));
+  base::Thread::Options options;
+  options.message_loop_type = base::MessageLoop::TYPE_IO;
+  if (!thread->StartWithOptions(options))
+    return nullptr;
 
+  return thread.Pass();
+}
+
+}  // namespace
+
+// DevToolsHttpHandlerImpl::ServerWrapper ------------------------------------
+
+class DevToolsHttpHandlerImpl::ServerWrapper : net::HttpServer::Delegate {
+ public:
+  static void StartServer(
+     base::WeakPtr<DevToolsHttpHandlerImpl> handler,
+     scoped_ptr<ServerSocketFactory> server_socket_factory,
+     const base::FilePath& output_directory,
+     const base::FilePath& frontend_dir,
+     bool bundles_resources);
+
+  void AcceptWebSocket(int connection_id,
+                       const net::HttpServerRequestInfo& request);
+  void SendOverWebSocket(int connection_id, const std::string& message);
+  void SendResponse(int connection_id,
+                    const net::HttpServerResponseInfo& response);
+  void Send200(int connection_id,
+               const std::string& data,
+               const std::string& mime_type);
+  void Send404(int connection_id);
+  void Send500(int connection_id, const std::string& message);
+  void Close(int connection_id);
+
+  virtual ~ServerWrapper() {}
+
+ private:
+  ServerWrapper(base::WeakPtr<DevToolsHttpHandlerImpl> handler,
+                scoped_ptr<net::ServerSocket> socket,
+                const base::FilePath& frontend_dir,
+                bool bundles_resources);
+
+  // net::HttpServer::Delegate implementation.
+  void OnConnect(int connection_id) override {}
+  void OnHttpRequest(int connection_id,
+                     const net::HttpServerRequestInfo& info) override;
+  void OnWebSocketRequest(int connection_id,
+                          const net::HttpServerRequestInfo& info) override;
+  void OnWebSocketMessage(int connection_id,
+                          const std::string& data) override;
+  void OnClose(int connection_id) override;
+
+  void WriteActivePortToUserProfile(const base::FilePath& output_directory);
+
+  base::WeakPtr<DevToolsHttpHandlerImpl> handler_;
+  scoped_ptr<net::HttpServer> server_;
+  base::FilePath frontend_dir_;
+  bool bundles_resources_;
+};
+
+void DevToolsHttpHandlerImpl::ServerWrapper::AcceptWebSocket(
+    int connection_id,
+    const net::HttpServerRequestInfo& request) {
+  server_->SetSendBufferSize(connection_id, kSendBufferSizeForDevTools);
+  server_->AcceptWebSocket(connection_id, request);
+}
+
+void DevToolsHttpHandlerImpl::ServerWrapper::SendOverWebSocket(
+    int connection_id,
+    const std::string& message) {
+  server_->SendOverWebSocket(connection_id, message);
+}
+
+void DevToolsHttpHandlerImpl::ServerWrapper::SendResponse(
+    int connection_id,
+    const net::HttpServerResponseInfo& response) {
+  server_->SendResponse(connection_id, response);
+}
+
+void DevToolsHttpHandlerImpl::ServerWrapper::Send200(
+    int connection_id,
+    const std::string& data,
+    const std::string& mime_type) {
+  server_->Send200(connection_id, data, mime_type);
+}
+
+void DevToolsHttpHandlerImpl::ServerWrapper::Send404(int connection_id) {
+  server_->Send404(connection_id);
+}
+
+void DevToolsHttpHandlerImpl::ServerWrapper::Send500(
+    int connection_id,
+    const std::string& message) {
+  server_->Send500(connection_id, message);
+}
+
+void DevToolsHttpHandlerImpl::ServerWrapper::Close(int connection_id) {
+  server_->Close(connection_id);
+}
+
+// DevToolsHttpHandlerImpl::AgentHostClientImpl ------------------------------
 // An internal implementation of DevToolsAgentHostClient that delegates
 // messages sent to a DebuggerShell instance.
-class DevToolsAgentHostClientImpl : public DevToolsAgentHostClient {
+class DevToolsHttpHandlerImpl::AgentHostClientImpl
+    : public DevToolsAgentHostClient {
  public:
-  DevToolsAgentHostClientImpl(base::MessageLoop* message_loop,
-                              net::HttpServer* server,
-                              int connection_id,
-                              DevToolsAgentHost* agent_host)
+  AgentHostClientImpl(base::MessageLoop* message_loop,
+                      ServerWrapper* server,
+                      int connection_id,
+                      DevToolsAgentHost* agent_host)
       : message_loop_(message_loop),
         server_(server),
         connection_id_(connection_id),
         agent_host_(agent_host) {
     agent_host_->AttachClient(this);
   }
 
-  ~DevToolsAgentHostClientImpl() override {
+  ~AgentHostClientImpl() override {
     if (agent_host_.get())
       agent_host_->DetachClient();
   }
 
   void AgentHostClosed(DevToolsAgentHost* agent_host,
                        bool replaced_with_another_client) override {
     DCHECK(agent_host == agent_host_.get());
     agent_host_ = NULL;
 
     base::DictionaryValue notification;
     notification.SetString(
         devtools::Inspector::detached::kParamReason,
         replaced_with_another_client ?
             "replaced_with_devtools" : "target_closed");
     std::string response = DevToolsProtocol::CreateNotification(
         devtools::Inspector::detached::kName,
         notification.DeepCopy())->Serialize();
     message_loop_->PostTask(
         FROM_HERE,
-        base::Bind(&net::HttpServer::SendOverWebSocket,
+        base::Bind(&ServerWrapper::SendOverWebSocket,
                    base::Unretained(server_),
                    connection_id_,
                    response));
 
     message_loop_->PostTask(
         FROM_HERE,
-        base::Bind(&net::HttpServer::Close,
+        base::Bind(&ServerWrapper::Close,
                    base::Unretained(server_),
                    connection_id_));
   }
 
   void DispatchProtocolMessage(DevToolsAgentHost* agent_host,
                                const std::string& message) override {
     DCHECK(agent_host == agent_host_.get());
     message_loop_->PostTask(
         FROM_HERE,
-        base::Bind(&net::HttpServer::SendOverWebSocket,
+        base::Bind(&ServerWrapper::SendOverWebSocket,
                    base::Unretained(server_),
                    connection_id_,
                    message));
   }
 
   void OnMessage(const std::string& message) {
     if (agent_host_.get())
       agent_host_->DispatchProtocolMessage(message);
   }
 
  private:
   base::MessageLoop* const message_loop_;
-  net::HttpServer* const server_;
+  ServerWrapper* const server_;
   const int connection_id_;
   scoped_refptr<DevToolsAgentHost> agent_host_;
 };
 
 static bool TimeComparator(const DevToolsTarget* target1,
                            const DevToolsTarget* target2) {
   return target1->GetLastActivityTime() > target2->GetLastActivityTime();
 }
 
-}  // namespace
-
 // DevToolsHttpHandlerImpl::BrowserTarget ------------------------------------
 
 class DevToolsHttpHandlerImpl::BrowserTarget {
  public:
   BrowserTarget(base::MessageLoop* message_loop,
-                net::HttpServer* server,
+                ServerWrapper* server,
                 int connection_id)
       : message_loop_(message_loop),
         server_(server),
         connection_id_(connection_id),
         tracing_handler_(new devtools::tracing::TracingHandler(
             devtools::tracing::TracingHandler::Browser)),
         protocol_handler_(new DevToolsProtocolHandlerImpl()) {
     protocol_handler_->SetNotifier(
         base::Bind(&BrowserTarget::Respond, base::Unretained(this)));
     protocol_handler_->SetTracingHandler(tracing_handler_.get());
@@ skipping 34 matching lines @@
         Respond(response->Serialize());
     } else {
       Respond(command->NoSuchMethodErrorResponse()->Serialize());
     }
   }
 
   void Respond(const std::string& message) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     message_loop_->PostTask(
         FROM_HERE,
-        base::Bind(&net::HttpServer::SendOverWebSocket,
+        base::Bind(&ServerWrapper::SendOverWebSocket,
                    base::Unretained(server_),
                    connection_id_,
                    message));
   }
 
  private:
   base::MessageLoop* const message_loop_;
-  net::HttpServer* const server_;
+  ServerWrapper* const server_;
   const int connection_id_;
   scoped_ptr<devtools::tracing::TracingHandler> tracing_handler_;
   scoped_ptr<DevToolsProtocolHandlerImpl> protocol_handler_;
   std::vector<DevToolsProtocol::Handler*> handlers_;
 };
 
 // DevToolsHttpHandler -------------------------------------------------------
 
 // static
 bool DevToolsHttpHandler::IsSupportedProtocolVersion(
@@ skipping 14 matching lines @@
 DevToolsHttpHandler* DevToolsHttpHandler::Start(
     scoped_ptr<ServerSocketFactory> server_socket_factory,
     const std::string& frontend_url,
     DevToolsHttpHandlerDelegate* delegate,
     const base::FilePath& active_port_output_directory) {
   DevToolsHttpHandlerImpl* http_handler =
       new DevToolsHttpHandlerImpl(server_socket_factory.Pass(),
                                   frontend_url,
                                   delegate,
                                   active_port_output_directory);
-  http_handler->Start();
   return http_handler;
 }
 
 // DevToolsHttpHandler::ServerSocketFactory ----------------------------------
 
 DevToolsHttpHandler::ServerSocketFactory::ServerSocketFactory(
     const std::string& address,
     int port,
     int backlog)
     : address_(address),
@@ skipping 10 matching lines @@
   if (socket &&
       socket->ListenWithAddressAndPort(address_, port_, backlog_) == net::OK) {
     return socket.Pass();
   }
   return scoped_ptr<net::ServerSocket>();
 }
 
 // DevToolsHttpHandlerImpl ---------------------------------------------------
 
 DevToolsHttpHandlerImpl::~DevToolsHttpHandlerImpl() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  // Stop() must be called prior to destruction.
-  DCHECK(server_.get() == NULL);
-  DCHECK(thread_.get() == NULL);
   STLDeleteValues(&target_map_);
-}
-
-void DevToolsHttpHandlerImpl::Start() {
-  if (thread_)
-    return;
-  thread_.reset(new base::Thread(kDevToolsHandlerThreadName));
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&DevToolsHttpHandlerImpl::StartHandlerThread, this));
-}
-
-// Runs on FILE thread.
-void DevToolsHttpHandlerImpl::StartHandlerThread() {
-  base::Thread::Options options;
-  options.message_loop_type = base::MessageLoop::TYPE_IO;
-  if (!thread_->StartWithOptions(options)) {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&DevToolsHttpHandlerImpl::ResetHandlerThread, this));
-    return;
-  }
-
-  thread_->message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&DevToolsHttpHandlerImpl::Init, this));
-}
-
-void DevToolsHttpHandlerImpl::ResetHandlerThread() {
-  thread_.reset();
-  server_ip_address_.reset();
-}
-
-void DevToolsHttpHandlerImpl::ResetHandlerThreadAndRelease() {
-  ResetHandlerThread();
-  Release();
+  STLDeleteValues(&browser_targets_);
+  STLDeleteValues(&connection_to_client_);
 }
 
 void DevToolsHttpHandlerImpl::Stop() {
-  if (!thread_)
-    return;
-  BrowserThread::PostTaskAndReply(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&DevToolsHttpHandlerImpl::StopHandlerThread, this),
-      base::Bind(&DevToolsHttpHandlerImpl::ResetHandlerThreadAndRelease, this));
-}
-
-void DevToolsHttpHandlerImpl::StopWithoutRelease() {
-  if (!thread_)
-    return;
-  BrowserThread::PostTaskAndReply(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&DevToolsHttpHandlerImpl::StopHandlerThread, this),
-      base::Bind(&DevToolsHttpHandlerImpl::ResetHandlerThread, this));
+  if (server_) {
+    DCHECK(thread_);
+    thread_->message_loop()->DeleteSoon(FROM_HERE, server_.release());
+  }
+  StopHandlerThread();
+  delete this;
 }
 
 GURL DevToolsHttpHandlerImpl::GetFrontendURL() {
   if (!server_ip_address_)
     return GURL();
   return GURL(std::string("http://") + server_ip_address_->ToString() + frontend_url_);
 }
 
 static std::string PathWithoutParams(const std::string& path) {
   size_t query_position = path.find("?");
@@ skipping 16 matching lines @@
   } else if (EndsWith(filename, ".json", false)) {
     return "application/json";
   }
   LOG(ERROR) << "GetMimeType doesn't know mime type for: "
              << filename
              << " text/plain will be returned";
   NOTREACHED();
   return "text/plain";
 }
 
-void DevToolsHttpHandlerImpl::OnHttpRequest(
+void DevToolsHttpHandlerImpl::ServerWrapper::OnHttpRequest(
     int connection_id,
     const net::HttpServerRequestInfo& info) {
   server_->SetSendBufferSize(connection_id, kSendBufferSizeForDevTools);
 
   if (info.path.find("/json") == 0) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
-        base::Bind(&DevToolsHttpHandlerImpl::OnJsonRequestUI,
-                   this,
+        base::Bind(&DevToolsHttpHandlerImpl::OnJsonRequest,
+                   handler_,
                    connection_id,
                    info));
     return;
   }
 
   if (info.path.find(kThumbUrlPrefix) == 0) {
     // Thumbnail request.
     const std::string target_id = info.path.substr(strlen(kThumbUrlPrefix));
-    DevToolsTarget* target = GetTarget(target_id);
-    GURL page_url;
-    if (target)
-      page_url = target->GetURL();
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
-        base::Bind(&DevToolsHttpHandlerImpl::OnThumbnailRequestUI,
-                   this,
+        base::Bind(&DevToolsHttpHandlerImpl::OnThumbnailRequest,
+                   handler_,
                    connection_id,
-                   page_url));
+                   target_id));
     return;
   }
 
   if (info.path == "" || info.path == "/") {
     // Discovery page request.
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
-        base::Bind(&DevToolsHttpHandlerImpl::OnDiscoveryPageRequestUI,
-                   this,
+        base::Bind(&DevToolsHttpHandlerImpl::OnDiscoveryPageRequest,
+                   handler_,
                    connection_id));
     return;
   }
 
   if (info.path.find("/devtools/") != 0) {
     server_->Send404(connection_id);
     return;
   }
 
   std::string filename = PathWithoutParams(info.path.substr(10));
   std::string mime_type = GetMimeType(filename);
 
-  base::FilePath frontend_dir = delegate_->GetDebugFrontendDir();
-  if (!frontend_dir.empty()) {
-    base::FilePath path = frontend_dir.AppendASCII(filename);
+  if (!frontend_dir_.empty()) {
+    base::FilePath path = frontend_dir_.AppendASCII(filename);
     std::string data;
     base::ReadFileToString(path, &data);
     server_->Send200(connection_id, data, mime_type);
     return;
   }
-  if (delegate_->BundlesFrontendResources()) {
+  if (bundles_resources_) {
     int resource_id = DevToolsHttpHandler::GetFrontendResourceId(filename);
     if (resource_id != -1) {
       base::StringPiece data = GetContentClient()->GetDataResource(
           resource_id, ui::SCALE_FACTOR_NONE);
       server_->Send200(connection_id, data.as_string(), mime_type);
       return;
     }
   }
   server_->Send404(connection_id);
 }
 
-void DevToolsHttpHandlerImpl::OnWebSocketRequest(
+void DevToolsHttpHandlerImpl::ServerWrapper::OnWebSocketRequest(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
-          &DevToolsHttpHandlerImpl::OnWebSocketRequestUI,
-          this,
+          &DevToolsHttpHandlerImpl::OnWebSocketRequest,
+          handler_,
           connection_id,
           request));
 }
 
-void DevToolsHttpHandlerImpl::OnWebSocketMessage(
+void DevToolsHttpHandlerImpl::ServerWrapper::OnWebSocketMessage(
     int connection_id,
     const std::string& data) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
-          &DevToolsHttpHandlerImpl::OnWebSocketMessageUI,
-          this,
+          &DevToolsHttpHandlerImpl::OnWebSocketMessage,
+          handler_,
           connection_id,
           data));
 }
 
-void DevToolsHttpHandlerImpl::OnClose(int connection_id) {
+void DevToolsHttpHandlerImpl::ServerWrapper::OnClose(int connection_id) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
-          &DevToolsHttpHandlerImpl::OnCloseUI,
-          this,
+          &DevToolsHttpHandlerImpl::OnClose,
+          handler_,
           connection_id));
 }
 
 std::string DevToolsHttpHandlerImpl::GetFrontendURLInternal(
     const std::string id,
     const std::string& host) {
   return base::StringPrintf(
       "%s%sws=%s%s%s",
       frontend_url_.c_str(),
       frontend_url_.find("?") == std::string::npos ? "?" : "&",
@@ skipping 20 matching lines @@
   *command = path.substr(1);
 
   size_t separator_pos = command->find("/");
   if (separator_pos != std::string::npos) {
     *target_id = command->substr(separator_pos + 1);
     *command = command->substr(0, separator_pos);
   }
   return true;
 }
 
-void DevToolsHttpHandlerImpl::OnJsonRequestUI(
+void DevToolsHttpHandlerImpl::OnJsonRequest(
     int connection_id,
     const net::HttpServerRequestInfo& info) {
   // Trim /json
   std::string path = info.path.substr(5);
 
   // Trim fragment and query
   std::string query;
   size_t query_pos = path.find("?");
   if (query_pos != std::string::npos) {
     query = path.substr(query_pos + 1);
@@ skipping 23 matching lines @@
 #if defined(OS_ANDROID)
     version.SetString("Android-Package",
         base::android::BuildInfo::GetInstance()->package_name());
 #endif
     SendJson(connection_id, net::HTTP_OK, &version, std::string());
     return;
   }
 
   if (command == "list") {
     std::string host = info.headers["host"];
-    AddRef();  // Balanced in OnTargetListReceived.
     DevToolsManagerDelegate* manager_delegate =
         DevToolsManager::GetInstance()->delegate();
     if (manager_delegate) {
       manager_delegate->EnumerateTargets(
-          base::Bind(&DevToolsHttpHandlerImpl::OnTargetListReceived,
-                     this, connection_id, host));
+          base::Bind(&DevToolsHttpHandlerImpl::OnTargetListReceivedWeak,
+                     weak_factory_.GetWeakPtr(), connection_id, host));
     } else {
       DevToolsManagerDelegate::TargetList empty_list;
       OnTargetListReceived(connection_id, host, empty_list);
     }
     return;
   }
 
   if (command == "new") {
     GURL url(net::UnescapeURLComponent(
         query, net::UnescapeRule::URL_SPECIAL_CHARS));
@@ skipping 54 matching lines @@
       return;
     }
   }
   SendJson(connection_id,
            net::HTTP_NOT_FOUND,
            NULL,
            "Unknown command: " + command);
   return;
 }
 
+// static
+void DevToolsHttpHandlerImpl::OnTargetListReceivedWeak(
+    base::WeakPtr<DevToolsHttpHandlerImpl> handler,
+    int connection_id,
+    const std::string& host,
+    const DevToolsManagerDelegate::TargetList& targets) {
+  if (handler) {
+    handler->OnTargetListReceived(connection_id, host, targets);
+  } else {
+    STLDeleteContainerPointers(targets.begin(), targets.end());
+  }
+}
+
 void DevToolsHttpHandlerImpl::OnTargetListReceived(
     int connection_id,
     const std::string& host,
     const DevToolsManagerDelegate::TargetList& targets) {
   DevToolsManagerDelegate::TargetList sorted_targets = targets;
   std::sort(sorted_targets.begin(), sorted_targets.end(), TimeComparator);
 
   STLDeleteValues(&target_map_);
   base::ListValue list_value;
   for (DevToolsManagerDelegate::TargetList::const_iterator it =
       sorted_targets.begin(); it != sorted_targets.end(); ++it) {
     DevToolsTarget* target = *it;
     target_map_[target->GetId()] = target;
     list_value.Append(SerializeTarget(*target, host));
   }
   SendJson(connection_id, net::HTTP_OK, &list_value, std::string());
-  Release();  // Balanced in OnJsonRequestUI.
 }
 
 DevToolsTarget* DevToolsHttpHandlerImpl::GetTarget(const std::string& id) {
   TargetMap::const_iterator it = target_map_.find(id);
   if (it == target_map_.end())
     return NULL;
   return it->second;
 }
 
-void DevToolsHttpHandlerImpl::OnThumbnailRequestUI(
-    int connection_id, const GURL& page_url) {
+void DevToolsHttpHandlerImpl::OnThumbnailRequest(
+    int connection_id, const std::string& target_id) {
+  DevToolsTarget* target = GetTarget(target_id);
+  GURL page_url;
+  if (target)
+    page_url = target->GetURL();
   DevToolsManagerDelegate* manager_delegate =
       DevToolsManager::GetInstance()->delegate();
   std::string data =
       manager_delegate ? manager_delegate->GetPageThumbnailData(page_url) : "";
   if (!data.empty())
     Send200(connection_id, data, "image/png");
   else
     Send404(connection_id);
 }
 
-void DevToolsHttpHandlerImpl::OnDiscoveryPageRequestUI(int connection_id) {
+void DevToolsHttpHandlerImpl::OnDiscoveryPageRequest(int connection_id) {
   std::string response = delegate_->GetDiscoveryPageHTML();
   Send200(connection_id, response, "text/html; charset=UTF-8");
 }
 
-void DevToolsHttpHandlerImpl::OnWebSocketRequestUI(
+void DevToolsHttpHandlerImpl::OnWebSocketRequest(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   if (!thread_)
     return;
 
   std::string browser_prefix = "/devtools/browser";
   size_t browser_pos = request.path.find(browser_prefix);
   if (browser_pos == 0) {
     BrowserTarget* browser_target = new BrowserTarget(
         thread_->message_loop(), server_.get(), connection_id);
@@ skipping 20 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(
+  AgentHostClientImpl* client_host = new AgentHostClientImpl(
       thread_->message_loop(), server_.get(), connection_id, agent.get());
-  connection_to_client_ui_[connection_id] = client_host;
+  connection_to_client_[connection_id] = client_host;
 
   AcceptWebSocket(connection_id, request);
 }
 
-void DevToolsHttpHandlerImpl::OnWebSocketMessageUI(
+void DevToolsHttpHandlerImpl::OnWebSocketMessage(
     int connection_id,
     const std::string& data) {
   BrowserTargets::iterator browser_it = browser_targets_.find(connection_id);
   if (browser_it != browser_targets_.end()) {
     browser_it->second->HandleMessage(data);
     return;
   }
 
   ConnectionToClientMap::iterator it =
-      connection_to_client_ui_.find(connection_id);
-  if (it == connection_to_client_ui_.end())
-    return;
-
-  DevToolsAgentHostClientImpl* client =
-      static_cast<DevToolsAgentHostClientImpl*>(it->second);
-  client->OnMessage(data);
+      connection_to_client_.find(connection_id);
+  if (it != connection_to_client_.end())
+    it->second->OnMessage(data);
 }
 
-void DevToolsHttpHandlerImpl::OnCloseUI(int connection_id) {
+void DevToolsHttpHandlerImpl::OnClose(int connection_id) {
   BrowserTargets::iterator browser_it = browser_targets_.find(connection_id);
   if (browser_it != browser_targets_.end()) {
     delete browser_it->second;
     browser_targets_.erase(connection_id);
     return;
   }
 
   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);
+      connection_to_client_.find(connection_id);
+  if (it != connection_to_client_.end()) {
+    delete it->second;
+    connection_to_client_.erase(connection_id);
   }
 }
 
-void DevToolsHttpHandlerImpl::OnHttpServerInitialized(
-    const net::IPEndPoint& ip_address) {
-  server_ip_address_.reset(new net::IPEndPoint(ip_address));
-}
-
 DevToolsHttpHandlerImpl::DevToolsHttpHandlerImpl(
     scoped_ptr<ServerSocketFactory> server_socket_factory,
     const std::string& frontend_url,
     DevToolsHttpHandlerDelegate* delegate,
-    const base::FilePath& active_port_output_directory)
+    const base::FilePath& output_directory)
     : frontend_url_(frontend_url),
-      server_socket_factory_(server_socket_factory.Pass()),
       delegate_(delegate),
-      active_port_output_directory_(active_port_output_directory) {
+      weak_factory_(this) {
   if (frontend_url_.empty())
     frontend_url_ = "/devtools/devtools.html";
 
-  // Balanced in ResetHandlerThreadAndRelease().
-  AddRef();
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&StartHandlerThread),
+      base::Bind(&DevToolsHttpHandlerImpl::ThreadStarted,
+                 weak_factory_.GetWeakPtr(),
+                 base::Passed(&server_socket_factory),
+                 output_directory));
 }
 
-// Runs on the handler thread
-void DevToolsHttpHandlerImpl::Init() {
-  scoped_ptr<net::ServerSocket> server_socket =
-      server_socket_factory_->CreateAndListen();
-  if (!server_socket) {
-    LOG(ERROR) << "Cannot start http server for devtools. Stop devtools.";
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&DevToolsHttpHandlerImpl::StopWithoutRelease, this));
-    return;
-  }
-
-  server_.reset(new net::HttpServer(server_socket.Pass(), this));
-  net::IPEndPoint ip_address;
-  server_->GetLocalAddress(&ip_address);
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&DevToolsHttpHandlerImpl::OnHttpServerInitialized,
-                 this, ip_address));
-  if (!active_port_output_directory_.empty())
-    WriteActivePortToUserProfile();
+void DevToolsHttpHandlerImpl::ThreadStarted(
+    scoped_ptr<ServerSocketFactory> server_socket_factory,
+    const base::FilePath& output_directory,
+    scoped_ptr<base::Thread> thread) {
+  thread_.swap(thread);
+  thread_->message_loop()->PostTask(FROM_HERE,
+      base::Bind(&DevToolsHttpHandlerImpl::ServerWrapper::StartServer,
+                 weak_factory_.GetWeakPtr(),
+                 base::Passed(&server_socket_factory),
+                 output_directory,
+                 delegate_->GetDebugFrontendDir(),
+                 delegate_->BundlesFrontendResources()));
 }
 
-// Runs on the handler thread
-void DevToolsHttpHandlerImpl::Teardown() {
-  server_.reset();
+// static
+void DevToolsHttpHandlerImpl::ServerWrapper::StartServer(
+    base::WeakPtr<DevToolsHttpHandlerImpl> handler,
+    scoped_ptr<ServerSocketFactory> server_socket_factory,
+    const base::FilePath& output_directory,
+    const base::FilePath& frontend_dir,
+    bool bundles_resources) {
+  scoped_ptr<ServerWrapper> server;
+  scoped_ptr<net::ServerSocket> server_socket =
+      server_socket_factory->CreateAndListen();
+  scoped_ptr<net::IPEndPoint> ip_address(new net::IPEndPoint);
+  if (server_socket) {
+    server.reset(new ServerWrapper(handler, server_socket.Pass(),
+                                   frontend_dir, bundles_resources));
+    if (!output_directory.empty())
+      server->WriteActivePortToUserProfile(output_directory);
+
+    if (server->server_->GetLocalAddress(ip_address.get()) != net::OK)
+      ip_address.reset();
+  } else {
+    ip_address.reset();
+    LOG(ERROR) << "Cannot start http server for devtools. Stop devtools.";
+  }
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+      base::Bind(&DevToolsHttpHandlerImpl::ServerStarted,
+                 handler, base::Passed(&server), base::Passed(&ip_address)));
 }
 
-// Runs on FILE thread to make sure that it is serialized against
-// {Start|Stop}HandlerThread and to allow calling pthread_join.
-void DevToolsHttpHandlerImpl::StopHandlerThread() {
-  if (!thread_->message_loop())
-    return;
-  thread_->message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&DevToolsHttpHandlerImpl::Teardown, this));
-  // Thread::Stop joins the thread.
-  thread_->Stop();
+DevToolsHttpHandlerImpl::ServerWrapper::ServerWrapper(
+    base::WeakPtr<DevToolsHttpHandlerImpl> handler,
+    scoped_ptr<net::ServerSocket> socket,
+    const base::FilePath& frontend_dir,
+    bool bundles_resources)
+    : handler_(handler),
+      server_(new net::HttpServer(socket.Pass(), this)),
+      frontend_dir_(frontend_dir),
+      bundles_resources_(bundles_resources) {
 }
 
-void DevToolsHttpHandlerImpl::WriteActivePortToUserProfile() {
-  DCHECK(!active_port_output_directory_.empty());
+void DevToolsHttpHandlerImpl::ServerStarted(
+    scoped_ptr<ServerWrapper> server,
+    scoped_ptr<net::IPEndPoint> ip_address) {
+  if (server) {
+    server_.swap(server);
+    server_ip_address_.swap(ip_address);
+  } else {
+    StopHandlerThread();
+  }
+}
+
+void DevToolsHttpHandlerImpl::StopHandlerThread() {
+  if (thread_) {
+    BrowserThread::DeleteSoon(BrowserThread::FILE, FROM_HERE,
+                              thread_.release());
+  }
+}
+
+void DevToolsHttpHandlerImpl::ServerWrapper::WriteActivePortToUserProfile(
+    const base::FilePath& output_directory) {
+  DCHECK(!output_directory.empty());
   net::IPEndPoint endpoint;
   int err;
   if ((err = server_->GetLocalAddress(&endpoint)) != net::OK) {
     LOG(ERROR) << "Error " << err << " getting local address";
     return;
   }
 
   // Write this port to a well-known file in the profile directory
   // so Telemetry can pick it up.
-  base::FilePath path = active_port_output_directory_.Append(
-      kDevToolsActivePortFileName);
+  base::FilePath path = output_directory.Append(kDevToolsActivePortFileName);
   std::string port_string = base::IntToString(endpoint.port());
   if (base::WriteFile(path, port_string.c_str(), port_string.length()) < 0) {
     LOG(ERROR) << "Error writing DevTools active port to file";
   }
 }
 
 void DevToolsHttpHandlerImpl::SendJson(int connection_id,
                                        net::HttpStatusCode status_code,
                                        base::Value* value,
                                        const std::string& message) {
   if (!thread_)
     return;
 
   // Serialize value and message.
   std::string json_value;
   if (value) {
     base::JSONWriter::WriteWithOptions(value,
                                        base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                        &json_value);
   }
   std::string json_message;
   scoped_ptr<base::Value> message_object(new base::StringValue(message));
   base::JSONWriter::Write(message_object.get(), &json_message);
 
   net::HttpServerResponseInfo response(status_code);
   response.SetBody(json_value + message, "application/json; charset=UTF-8");
 
   thread_->message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&net::HttpServer::SendResponse,
+      base::Bind(&ServerWrapper::SendResponse,
                  base::Unretained(server_.get()),
                  connection_id,
                  response));
 }
 
 void DevToolsHttpHandlerImpl::Send200(int connection_id,
                                       const std::string& data,
                                       const std::string& mime_type) {
   if (!thread_)
     return;
   thread_->message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&net::HttpServer::Send200,
+      base::Bind(&ServerWrapper::Send200,
                  base::Unretained(server_.get()),
                  connection_id,
                  data,
                  mime_type));
 }
 
 void DevToolsHttpHandlerImpl::Send404(int connection_id) {
   if (!thread_)
     return;
   thread_->message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&net::HttpServer::Send404,
+      base::Bind(&ServerWrapper::Send404,
                  base::Unretained(server_.get()),
                  connection_id));
 }
 
 void DevToolsHttpHandlerImpl::Send500(int connection_id,
                                       const std::string& message) {
   if (!thread_)
     return;
   thread_->message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&net::HttpServer::Send500,
+      base::Bind(&ServerWrapper::Send500,
                  base::Unretained(server_.get()),
                  connection_id,
                  message));
 }
 
 void DevToolsHttpHandlerImpl::AcceptWebSocket(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   if (!thread_)
     return;
   thread_->message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&net::HttpServer::SetSendBufferSize,
-                 base::Unretained(server_.get()),
-                 connection_id,
-                 kSendBufferSizeForDevTools));
-  thread_->message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&net::HttpServer::AcceptWebSocket,
+      base::Bind(&ServerWrapper::AcceptWebSocket,
                  base::Unretained(server_.get()),
                  connection_id,
                  request));
 }
 
 base::DictionaryValue* DevToolsHttpHandlerImpl::SerializeTarget(
     const DevToolsTarget& target,
     const std::string& host) {
   base::DictionaryValue* dictionary = new base::DictionaryValue;
 
@@ skipping 32 matching lines @@
         id.c_str(),
         host);
     dictionary->SetString(
         kTargetDevtoolsFrontendUrlField, devtools_frontend_url);
   }
 
   return dictionary;
 }
 
 }  // namespace content