[DevTools] Move CreateSocketForTethering to ServerSocketFactory

DevToolsManagerDelegate::CreateSocketForTethering was called from handler thread where there is no control over DevToolsManagerDelegate's lifetime.

BUG=

Review URL: https://codereview.chromium.org/820693003

Cr-Commit-Position: refs/heads/master@{#311235}

18 files changed, 228 insertions, 250 deletions

diff --git a/android_webview/native/aw_dev_tools_server.cc b/android_webview/native/aw_dev_tools_server.cc
index ffe6b25..9c96694 100644
--- a/android_webview/native/aw_dev_tools_server.cc
+++ b/android_webview/native/aw_dev_tools_server.cc
@@ -39,7 +39,7 @@ const int kBackLog = 10;
 // instance of this gets created each time web debugging is enabled.
 class AwDevToolsServerDelegate : public content::DevToolsHttpHandlerDelegate {
  public:
-  AwDevToolsServerDelegate() : last_tethering_socket_(0) {
+  AwDevToolsServerDelegate() {
   }
 
   virtual ~AwDevToolsServerDelegate() {}
@@ -54,22 +54,7 @@ class AwDevToolsServerDelegate : public content::DevToolsHttpHandlerDelegate {
   base::FilePath GetDebugFrontendDir() override {
     return base::FilePath();
   }
-
-  scoped_ptr<net::ServerSocket>
-  CreateSocketForTethering(std::string* name) override {
-    *name = base::StringPrintf(
-        kTetheringSocketName, getpid(), ++last_tethering_socket_);
-    scoped_ptr<net::UnixDomainServerSocket> socket(
-        new net::UnixDomainServerSocket(
-            base::Bind(&content::CanUserConnectToDevTools), true));
-    if (socket->ListenWithAddressAndPort(*name, 0, kBackLog) != net::OK)
-      return scoped_ptr<net::ServerSocket>();
-
-    return socket.Pass();
-  }
-
  private:
-  int last_tethering_socket_;
 
   DISALLOW_COPY_AND_ASSIGN(AwDevToolsServerDelegate);
 };
@@ -90,17 +75,38 @@ class UnixDomainServerSocketFactory
     : public content::DevToolsHttpHandler::ServerSocketFactory {
  public:
   explicit UnixDomainServerSocketFactory(const std::string& socket_name)
-      : content::DevToolsHttpHandler::ServerSocketFactory(socket_name, 0, 1) {}
+      : socket_name_(socket_name),
+        last_tethering_socket_(0) {
+  }
 
  private:
   // content::DevToolsHttpHandler::ServerSocketFactory.
-  virtual scoped_ptr<net::ServerSocket> Create() const override {
-    return scoped_ptr<net::ServerSocket>(
+  virtual scoped_ptr<net::ServerSocket> CreateForHttpServer() override {
+    scoped_ptr<net::ServerSocket> socket(
         new net::UnixDomainServerSocket(
             base::Bind(&content::CanUserConnectToDevTools),
             true /* use_abstract_namespace */));
+    if (socket->ListenWithAddressAndPort(socket_name_, 0, kBackLog) != net::OK)
+      return scoped_ptr<net::ServerSocket>();
+
+    return socket;
+  }
+
+  scoped_ptr<net::ServerSocket> CreateForTethering(std::string* name) override {
+    *name = base::StringPrintf(
+        kTetheringSocketName, getpid(), ++last_tethering_socket_);
+    scoped_ptr<net::UnixDomainServerSocket> socket(
+        new net::UnixDomainServerSocket(
+            base::Bind(&content::CanUserConnectToDevTools), true));
+    if (socket->ListenWithAddressAndPort(*name, 0, kBackLog) != net::OK)
+      return scoped_ptr<net::ServerSocket>();
+
+    return socket.Pass();
   }
 
+  std::string socket_name_;
+  int last_tethering_socket_;
+
   DISALLOW_COPY_AND_ASSIGN(UnixDomainServerSocketFactory);
 };
 
diff --git a/chrome/browser/android/dev_tools_server.cc b/chrome/browser/android/dev_tools_server.cc
index 83477f5..57dc0ea 100644
--- a/chrome/browser/android/dev_tools_server.cc
+++ b/chrome/browser/android/dev_tools_server.cc
@@ -82,10 +82,7 @@ bool AuthorizeSocketAccessWithDebugPermission(
 // instance of this gets created each time devtools is enabled.
 class DevToolsServerDelegate : public content::DevToolsHttpHandlerDelegate {
  public:
-  explicit DevToolsServerDelegate(
-      const net::UnixDomainServerSocket::AuthCallback& auth_callback)
-      : last_tethering_socket_(0),
-        auth_callback_(auth_callback) {
+  DevToolsServerDelegate() {
   }
 
   std::string GetDiscoveryPageHTML() override {
@@ -107,18 +104,6 @@ class DevToolsServerDelegate : public content::DevToolsHttpHandlerDelegate {
     return base::FilePath();
   }
 
-  scoped_ptr<net::ServerSocket>
-  CreateSocketForTethering(std::string* name) override {
-    *name = base::StringPrintf(
-        kTetheringSocketName, getpid(), ++last_tethering_socket_);
-    scoped_ptr<net::UnixDomainServerSocket> socket(
-        new net::UnixDomainServerSocket(auth_callback_, true));
-    if (socket->ListenWithAddressAndPort(*name, 0, kBackLog) != net::OK)
-      return scoped_ptr<net::ServerSocket>();
-
-    return socket.Pass();
-  }
-
  private:
   static void PopulatePageThumbnails() {
     Profile* profile =
@@ -128,9 +113,6 @@ class DevToolsServerDelegate : public content::DevToolsHttpHandlerDelegate {
       top_sites->SyncWithHistory();
   }
 
-  int last_tethering_socket_;
-  const net::UnixDomainServerSocket::AuthCallback auth_callback_;
-
   DISALLOW_COPY_AND_ASSIGN(DevToolsServerDelegate);
 };
 
@@ -142,37 +124,44 @@ class UnixDomainServerSocketFactory
   UnixDomainServerSocketFactory(
       const std::string& socket_name,
       const net::UnixDomainServerSocket::AuthCallback& auth_callback)
-      : content::DevToolsHttpHandler::ServerSocketFactory(socket_name, 0, 1),
+      : socket_name_(socket_name),
+        last_tethering_socket_(0),
         auth_callback_(auth_callback) {
   }
 
  private:
-  // content::DevToolsHttpHandler::ServerSocketFactory.
-  virtual scoped_ptr<net::ServerSocket> Create() const override {
-    return scoped_ptr<net::ServerSocket>(
+  scoped_ptr<net::ServerSocket> CreateForHttpServer() override {
+    scoped_ptr<net::ServerSocket> socket(
         new net::UnixDomainServerSocket(auth_callback_,
                                         true /* use_abstract_namespace */));
-  }
-
-  virtual scoped_ptr<net::ServerSocket> CreateAndListen() const override {
-    scoped_ptr<net::ServerSocket> socket = Create();
-    if (!socket)
-      return scoped_ptr<net::ServerSocket>();
 
-    if (socket->ListenWithAddressAndPort(address_, port_, backlog_) == net::OK)
+    if (socket->ListenWithAddressAndPort(socket_name_, 0, kBackLog) == net::OK)
       return socket.Pass();
 
     // Try a fallback socket name.
     const std::string fallback_address(
-        base::StringPrintf("%s_%d", address_.c_str(), getpid()));
-    if (socket->ListenWithAddressAndPort(fallback_address, port_, backlog_)
+        base::StringPrintf("%s_%d", socket_name_.c_str(), getpid()));
+    if (socket->ListenWithAddressAndPort(fallback_address, 0, kBackLog)
         == net::OK)
       return socket.Pass();
 
     return scoped_ptr<net::ServerSocket>();
   }
 
-  const net::UnixDomainServerSocket::AuthCallback auth_callback_;
+  scoped_ptr<net::ServerSocket> CreateForTethering(std::string* name) override {
+    *name = base::StringPrintf(
+        kTetheringSocketName, getpid(), ++last_tethering_socket_);
+    scoped_ptr<net::UnixDomainServerSocket> socket(
+        new net::UnixDomainServerSocket(auth_callback_, true));
+    if (socket->ListenWithAddressAndPort(*name, 0, kBackLog) != net::OK)
+      return scoped_ptr<net::ServerSocket>();
+
+    return socket.Pass();
+  }
+
+  std::string socket_name_;
+  int last_tethering_socket_;
+  net::UnixDomainServerSocket::AuthCallback auth_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(UnixDomainServerSocketFactory);
 };
@@ -208,7 +197,7 @@ void DevToolsServer::Start(bool allow_debug_permission) {
   protocol_handler_.reset(content::DevToolsHttpHandler::Start(
       factory.Pass(),
       base::StringPrintf(kFrontEndURL, content::GetWebKitRevision().c_str()),
-      new DevToolsServerDelegate(auth_callback),
+      new DevToolsServerDelegate(),
       base::FilePath()));
 }
 
diff --git a/chrome/browser/devtools/browser_list_tabcontents_provider.cc b/chrome/browser/devtools/browser_list_tabcontents_provider.cc
index a975222..b69e4c32 100644
--- a/chrome/browser/devtools/browser_list_tabcontents_provider.cc
+++ b/chrome/browser/devtools/browser_list_tabcontents_provider.cc
@@ -5,41 +5,17 @@
 #include "chrome/browser/devtools/browser_list_tabcontents_provider.h"
 
 #include "base/path_service.h"
-#include "base/strings/string_number_conversions.h"
 #include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_iterator.h"
-#include "chrome/browser/ui/host_desktop.h"
 #include "chrome/common/chrome_paths.h"
-#include "content/public/common/url_constants.h"
 #include "grit/browser_resources.h"
-#include "net/base/net_errors.h"
-#include "net/socket/tcp_server_socket.h"
-#include "net/url_request/url_request_context_getter.h"
 #include "ui/base/resource/resource_bundle.h"
 
-namespace {
-
-const uint16 kMinTetheringPort = 9333;
-const uint16 kMaxTetheringPort = 9444;
-
-const int kBackLog = 10;
-
-base::LazyInstance<bool>::Leaky g_tethering_enabled = LAZY_INSTANCE_INITIALIZER;
-
-}
-
-// static
-void BrowserListTabContentsProvider::EnableTethering() {
-  g_tethering_enabled.Get() = true;
-}
-
 BrowserListTabContentsProvider::BrowserListTabContentsProvider(
     chrome::HostDesktopType host_desktop_type)
-    : host_desktop_type_(host_desktop_type),
-      last_tethering_port_(kMinTetheringPort) {
-  g_tethering_enabled.Get() = false;
+    : host_desktop_type_(host_desktop_type) {
 }
 
 BrowserListTabContentsProvider::~BrowserListTabContentsProvider() {
@@ -76,21 +52,3 @@ base::FilePath BrowserListTabContentsProvider::GetDebugFrontendDir() {
   return base::FilePath();
 #endif
 }
-
-scoped_ptr<net::ServerSocket>
-BrowserListTabContentsProvider::CreateSocketForTethering(
-    std::string* name) {
-  if (!g_tethering_enabled.Get())
-    return scoped_ptr<net::ServerSocket>();
-
-  if (last_tethering_port_ == kMaxTetheringPort)
-    last_tethering_port_ = kMinTetheringPort;
-  uint16 port = ++last_tethering_port_;
-  *name = base::IntToString(port);
-  scoped_ptr<net::TCPServerSocket> socket(
-      new net::TCPServerSocket(nullptr, net::NetLog::Source()));
-  if (socket->ListenWithAddressAndPort("127.0.0.1", port, kBackLog) != net::OK)
-    return scoped_ptr<net::ServerSocket>();
-
-  return socket.Pass();
-}
diff --git a/chrome/browser/devtools/browser_list_tabcontents_provider.h b/chrome/browser/devtools/browser_list_tabcontents_provider.h
index d020838..9ec2a7d 100644
--- a/chrome/browser/devtools/browser_list_tabcontents_provider.h
+++ b/chrome/browser/devtools/browser_list_tabcontents_provider.h
@@ -5,33 +5,23 @@
 #ifndef CHROME_BROWSER_DEVTOOLS_BROWSER_LIST_TABCONTENTS_PROVIDER_H_
 #define CHROME_BROWSER_DEVTOOLS_BROWSER_LIST_TABCONTENTS_PROVIDER_H_
 
-#include <set>
-#include <string>
-
-#include "base/basictypes.h"
-#include "base/compiler_specific.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "content/public/browser/devtools_http_handler_delegate.h"
 
 class BrowserListTabContentsProvider
     : public content::DevToolsHttpHandlerDelegate {
  public:
-  static void EnableTethering();
-
   explicit BrowserListTabContentsProvider(
       chrome::HostDesktopType host_desktop_type);
   ~BrowserListTabContentsProvider() override;
 
-  // DevToolsHttpProtocolHandler::Delegate overrides.
+  // DevToolsHttpHandlerDelegate implementation.
   std::string GetDiscoveryPageHTML() override;
   bool BundlesFrontendResources() override;
   base::FilePath GetDebugFrontendDir() override;
-  scoped_ptr<net::ServerSocket> CreateSocketForTethering(
-      std::string* name) override;
 
  private:
   chrome::HostDesktopType host_desktop_type_;
-  uint16 last_tethering_port_;
   DISALLOW_COPY_AND_ASSIGN(BrowserListTabContentsProvider);
 };
 
diff --git a/chrome/browser/devtools/device/devtools_android_bridge.cc b/chrome/browser/devtools/device/devtools_android_bridge.cc
index 956ac4e..96e59b5 100644
--- a/chrome/browser/devtools/device/devtools_android_bridge.cc
+++ b/chrome/browser/devtools/device/devtools_android_bridge.cc
@@ -22,7 +22,6 @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
-#include "chrome/browser/devtools/browser_list_tabcontents_provider.h"
 #include "chrome/browser/devtools/device/adb/adb_device_info_query.h"
 #include "chrome/browser/devtools/device/adb/adb_device_provider.h"
 #include "chrome/browser/devtools/device/port_forwarding_controller.h"
@@ -32,6 +31,7 @@
 #include "chrome/browser/devtools/devtools_protocol.h"
 #include "chrome/browser/devtools/devtools_target_impl.h"
 #include "chrome/browser/devtools/devtools_window.h"
+#include "chrome/browser/devtools/remote_debugging_server.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
@@ -985,7 +985,7 @@ void DevToolsAndroidBridge::ScheduleTaskDefault(const base::Closure& task) {
 void DevToolsAndroidBridge::CreateDeviceProviders() {
   AndroidDeviceManager::DeviceProviders device_providers;
 #if defined(DEBUG_DEVTOOLS)
-  BrowserListTabContentsProvider::EnableTethering();
+  RemoteDebuggingServer::EnableTetheringForDebug();
   // We cannot rely on command line switch here as we might want to connect
   // to another instance of Chrome. Using hard-coded port number instead.
   const int kDefaultDebuggingPort = 9222;
diff --git a/chrome/browser/devtools/device/port_forwarding_browsertest.cc b/chrome/browser/devtools/device/port_forwarding_browsertest.cc
index 7f90128..19121e5 100644
--- a/chrome/browser/devtools/device/port_forwarding_browsertest.cc
+++ b/chrome/browser/devtools/device/port_forwarding_browsertest.cc
@@ -6,9 +6,9 @@
 #include "base/compiler_specific.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
-#include "chrome/browser/devtools/browser_list_tabcontents_provider.h"
 #include "chrome/browser/devtools/device/devtools_android_bridge.h"
 #include "chrome/browser/devtools/device/self_device_provider.h"
+#include "chrome/browser/devtools/remote_debugging_server.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
@@ -99,7 +99,7 @@ IN_PROC_BROWSER_TEST_F(PortForwardingTest,
   Listener wait_for_port_forwarding(profile);
   content::RunMessageLoop();
 
-  BrowserListTabContentsProvider::EnableTethering();
+  RemoteDebuggingServer::EnableTetheringForDebug();
 
   ui_test_utils::NavigateToURL(browser(), forwarding_url);
 
diff --git a/chrome/browser/devtools/remote_debugging_server.cc b/chrome/browser/devtools/remote_debugging_server.cc
index a1dc007..ca8de35 100644
--- a/chrome/browser/devtools/remote_debugging_server.cc
+++ b/chrome/browser/devtools/remote_debugging_server.cc
@@ -4,34 +4,75 @@
 
 #include "chrome/browser/devtools/remote_debugging_server.h"
 
+#include "base/lazy_instance.h"
 #include "base/path_service.h"
+#include "base/strings/string_number_conversions.h"
 #include "chrome/browser/devtools/browser_list_tabcontents_provider.h"
 #include "chrome/browser/ui/webui/devtools_ui.h"
 #include "chrome/common/chrome_paths.h"
 #include "content/public/browser/devtools_http_handler.h"
+#include "net/base/net_errors.h"
 #include "net/socket/tcp_server_socket.h"
 
 namespace {
 
+base::LazyInstance<bool>::Leaky g_tethering_enabled = LAZY_INSTANCE_INITIALIZER;
+
+const uint16 kMinTetheringPort = 9333;
+const uint16 kMaxTetheringPort = 9444;
+const int kBackLog = 10;
+
 class TCPServerSocketFactory
     : public content::DevToolsHttpHandler::ServerSocketFactory {
  public:
-  TCPServerSocketFactory(const std::string& address, uint16 port, int backlog)
-      : content::DevToolsHttpHandler::ServerSocketFactory(
-            address, port, backlog) {}
+  TCPServerSocketFactory(const std::string& address, uint16 port)
+      : address_(address),
+        port_(port),
+        last_tethering_port_(kMinTetheringPort) {
+  }
 
  private:
   // content::DevToolsHttpHandler::ServerSocketFactory.
-  scoped_ptr<net::ServerSocket> Create() const override {
-    return scoped_ptr<net::ServerSocket>(
-        new net::TCPServerSocket(NULL, net::NetLog::Source()));
+  scoped_ptr<net::ServerSocket> CreateForHttpServer() override {
+    scoped_ptr<net::ServerSocket> socket(
+        new net::TCPServerSocket(nullptr, net::NetLog::Source()));
+    if (socket->ListenWithAddressAndPort(address_, port_, kBackLog) != net::OK)
+      return scoped_ptr<net::ServerSocket>();
+
+    return socket;
+  }
+
+  scoped_ptr<net::ServerSocket> CreateForTethering(std::string* name) override {
+    if (!g_tethering_enabled.Get())
+      return scoped_ptr<net::ServerSocket>();
+
+    if (last_tethering_port_ == kMaxTetheringPort)
+      last_tethering_port_ = kMinTetheringPort;
+    uint16 port = ++last_tethering_port_;
+    *name = base::IntToString(port);
+    scoped_ptr<net::TCPServerSocket> socket(
+        new net::TCPServerSocket(nullptr, net::NetLog::Source()));
+    if (socket->ListenWithAddressAndPort("127.0.0.1", port, kBackLog) !=
+        net::OK) {
+      return scoped_ptr<net::ServerSocket>();
+    }
+    return socket.Pass();
   }
 
+  std::string address_;
+  uint16 port_;
+  uint16 last_tethering_port_;
+
   DISALLOW_COPY_AND_ASSIGN(TCPServerSocketFactory);
 };
 
 }  // namespace
 
+// static
+void RemoteDebuggingServer::EnableTetheringForDebug() {
+  g_tethering_enabled.Get() = true;
+}
+
 RemoteDebuggingServer::RemoteDebuggingServer(
     chrome::HostDesktopType host_desktop_type,
     const std::string& ip,
@@ -45,11 +86,9 @@ RemoteDebuggingServer::RemoteDebuggingServer(
     DCHECK(result);
   }
 
-  scoped_ptr<content::DevToolsHttpHandler::ServerSocketFactory> factory(
-      new TCPServerSocketFactory(ip, port, 1));
   devtools_http_handler_.reset(content::DevToolsHttpHandler::Start(
-      factory.Pass(),
-      "",
+      make_scoped_ptr(new TCPServerSocketFactory(ip, port)),
+      std::string(),
       new BrowserListTabContentsProvider(host_desktop_type),
       output_dir));
 }
diff --git a/chrome/browser/devtools/remote_debugging_server.h b/chrome/browser/devtools/remote_debugging_server.h
index c04f781..c8afa6f 100644
--- a/chrome/browser/devtools/remote_debugging_server.h
+++ b/chrome/browser/devtools/remote_debugging_server.h
@@ -17,6 +17,8 @@ class DevToolsHttpHandler;
 
 class RemoteDebuggingServer {
  public:
+  static void EnableTetheringForDebug();
+
   RemoteDebuggingServer(chrome::HostDesktopType host_desktop_type,
                         const std::string& ip,
                         uint16 port);
diff --git a/chromecast/browser/devtools/cast_dev_tools_delegate.cc b/chromecast/browser/devtools/cast_dev_tools_delegate.cc
index 6f28faf..727b47a 100644
--- a/chromecast/browser/devtools/cast_dev_tools_delegate.cc
+++ b/chromecast/browser/devtools/cast_dev_tools_delegate.cc
@@ -106,11 +106,6 @@ base::FilePath CastDevToolsDelegate::GetDebugFrontendDir() {
   return base::FilePath();
 }
 
-scoped_ptr<net::ServerSocket>
-CastDevToolsDelegate::CreateSocketForTethering(std::string* name) {
-  return scoped_ptr<net::ServerSocket>();
-}
-
 // CastDevToolsManagerDelegate -----------------------------------------------
 
 CastDevToolsManagerDelegate::CastDevToolsManagerDelegate() {
diff --git a/chromecast/browser/devtools/cast_dev_tools_delegate.h b/chromecast/browser/devtools/cast_dev_tools_delegate.h
index ea8f661..809667b 100644
--- a/chromecast/browser/devtools/cast_dev_tools_delegate.h
+++ b/chromecast/browser/devtools/cast_dev_tools_delegate.h
@@ -29,8 +29,6 @@ class CastDevToolsDelegate : public content::DevToolsHttpHandlerDelegate {
   std::string GetDiscoveryPageHTML() override;
   bool BundlesFrontendResources() override;
   base::FilePath GetDebugFrontendDir() override;
-  scoped_ptr<net::ServerSocket> CreateSocketForTethering(
-      std::string* name) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CastDevToolsDelegate);
diff --git a/chromecast/browser/devtools/remote_debugging_server.cc b/chromecast/browser/devtools/remote_debugging_server.cc
index 60b4933..0591644 100644
--- a/chromecast/browser/devtools/remote_debugging_server.cc
+++ b/chromecast/browser/devtools/remote_debugging_server.cc
@@ -17,6 +17,7 @@
 #include "content/public/browser/devtools_http_handler.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/user_agent.h"
+#include "net/base/net_errors.h"
 #include "net/socket/tcp_server_socket.h"
 
 #if defined(OS_ANDROID)
@@ -33,39 +34,54 @@ const char kFrontEndURL[] =
     "https://chrome-devtools-frontend.appspot.com/serve_rev/%s/inspector.html";
 const uint16 kDefaultRemoteDebuggingPort = 9222;
 
+const int kBackLog = 10;
+
 #if defined(OS_ANDROID)
 class UnixDomainServerSocketFactory
     : public content::DevToolsHttpHandler::ServerSocketFactory {
  public:
   explicit UnixDomainServerSocketFactory(const std::string& socket_name)
-      : content::DevToolsHttpHandler::ServerSocketFactory(socket_name, 0, 1) {}
+      : socket_name_(socket_name) {}
 
  private:
   // content::DevToolsHttpHandler::ServerSocketFactory.
-  scoped_ptr<net::ServerSocket> Create() const override {
-    return scoped_ptr<net::ServerSocket>(
+  scoped_ptr<net::ServerSocket> CreateForHttpServer() override {
+    scoped_ptr<net::ServerSocket> socket(
         new net::UnixDomainServerSocket(
             base::Bind(&content::CanUserConnectToDevTools),
             true /* use_abstract_namespace */));
+    if (socket->ListenWithAddressAndPort(socket_name_, 0, kBackLog) != net::OK)
+      return scoped_ptr<net::ServerSocket>();
+
+    return socket;
   }
 
+  std::string socket_name_;
+
   DISALLOW_COPY_AND_ASSIGN(UnixDomainServerSocketFactory);
 };
 #else
 class TCPServerSocketFactory
     : public content::DevToolsHttpHandler::ServerSocketFactory {
  public:
-  TCPServerSocketFactory(const std::string& address, uint16 port, int backlog)
-      : content::DevToolsHttpHandler::ServerSocketFactory(
-            address, port, backlog) {}
+  TCPServerSocketFactory(const std::string& address, uint16 port)
+      : address_(address), port_(port) {
+  }
 
  private:
   // content::DevToolsHttpHandler::ServerSocketFactory.
-  scoped_ptr<net::ServerSocket> Create() const override {
-    return scoped_ptr<net::ServerSocket>(
-        new net::TCPServerSocket(NULL, net::NetLog::Source()));
+  scoped_ptr<net::ServerSocket> CreateForHttpServer() override {
+    scoped_ptr<net::ServerSocket> socket(
+        new net::TCPServerSocket(nullptr, net::NetLog::Source()));
+    if (socket->ListenWithAddressAndPort(address_, port_, kBackLog) != net::OK)
+      return scoped_ptr<net::ServerSocket>();
+
+    return socket;
   }
 
+  std::string address_;
+  uint16 port_;
+
   DISALLOW_COPY_AND_ASSIGN(TCPServerSocketFactory);
 };
 #endif
@@ -83,7 +99,7 @@ CreateSocketFactory(uint16 port) {
       new UnixDomainServerSocketFactory(socket_name));
 #else
   return scoped_ptr<content::DevToolsHttpHandler::ServerSocketFactory>(
-      new TCPServerSocketFactory("0.0.0.0", port, 1));
+      new TCPServerSocketFactory("0.0.0.0", port));
 #endif
 }
 
diff --git a/content/browser/devtools/devtools_http_handler_impl.cc b/content/browser/devtools/devtools_http_handler_impl.cc
index 4313668..73087b7 100644
--- a/content/browser/devtools/devtools_http_handler_impl.cc
+++ b/content/browser/devtools/devtools_http_handler_impl.cc
@@ -95,6 +95,7 @@ class DevToolsHttpHandlerImpl : public DevToolsHttpHandler {
 
   void ServerStarted(base::Thread* thread,
                      ServerWrapper* server_wrapper,
+                     ServerSocketFactory* socket_factory,
                      scoped_ptr<net::IPEndPoint> ip_address);
 
  private:
@@ -142,6 +143,7 @@ class DevToolsHttpHandlerImpl : public DevToolsHttpHandler {
   typedef std::map<int, DevToolsAgentHostClientImpl*> ConnectionToClientMap;
   ConnectionToClientMap connection_to_client_;
   const scoped_ptr<DevToolsHttpHandlerDelegate> delegate_;
+  ServerSocketFactory* socket_factory_;
   typedef std::map<std::string, DevToolsTarget*> TargetMap;
   TargetMap target_map_;
   typedef std::map<int, BrowserTarget*> BrowserTargets;
@@ -246,12 +248,18 @@ void ServerWrapper::Close(int connection_id) {
 
 // Thread and ServerWrapper lifetime management ------------------------------
 
-void TerminateOnUI(base::Thread* thread, ServerWrapper* server_wrapper) {
+void TerminateOnUI(base::Thread* thread,
+                   ServerWrapper* server_wrapper,
+                   DevToolsHttpHandler::ServerSocketFactory* socket_factory) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (server_wrapper) {
     DCHECK(thread);
     thread->message_loop()->DeleteSoon(FROM_HERE, server_wrapper);
   }
+  if (socket_factory) {
+    DCHECK(thread);
+    thread->message_loop()->DeleteSoon(FROM_HERE, socket_factory);
+  }
   if (thread) {
     BrowserThread::DeleteSoon(BrowserThread::FILE, FROM_HERE, thread);
   }
@@ -261,26 +269,28 @@ void ServerStartedOnUI(
     base::WeakPtr<DevToolsHttpHandlerImpl> handler,
     base::Thread* thread,
     ServerWrapper* server_wrapper,
+    DevToolsHttpHandler::ServerSocketFactory* socket_factory,
     scoped_ptr<net::IPEndPoint> ip_address) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (handler && thread && server_wrapper) {
-    handler->ServerStarted(thread, server_wrapper, ip_address.Pass());
+    handler->ServerStarted(thread, server_wrapper, socket_factory,
+                           ip_address.Pass());
   } else {
-    TerminateOnUI(thread, server_wrapper);
+    TerminateOnUI(thread, server_wrapper, socket_factory);
   }
 }
 
 void StartServerOnHandlerThread(
     base::WeakPtr<DevToolsHttpHandlerImpl> handler,
     base::Thread* thread,
-    scoped_ptr<DevToolsHttpHandler::ServerSocketFactory> server_socket_factory,
+    DevToolsHttpHandler::ServerSocketFactory* server_socket_factory,
     const base::FilePath& output_directory,
     const base::FilePath& frontend_dir,
     bool bundles_resources) {
   DCHECK_EQ(thread->message_loop(), base::MessageLoop::current());
   ServerWrapper* server_wrapper = nullptr;
   scoped_ptr<net::ServerSocket> server_socket =
-      server_socket_factory->CreateAndListen();
+      server_socket_factory->CreateForHttpServer();
   scoped_ptr<net::IPEndPoint> ip_address(new net::IPEndPoint);
   if (server_socket) {
     server_wrapper = new ServerWrapper(handler, server_socket.Pass(),
@@ -296,12 +306,16 @@ void StartServerOnHandlerThread(
   }
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&ServerStartedOnUI,
-                 handler, thread, server_wrapper, base::Passed(&ip_address)));
+                 handler,
+                 thread,
+                 server_wrapper,
+                 server_socket_factory,
+                 base::Passed(&ip_address)));
 }
 
 void StartServerOnFile(
     base::WeakPtr<DevToolsHttpHandlerImpl> handler,
-    scoped_ptr<DevToolsHttpHandler::ServerSocketFactory> server_socket_factory,
+    DevToolsHttpHandler::ServerSocketFactory* server_socket_factory,
     const base::FilePath& output_directory,
     const base::FilePath& frontend_dir,
     bool bundles_resources) {
@@ -315,7 +329,7 @@ void StartServerOnFile(
         base::Bind(&StartServerOnHandlerThread,
                    handler,
                    base::Unretained(thread.release()),
-                   base::Passed(&server_socket_factory),
+                   server_socket_factory,
                    output_directory,
                    frontend_dir,
                    bundles_resources));
@@ -397,14 +411,14 @@ class BrowserTarget {
  public:
   BrowserTarget(base::MessageLoop* message_loop,
                 ServerWrapper* server_wrapper,
-                DevToolsHttpHandlerDelegate* delegate,
+                DevToolsHttpHandler::ServerSocketFactory* socket_factory,
                 int connection_id)
       : message_loop_(message_loop),
         server_wrapper_(server_wrapper),
         connection_id_(connection_id),
         system_info_handler_(new devtools::system_info::SystemInfoHandler()),
         tethering_handler_(new devtools::tethering::TetheringHandler(
-            delegate, message_loop->message_loop_proxy())),
+            socket_factory, message_loop->message_loop_proxy())),
         tracing_handler_(new devtools::tracing::TracingHandler(
             devtools::tracing::TracingHandler::Browser)),
         protocol_handler_(new DevToolsProtocolHandler(
@@ -482,32 +496,21 @@ DevToolsHttpHandler* DevToolsHttpHandler::Start(
 
 // DevToolsHttpHandler::ServerSocketFactory ----------------------------------
 
-DevToolsHttpHandler::ServerSocketFactory::ServerSocketFactory(
-    const std::string& address,
-    uint16 port,
-    int backlog)
-    : address_(address),
-      port_(port),
-      backlog_(backlog) {
-}
-
-DevToolsHttpHandler::ServerSocketFactory::~ServerSocketFactory() {
+scoped_ptr<net::ServerSocket>
+DevToolsHttpHandler::ServerSocketFactory::CreateForHttpServer() {
+  return scoped_ptr<net::ServerSocket>();
 }
 
 scoped_ptr<net::ServerSocket>
-DevToolsHttpHandler::ServerSocketFactory::CreateAndListen() const {
-  scoped_ptr<net::ServerSocket> socket = Create();
-  if (socket &&
-      socket->ListenWithAddressAndPort(address_, port_, backlog_) == net::OK) {
-    return socket.Pass();
-  }
+DevToolsHttpHandler::ServerSocketFactory::CreateForTethering(
+    std::string* name) {
   return scoped_ptr<net::ServerSocket>();
 }
 
 // DevToolsHttpHandlerImpl ---------------------------------------------------
 
 DevToolsHttpHandlerImpl::~DevToolsHttpHandlerImpl() {
-  TerminateOnUI(thread_, server_wrapper_);
+  TerminateOnUI(thread_, server_wrapper_, socket_factory_);
   STLDeleteValues(&target_map_);
   STLDeleteValues(&browser_targets_);
   STLDeleteValues(&connection_to_client_);
@@ -880,7 +883,7 @@ void DevToolsHttpHandlerImpl::OnWebSocketRequest(
   if (browser_pos == 0) {
     browser_targets_[connection_id] = new BrowserTarget(thread_->message_loop(),
                                                         server_wrapper_,
-                                                        delegate_.get(),
+                                                        socket_factory_,
                                                         connection_id);
     AcceptWebSocket(connection_id, request);
     return;
@@ -954,6 +957,7 @@ DevToolsHttpHandlerImpl::DevToolsHttpHandlerImpl(
       frontend_url_(frontend_url),
       server_wrapper_(nullptr),
       delegate_(delegate),
+      socket_factory_(nullptr),
       weak_factory_(this) {
   if (frontend_url_.empty())
     frontend_url_ = "/devtools/inspector.html";
@@ -962,7 +966,7 @@ DevToolsHttpHandlerImpl::DevToolsHttpHandlerImpl(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&StartServerOnFile,
                  weak_factory_.GetWeakPtr(),
-                 base::Passed(&server_socket_factory),
+                 server_socket_factory.release(),
                  output_directory,
                  delegate_->GetDebugFrontendDir(),
                  delegate_->BundlesFrontendResources()));
@@ -971,9 +975,11 @@ DevToolsHttpHandlerImpl::DevToolsHttpHandlerImpl(
 void DevToolsHttpHandlerImpl::ServerStarted(
     base::Thread* thread,
     ServerWrapper* server_wrapper,
+    ServerSocketFactory* socket_factory,
     scoped_ptr<net::IPEndPoint> ip_address) {
   thread_ = thread;
   server_wrapper_ = server_wrapper;
+  socket_factory_ = socket_factory;
   server_ip_address_.swap(ip_address);
 }
 
diff --git a/content/browser/devtools/devtools_http_handler_unittest.cc b/content/browser/devtools/devtools_http_handler_unittest.cc
index 6800c3c..e8c131b 100644
--- a/content/browser/devtools/devtools_http_handler_unittest.cc
+++ b/content/browser/devtools/devtools_http_handler_unittest.cc
@@ -33,12 +33,6 @@ class DummyServerSocket : public net::ServerSocket {
     return net::OK;
   }
 
-  int ListenWithAddressAndPort(const std::string& ip_address,
-                               uint16 port,
-                               int backlog) override {
-    return net::OK;
-  }
-
   int GetLocalAddress(net::IPEndPoint* address) const override {
     net::IPAddressNumber number;
     EXPECT_TRUE(net::ParseIPLiteralToNumber("127.0.0.1", &number));
@@ -61,8 +55,7 @@ class DummyServerSocketFactory
  public:
   DummyServerSocketFactory(base::Closure quit_closure_1,
                            base::Closure quit_closure_2)
-      : DevToolsHttpHandler::ServerSocketFactory("", 0, 0),
-        quit_closure_1_(quit_closure_1),
+      : quit_closure_1_(quit_closure_1),
         quit_closure_2_(quit_closure_2) {}
 
   ~DummyServerSocketFactory() override {
@@ -71,7 +64,7 @@ class DummyServerSocketFactory
   }
 
  protected:
-  scoped_ptr<net::ServerSocket> Create() const override {
+  scoped_ptr<net::ServerSocket> CreateForHttpServer() override {
     base::MessageLoopProxy::current()->PostTask(FROM_HERE,
         base::Bind(&QuitFromHandlerThread, quit_closure_1_));
     return scoped_ptr<net::ServerSocket>(new DummyServerSocket());
@@ -89,10 +82,10 @@ class FailingServerSocketFactory : public DummyServerSocketFactory {
   }
 
  private:
-  scoped_ptr<net::ServerSocket> Create() const override {
+  scoped_ptr<net::ServerSocket> CreateForHttpServer() override {
     base::MessageLoopProxy::current()->PostTask(FROM_HERE,
         base::Bind(&QuitFromHandlerThread, quit_closure_1_));
-    return nullptr;
+    return scoped_ptr<net::ServerSocket>();
   }
 };
 
@@ -103,11 +96,6 @@ class DummyDelegate : public DevToolsHttpHandlerDelegate {
   bool BundlesFrontendResources() override { return true; }
 
   base::FilePath GetDebugFrontendDir() override { return base::FilePath(); }
-
-  scoped_ptr<net::ServerSocket>
-  CreateSocketForTethering(std::string* name) override {
-    return scoped_ptr<net::ServerSocket>();
-  }
 };
 
 }
diff --git a/content/browser/devtools/protocol/tethering_handler.cc b/content/browser/devtools/protocol/tethering_handler.cc
index 0f00194..efdf0d1 100644
--- a/content/browser/devtools/protocol/tethering_handler.cc
+++ b/content/browser/devtools/protocol/tethering_handler.cc
@@ -5,7 +5,7 @@
 #include "content/browser/devtools/protocol/tethering_handler.h"
 
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/devtools_http_handler_delegate.h"
+#include "content/public/browser/devtools_http_handler.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/socket/server_socket.h"
@@ -30,17 +30,15 @@ using Response = DevToolsProtocolClient::Response;
 
 class SocketPump {
  public:
-  SocketPump(DevToolsHttpHandlerDelegate* delegate,
-             net::StreamSocket* client_socket)
+  SocketPump(net::StreamSocket* client_socket)
       : client_socket_(client_socket),
-        delegate_(delegate),
         pending_writes_(0),
         pending_destruction_(false) {
   }
 
-  std::string Init() {
+  std::string Init(DevToolsHttpHandler::ServerSocketFactory* socket_factory) {
     std::string channel_name;
-    server_socket_ = delegate_->CreateSocketForTethering(&channel_name);
+    server_socket_ = socket_factory->CreateForTethering(&channel_name);
     if (!server_socket_.get() || channel_name.empty())
       SelfDestruct();
 
@@ -150,7 +148,6 @@ class SocketPump {
   scoped_ptr<net::StreamSocket> client_socket_;
   scoped_ptr<net::ServerSocket> server_socket_;
   scoped_ptr<net::StreamSocket> accepted_socket_;
-  DevToolsHttpHandlerDelegate* delegate_;
   int pending_writes_;
   bool pending_destruction_;
 };
@@ -160,9 +157,9 @@ class BoundSocket {
   typedef base::Callback<void(uint16, const std::string&)> AcceptedCallback;
 
   BoundSocket(AcceptedCallback accepted_callback,
-              DevToolsHttpHandlerDelegate* delegate)
+              DevToolsHttpHandler::ServerSocketFactory* socket_factory)
       : accepted_callback_(accepted_callback),
-        delegate_(delegate),
+        socket_factory_(socket_factory),
         socket_(new net::TCPServerSocket(NULL, net::NetLog::Source())),
         port_(0) {
   }
@@ -215,14 +212,14 @@ class BoundSocket {
     if (result != net::OK)
       return;
 
-    SocketPump* pump = new SocketPump(delegate_, accept_socket_.release());
-    std::string name = pump->Init();
+    SocketPump* pump = new SocketPump(accept_socket_.release());
+    std::string name = pump->Init(socket_factory_);
     if (!name.empty())
       accepted_callback_.Run(port_, name);
   }
 
   AcceptedCallback accepted_callback_;
-  DevToolsHttpHandlerDelegate* delegate_;
+  DevToolsHttpHandler::ServerSocketFactory* socket_factory_;
   scoped_ptr<net::ServerSocket> socket_;
   scoped_ptr<net::StreamSocket> accept_socket_;
   uint16 port_;
@@ -236,7 +233,7 @@ class TetheringHandler::TetheringImpl {
  public:
   TetheringImpl(
       base::WeakPtr<TetheringHandler> handler,
-      DevToolsHttpHandlerDelegate* delegate);
+      DevToolsHttpHandler::ServerSocketFactory* socket_factory);
   ~TetheringImpl();
 
   void Bind(DevToolsCommandId command_id, uint16 port);
@@ -248,7 +245,7 @@ class TetheringHandler::TetheringImpl {
                          const std::string& message);
 
   base::WeakPtr<TetheringHandler> handler_;
-  DevToolsHttpHandlerDelegate* delegate_;
+  DevToolsHttpHandler::ServerSocketFactory* socket_factory_;
 
   typedef std::map<uint16, BoundSocket*> BoundSockets;
   BoundSockets bound_sockets_;
@@ -256,14 +253,13 @@ class TetheringHandler::TetheringImpl {
 
 TetheringHandler::TetheringImpl::TetheringImpl(
     base::WeakPtr<TetheringHandler> handler,
-    DevToolsHttpHandlerDelegate* delegate)
+    DevToolsHttpHandler::ServerSocketFactory* socket_factory)
     : handler_(handler),
-      delegate_(delegate) {
+      socket_factory_(socket_factory) {
 }
 
 TetheringHandler::TetheringImpl::~TetheringImpl() {
-  STLDeleteContainerPairSecondPointers(bound_sockets_.begin(),
-                                       bound_sockets_.end());
+  STLDeleteValues(&bound_sockets_);
 }
 
 void TetheringHandler::TetheringImpl::Bind(
@@ -275,7 +271,8 @@ void TetheringHandler::TetheringImpl::Bind(
 
   BoundSocket::AcceptedCallback callback = base::Bind(
       &TetheringHandler::TetheringImpl::Accepted, base::Unretained(this));
-  scoped_ptr<BoundSocket> bound_socket(new BoundSocket(callback, delegate_));
+  scoped_ptr<BoundSocket> bound_socket(
+      new BoundSocket(callback, socket_factory_));
   if (!bound_socket->Listen(port)) {
     SendInternalError(command_id, "Could not bind port");
     return;
@@ -330,9 +327,9 @@ void TetheringHandler::TetheringImpl::SendInternalError(
 TetheringHandler::TetheringImpl* TetheringHandler::impl_ = nullptr;
 
 TetheringHandler::TetheringHandler(
-    DevToolsHttpHandlerDelegate* delegate,
+    DevToolsHttpHandler::ServerSocketFactory* socket_factory,
     scoped_refptr<base::MessageLoopProxy> message_loop_proxy)
-    : delegate_(delegate),
+    : socket_factory_(socket_factory),
       message_loop_proxy_(message_loop_proxy),
       is_active_(false),
       weak_factory_(this) {
@@ -360,7 +357,7 @@ bool TetheringHandler::Activate() {
   if (impl_)
     return false;
   is_active_ = true;
-  impl_ = new TetheringImpl(weak_factory_.GetWeakPtr(), delegate_);
+  impl_ = new TetheringImpl(weak_factory_.GetWeakPtr(), socket_factory_);
   return true;
 }
 
diff --git a/content/browser/devtools/protocol/tethering_handler.h b/content/browser/devtools/protocol/tethering_handler.h
index a98da1e..ac6afc8 100644
--- a/content/browser/devtools/protocol/tethering_handler.h
+++ b/content/browser/devtools/protocol/tethering_handler.h
@@ -8,11 +8,9 @@
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "content/browser/devtools/protocol/devtools_protocol_handler.h"
+#include "content/public/browser/devtools_http_handler.h"
 
 namespace content {
-
-class DevToolsHttpHandlerDelegate;
-
 namespace devtools {
 namespace tethering {
 
@@ -21,7 +19,7 @@ class TetheringHandler {
  public:
   using Response = DevToolsProtocolClient::Response;
 
-  TetheringHandler(DevToolsHttpHandlerDelegate* delegate,
+  TetheringHandler(DevToolsHttpHandler::ServerSocketFactory* delegate,
                    scoped_refptr<base::MessageLoopProxy> message_loop_proxy);
   ~TetheringHandler();
 
@@ -42,7 +40,7 @@ class TetheringHandler {
                          const std::string& message);
 
   scoped_ptr<Client> client_;
-  DevToolsHttpHandlerDelegate* delegate_;
+  DevToolsHttpHandler::ServerSocketFactory* socket_factory_;
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
   bool is_active_;
   base::WeakPtrFactory<TetheringHandler> weak_factory_;
diff --git a/content/public/browser/devtools_http_handler.h b/content/public/browser/devtools_http_handler.h
index 25dc327..1c79ef0 100644
--- a/content/public/browser/devtools_http_handler.h
+++ b/content/public/browser/devtools_http_handler.h
@@ -29,28 +29,20 @@ class DevToolsHttpHandler {
  public:
 
   // Factory of net::ServerSocket. This is to separate instantiating dev tools
-  // and instantiating server socket.
+  // and instantiating server sockets.
+  // All methods including destructor are called on a separate thread
+  // different from any BrowserThread instance.
   class CONTENT_EXPORT ServerSocketFactory {
    public:
-    ServerSocketFactory(const std::string& address, uint16 port, int backlog);
-    virtual ~ServerSocketFactory();
+    virtual ~ServerSocketFactory() {}
 
-    // Returns a new instance of ServerSocket or NULL if an error occurred.
-    // It calls ServerSocket::ListenWithAddressAndPort() with address, port and
-    // backlog passed to constructor.
-    virtual scoped_ptr<net::ServerSocket> CreateAndListen() const;
+    // Returns a new instance of ServerSocket or nullptr if an error occurred.
+    virtual scoped_ptr<net::ServerSocket> CreateForHttpServer();
 
-   protected:
-    // Creates a server socket. ServerSocket::Listen() will be called soon
-    // unless it returns NULL.
-    virtual scoped_ptr<net::ServerSocket> Create() const = 0;
-
-    const std::string address_;
-    const uint16 port_;
-    const int backlog_;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(ServerSocketFactory);
+    // Creates a named socket for reversed tethering implementation (used with
+    // remote debugging, primarily for mobile).
+    virtual scoped_ptr<net::ServerSocket> CreateForTethering(
+        std::string* out_name);
   };
 
   // Returns true if the given protocol version is supported.
diff --git a/content/public/browser/devtools_http_handler_delegate.h b/content/public/browser/devtools_http_handler_delegate.h
index d1c0370..4f96413 100644
--- a/content/public/browser/devtools_http_handler_delegate.h
+++ b/content/public/browser/devtools_http_handler_delegate.h
@@ -29,11 +29,6 @@ class DevToolsHttpHandlerDelegate {
 
   // Returns path to the front-end files on the local filesystem for debugging.
   virtual base::FilePath GetDebugFrontendDir() = 0;
-
-  // Creates named socket for reversed tethering implementation (used with
-  // remote debugging, primarily for mobile).
-  virtual scoped_ptr<net::ServerSocket> CreateSocketForTethering(
-      std::string* name) = 0;
 };
 
 }  // namespace content
diff --git a/content/shell/browser/shell_devtools_manager_delegate.cc b/content/shell/browser/shell_devtools_manager_delegate.cc
index 63086a9..d740326 100644
--- a/content/shell/browser/shell_devtools_manager_delegate.cc
+++ b/content/shell/browser/shell_devtools_manager_delegate.cc
@@ -24,6 +24,7 @@
 #include "content/public/common/user_agent.h"
 #include "content/shell/browser/shell.h"
 #include "grit/shell_resources.h"
+#include "net/base/net_errors.h"
 #include "net/socket/tcp_server_socket.h"
 #include "ui/base/resource/resource_bundle.h"
 
@@ -44,39 +45,54 @@ const char kTargetTypePage[] = "page";
 const char kTargetTypeServiceWorker[] = "service_worker";
 const char kTargetTypeOther[] = "other";
 
+const int kBackLog = 10;
+
 #if defined(OS_ANDROID)
 class UnixDomainServerSocketFactory
     : public DevToolsHttpHandler::ServerSocketFactory {
  public:
   explicit UnixDomainServerSocketFactory(const std::string& socket_name)
-      : DevToolsHttpHandler::ServerSocketFactory(socket_name, 0, 1) {}
+      : socket_name_(socket_name) {}
 
  private:
   // DevToolsHttpHandler::ServerSocketFactory.
-  virtual scoped_ptr<net::ServerSocket> Create() const override {
-    return scoped_ptr<net::ServerSocket>(
+  virtual scoped_ptr<net::ServerSocket> CreateForHttpServer() override {
+    scoped_ptr<net::ServerSocket> socket(
         new net::UnixDomainServerSocket(
             base::Bind(&CanUserConnectToDevTools),
             true /* use_abstract_namespace */));
+    if (socket->ListenWithAddressAndPort(socket_name_, 0, kBackLog) != net::OK)
+      return scoped_ptr<net::ServerSocket>();
+
+    return socket;
   }
 
+  std::string socket_name_;
+
   DISALLOW_COPY_AND_ASSIGN(UnixDomainServerSocketFactory);
 };
 #else
 class TCPServerSocketFactory
     : public DevToolsHttpHandler::ServerSocketFactory {
  public:
-  TCPServerSocketFactory(const std::string& address, uint16 port, int backlog)
-      : DevToolsHttpHandler::ServerSocketFactory(
-            address, port, backlog) {}
+  TCPServerSocketFactory(const std::string& address, uint16 port)
+      : address_(address), port_(port) {
+  }
 
  private:
   // DevToolsHttpHandler::ServerSocketFactory.
-  scoped_ptr<net::ServerSocket> Create() const override {
-    return scoped_ptr<net::ServerSocket>(
-        new net::TCPServerSocket(NULL, net::NetLog::Source()));
+  scoped_ptr<net::ServerSocket> CreateForHttpServer() override {
+    scoped_ptr<net::ServerSocket> socket(
+        new net::TCPServerSocket(nullptr, net::NetLog::Source()));
+    if (socket->ListenWithAddressAndPort(address_, port_, kBackLog) != net::OK)
+      return scoped_ptr<net::ServerSocket>();
+
+    return socket;
   }
 
+  std::string address_;
+  uint16 port_;
+
   DISALLOW_COPY_AND_ASSIGN(TCPServerSocketFactory);
 };
 #endif
@@ -109,7 +125,7 @@ CreateSocketFactory() {
     }
   }
   return scoped_ptr<DevToolsHttpHandler::ServerSocketFactory>(
-      new TCPServerSocketFactory("127.0.0.1", port, 1));
+      new TCPServerSocketFactory("127.0.0.1", port));
 #endif
 }
 
@@ -180,8 +196,6 @@ class ShellDevToolsDelegate : public DevToolsHttpHandlerDelegate {
   std::string GetDiscoveryPageHTML() override;
   bool BundlesFrontendResources() override;
   base::FilePath GetDebugFrontendDir() override;
-  scoped_ptr<net::ServerSocket> CreateSocketForTethering(
-      std::string* name) override;
 
  private:
   BrowserContext* browser_context_;
@@ -217,11 +231,6 @@ base::FilePath ShellDevToolsDelegate::GetDebugFrontendDir() {
   return base::FilePath();
 }
 
-scoped_ptr<net::ServerSocket>
-ShellDevToolsDelegate::CreateSocketForTethering(std::string* name) {
-  return scoped_ptr<net::ServerSocket>();
-}
-
 }  // namespace
 
 // ShellDevToolsManagerDelegate ----------------------------------------------