[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"
 #include "base/compiler_specific.h"
 #include "base/files/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_manager.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/protocol/devtools_protocol_handler_impl.h"
 #include "content/browser/devtools/protocol/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_http_handler.h"
 #include "content/public/browser/devtools_http_handler_delegate.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 "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"
+#include "net/server/http_server.h"
 #include "net/server/http_server_request_info.h"
 #include "net/server/http_server_response_info.h"
 #include "net/socket/server_socket.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #endif
 
 namespace content {
 
@@ skipping 14 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
 
+class BrowserTarget;
+class DevToolsAgentHostClientImpl;
+class ServerWrapper;
+
+// DevToolsHttpHandlerImpl ---------------------------------------------------
+
+class DevToolsHttpHandlerImpl : public DevToolsHttpHandler {
+ public:
+  DevToolsHttpHandlerImpl(scoped_ptr<ServerSocketFactory> server_socket_factory,
+                          const std::string& frontend_url,
+                          DevToolsHttpHandlerDelegate* delegate,
+                          const base::FilePath& output_directory);
+  ~DevToolsHttpHandlerImpl() override;
+
+  void OnJsonRequest(int connection_id,
+                     const net::HttpServerRequestInfo& info);
+  void OnThumbnailRequest(int connection_id, const std::string& target_id);
+  void OnDiscoveryPageRequest(int connection_id);
+
+  void OnWebSocketRequest(int connection_id,
+                          const net::HttpServerRequestInfo& info);
+  void OnWebSocketMessage(int connection_id, const std::string& data);
+  void OnClose(int connection_id);
+
+  void OnTargetListReceived(
+      int connection_id,
+      const std::string& host,
+      const DevToolsManagerDelegate::TargetList& targets);
+
+  void ServerStarted(base::Thread* thread,
+                     ServerWrapper* server_wrapper,
+                     scoped_ptr<net::IPEndPoint> ip_address);
+
+ private:
+  // DevToolsHttpHandler implementation.
+  void Stop() override;
+  GURL GetFrontendURL() override;
+
+  DevToolsTarget* GetTarget(const std::string& id);
+
+  void SendJson(int connection_id,
+                net::HttpStatusCode status_code,
+                base::Value* value,
+                const std::string& message);
+  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 AcceptWebSocket(int connection_id,
+                       const net::HttpServerRequestInfo& request);
+
+  // Returns the front end url without the host at the beginning.
+  std::string GetFrontendURLInternal(const std::string target_id,
+                                     const std::string& host);
+
+  base::DictionaryValue* SerializeTarget(const DevToolsTarget& target,
+                                         const std::string& host);
+
+  // The thread used by the devtools handler to run server socket.
+  base::Thread* thread_;
+
+  std::string frontend_url_;
+  ServerWrapper* server_wrapper_;
+  scoped_ptr<net::IPEndPoint> server_ip_address_;
+  typedef std::map<int, DevToolsAgentHostClientImpl*> ConnectionToClientMap;
+  ConnectionToClientMap connection_to_client_;
+  const scoped_ptr<DevToolsHttpHandlerDelegate> delegate_;
+  typedef std::map<std::string, DevToolsTarget*> TargetMap;
+  TargetMap target_map_;
+  typedef std::map<int, BrowserTarget*> BrowserTargets;
+  BrowserTargets browser_targets_;
+  base::WeakPtrFactory<DevToolsHttpHandlerImpl> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(DevToolsHttpHandlerImpl);
+};
+
+// ServerWrapper -------------------------------------------------------------
+
+class ServerWrapper : net::HttpServer::Delegate {

[dgozman, 2014/11/10 15:39:19]

Let's comment that this class lives on handler thread.

[vkuzkokov, 2014/11/11 08:52:05]

Done.

+ public:
+  ServerWrapper(base::WeakPtr<DevToolsHttpHandlerImpl> handler,
+                scoped_ptr<net::ServerSocket> socket,
+                const base::FilePath& frontend_dir,
+                bool bundles_resources);
+
+  int GetLocalAddress(net::IPEndPoint* address);
+
+  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);
+
+  void WriteActivePortToUserProfile(const base::FilePath& output_directory);
+
+  virtual ~ServerWrapper() {}
+
+ private:
+  // 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;
+
+  base::WeakPtr<DevToolsHttpHandlerImpl> handler_;
+  scoped_ptr<net::HttpServer> server_;
+  base::FilePath frontend_dir_;
+  bool bundles_resources_;
+};
+
+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) {
+}
+
+int ServerWrapper::GetLocalAddress(net::IPEndPoint* address) {
+  return server_->GetLocalAddress(address);
+}
+
+void ServerWrapper::AcceptWebSocket(int connection_id,
+                                    const net::HttpServerRequestInfo& request) {
+  server_->SetSendBufferSize(connection_id, kSendBufferSizeForDevTools);
+  server_->AcceptWebSocket(connection_id, request);
+}
+
+void ServerWrapper::SendOverWebSocket(int connection_id,
+                                      const std::string& message) {
+  server_->SendOverWebSocket(connection_id, message);
+}
+
+void ServerWrapper::SendResponse(int connection_id,
+                                 const net::HttpServerResponseInfo& response) {
+  server_->SendResponse(connection_id, response);
+}
+
+void ServerWrapper::Send200(int connection_id,
+                            const std::string& data,
+                            const std::string& mime_type) {
+  server_->Send200(connection_id, data, mime_type);
+}
+
+void ServerWrapper::Send404(int connection_id) {
+  server_->Send404(connection_id);
+}
+
+void ServerWrapper::Send500(int connection_id,
+                            const std::string& message) {
+  server_->Send500(connection_id, message);
+}
+
+void ServerWrapper::Close(int connection_id) {
+  server_->Close(connection_id);
+}
+
+// Thread and ServerWrapper lifetime management ------------------------------
+
+void Terminate(base::Thread* thread, ServerWrapper* server_wrapper) {

[dgozman, 2014/11/10 15:39:19]

TerminateOnUI

[vkuzkokov, 2014/11/11 08:52:05]

Done.

+  if (server_wrapper) {
+    DCHECK(thread);
+    thread->message_loop()->DeleteSoon(FROM_HERE, server_wrapper);
+  }
+  if (thread) {
+    BrowserThread::DeleteSoon(BrowserThread::FILE, FROM_HERE, thread);
+  }
+}
+
+void ServerStartedOnUI(

[dgozman, 2014/11/10 15:39:19]

Let's DCHECK that thread is valid in all these static methods.

[vkuzkokov, 2014/11/11 08:52:05]

Done.

+    base::WeakPtr<DevToolsHttpHandlerImpl> handler,
+    base::Thread* thread,
+    ServerWrapper* server_wrapper,
+    scoped_ptr<net::IPEndPoint> ip_address) {
+  if (handler && thread && server_wrapper) {
+    handler->ServerStarted(thread, server_wrapper, ip_address.Pass());
+  } else {
+    Terminate(thread, server_wrapper);
+  }
+}
+
+void StartServerOnHandlerThread(
+    base::WeakPtr<DevToolsHttpHandlerImpl> handler,
+    base::Thread* thread,
+    scoped_ptr<DevToolsHttpHandler::ServerSocketFactory> server_socket_factory,
+    const base::FilePath& output_directory,
+    const base::FilePath& frontend_dir,
+    bool bundles_resources) {
+  ServerWrapper* server_wrapper = nullptr;
+  scoped_ptr<net::ServerSocket> server_socket =
+      server_socket_factory->CreateAndListen();
+  scoped_ptr<net::IPEndPoint> ip_address(new net::IPEndPoint);
+  if (server_socket) {
+    server_wrapper = new ServerWrapper(handler, server_socket.Pass(),
+                                       frontend_dir, bundles_resources);
+    if (!output_directory.empty())
+      server_wrapper->WriteActivePortToUserProfile(output_directory);
+
+    if (server_wrapper->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(&ServerStartedOnUI,
+                 handler, thread, server_wrapper, base::Passed(&ip_address)));
+}
+
+void StartServerOnFile(
+    base::WeakPtr<DevToolsHttpHandlerImpl> handler,
+    scoped_ptr<DevToolsHttpHandler::ServerSocketFactory> server_socket_factory,
+    const base::FilePath& output_directory,
+    const base::FilePath& frontend_dir,
+    bool bundles_resources) {
+  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)) {
+    base::MessageLoop* message_loop = thread->message_loop();
+    message_loop->PostTask(FROM_HERE,
+        base::Bind(&StartServerOnHandlerThread,
+                   handler,
+                   base::Unretained(thread.release()),
+                   base::Passed(&server_socket_factory),
+                   output_directory,
+                   frontend_dir,
+                   bundles_resources));
+  }
+}
+
 // DevToolsAgentHostClientImpl -----------------------------------------------
-
 // An internal implementation of DevToolsAgentHostClient that delegates
 // messages sent to a DebuggerShell instance.
 class DevToolsAgentHostClientImpl : public DevToolsAgentHostClient {
  public:
   DevToolsAgentHostClientImpl(base::MessageLoop* message_loop,
-                              net::HttpServer* server,
+                              ServerWrapper* server_wrapper,
                               int connection_id,
                               DevToolsAgentHost* agent_host)
       : message_loop_(message_loop),
-        server_(server),
+        server_wrapper_(server_wrapper),
         connection_id_(connection_id),
         agent_host_(agent_host) {
     agent_host_->AttachClient(this);
   }
 
   ~DevToolsAgentHostClientImpl() 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::Unretained(server_),
+        base::Bind(&ServerWrapper::SendOverWebSocket,
+                   base::Unretained(server_wrapper_),
                    connection_id_,
                    response));
 
     message_loop_->PostTask(
         FROM_HERE,
-        base::Bind(&net::HttpServer::Close,
-                   base::Unretained(server_),
+        base::Bind(&ServerWrapper::Close,
+                   base::Unretained(server_wrapper_),
                    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::Unretained(server_),
+        base::Bind(&ServerWrapper::SendOverWebSocket,
+                   base::Unretained(server_wrapper_),
                    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_wrapper_;
   const int connection_id_;
   scoped_refptr<DevToolsAgentHost> agent_host_;
 };
 
 static bool TimeComparator(const DevToolsTarget* target1,
                            const DevToolsTarget* target2) {
   return target1->GetLastActivityTime() > target2->GetLastActivityTime();
 }
 
-}  // namespace
+// BrowserTarget -------------------------------------------------------------
 
-// DevToolsHttpHandlerImpl::BrowserTarget ------------------------------------
-
-class DevToolsHttpHandlerImpl::BrowserTarget {
+class BrowserTarget {
  public:
   BrowserTarget(base::MessageLoop* message_loop,
-                net::HttpServer* server,
+                ServerWrapper* server_wrapper,
                 int connection_id)
       : message_loop_(message_loop),
-        server_(server),
+        server_wrapper_(server_wrapper),
         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());
   }
 
   ~BrowserTarget() {
@@ skipping 31 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::Unretained(server_),
+        base::Bind(&ServerWrapper::SendOverWebSocket,
+                   base::Unretained(server_wrapper_),
                    connection_id_,
                    message));
   }
 
  private:
   base::MessageLoop* const message_loop_;
-  net::HttpServer* const server_;
+  ServerWrapper* const server_wrapper_;
   const int connection_id_;
   scoped_ptr<devtools::tracing::TracingHandler> tracing_handler_;
   scoped_ptr<DevToolsProtocolHandlerImpl> protocol_handler_;
   std::vector<DevToolsProtocol::Handler*> handlers_;
 };
 
+}  // namespace
+
 // DevToolsHttpHandler -------------------------------------------------------
 
 // static
 bool DevToolsHttpHandler::IsSupportedProtocolVersion(
     const std::string& version) {
   return devtools::IsSupportedProtocolVersion(version);
 }
 
 // static
 int DevToolsHttpHandler::GetFrontendResourceId(const std::string& name) {
   for (size_t i = 0; i < kDevtoolsResourcesSize; ++i) {
     if (name == kDevtoolsResources[i].name)
       return kDevtoolsResources[i].value;
   }
   return -1;
 }
 
 // static
 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));
+  Terminate(thread_, server_wrapper_);
+  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(
-    int connection_id,
-    const net::HttpServerRequestInfo& info) {
+void 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 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(
-    int connection_id,
-    const std::string& data) {
+void 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 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(
+static void OnTargetListReceivedWeak(

[dgozman, 2014/11/10 15:39:19]

nit: I think this should be a static method on a class, and moved near to
OnTargetListReceived.

[vkuzkokov, 2014/11/11 08:52:05]

Done.

+    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::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(&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 70 matching lines @@
 
   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);
+        thread_->message_loop(), server_wrapper_, connection_id);
     browser_target->RegisterHandler(
         new TetheringHandler(delegate_.get(), thread_->message_loop_proxy()));
     browser_target->RegisterHandler(
         new DevToolsSystemInfoHandler());
     browser_targets_[connection_id] = browser_target;
     AcceptWebSocket(connection_id, request);
     return;
   }
 
   size_t pos = request.path.find(kPageUrlPrefix);
@@ skipping 11 matching lines @@
     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.get());
-  connection_to_client_ui_[connection_id] = client_host;
+      thread_->message_loop(), server_wrapper_, connection_id, agent.get());
+  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)
-    : frontend_url_(frontend_url),
-      server_socket_factory_(server_socket_factory.Pass()),
+    const base::FilePath& output_directory)
+    : thread_(nullptr),
+      frontend_url_(frontend_url),
+      server_wrapper_(nullptr),
       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::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&StartServerOnFile,
+                 weak_factory_.GetWeakPtr(),
+                 base::Passed(&server_socket_factory),
+                 output_directory,
+                 delegate_->GetDebugFrontendDir(),
+                 delegate_->BundlesFrontendResources()));
 }
 
-// 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::ServerStarted(
+    base::Thread* thread,
+    ServerWrapper* server_wrapper,
+    scoped_ptr<net::IPEndPoint> ip_address) {
+  thread_ = thread;
+  server_wrapper_ = server_wrapper;
+  server_ip_address_.swap(ip_address);
 }
 
-// Runs on the handler thread
-void DevToolsHttpHandlerImpl::Teardown() {
-  server_.reset();
-}
-
-// 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();
-}
-
-void DevToolsHttpHandlerImpl::WriteActivePortToUserProfile() {
-  DCHECK(!active_port_output_directory_.empty());
+void 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::Unretained(server_.get()),
+      base::Bind(&ServerWrapper::SendResponse,
+                 base::Unretained(server_wrapper_),
                  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::Unretained(server_.get()),
+      base::Bind(&ServerWrapper::Send200,
+                 base::Unretained(server_wrapper_),
                  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::Unretained(server_.get()),
+      base::Bind(&ServerWrapper::Send404,
+                 base::Unretained(server_wrapper_),
                  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::Unretained(server_.get()),
+      base::Bind(&ServerWrapper::Send500,
+                 base::Unretained(server_wrapper_),
                  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::Unretained(server_.get()),
+      base::Bind(&ServerWrapper::AcceptWebSocket,
+                 base::Unretained(server_wrapper_),
                  connection_id,
                  request));
 }
 
 base::DictionaryValue* DevToolsHttpHandlerImpl::SerializeTarget(
     const DevToolsTarget& target,
     const std::string& host) {
   base::DictionaryValue* dictionary = new base::DictionaryValue;
 
   std::string id = target.GetId();
@@ skipping 31 matching lines @@
         id.c_str(),
         host);
     dictionary->SetString(
         kTargetDevtoolsFrontendUrlField, devtools_frontend_url);
   }
 
   return dictionary;
 }
 
 }  // namespace content