Replace StreamListenSocket with StreamSocket in HttpServer.

chrome/browser/android/dev_tools_server.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 "chrome/browser/android/dev_tools_server.h"
 
 #include <pwd.h>
 #include <cstring>
 
 #include "base/android/jni_string.h"
@@ skipping 22 matching lines @@
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/user_agent.h"
 #include "grit/browser_resources.h"
 #include "jni/DevToolsServer_jni.h"
-#include "net/socket/unix_domain_socket_posix.h"
+#include "net/base/net_errors.h"
+#include "net/socket/unix_domain_listen_socket_posix.h"
+#include "net/socket/unix_domain_server_socket_posix.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using content::DevToolsAgentHost;
 using content::RenderViewHost;
 using content::WebContents;
 
 namespace {
 
 // TL;DR: Do not change this string.
@@ skipping 305 matching lines @@
     }
 
     callback.Run(targets);
   }
 
   virtual scoped_ptr<net::StreamListenSocket> CreateSocketForTethering(
       net::StreamListenSocket::Delegate* delegate,
       std::string* name) OVERRIDE {
     *name = base::StringPrintf(
         kTetheringSocketName, getpid(), ++last_tethering_socket_);
-    return net::UnixDomainSocket::CreateAndListenWithAbstractNamespace(
+    return net::UnixDomainListenSocket::CreateAndListenWithAbstractNamespace(
                *name,
                "",
                delegate,
                base::Bind(&content::CanUserConnectToDevTools))
            .PassAs<net::StreamListenSocket>();
   }
 
  private:
   static void PopulatePageThumbnails() {
     Profile* profile =
         ProfileManager::GetLastUsedProfile()->GetOriginalProfile();
     history::TopSites* top_sites = profile->GetTopSites();
     if (top_sites)
       top_sites->SyncWithHistory();
   }
 
   int last_tethering_socket_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsServerDelegate);
 };
 
+// Factory for UnixDomainServerSocket. It tries a fallback socket when
+// original socket doesn't work.
+class UnixDomainServerSocketFactory
+    : public content::DevToolsHttpHandler::ServerSocketFactory {
+ public:
+  explicit UnixDomainServerSocketFactory(const std::string& socket_name)
+      : content::DevToolsHttpHandler::ServerSocketFactory(socket_name, 0, 1) {}
+
+ private:
+  // content::DevToolsHttpHandler::ServerSocketFactory.
+  virtual scoped_ptr<net::ServerSocket> Create() const OVERRIDE {
+    return scoped_ptr<net::ServerSocket>(
+        new net::UnixDomainServerSocket(
+            base::Bind(&content::CanUserConnectToDevTools),
+            true));
+  }
+
+  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)
+      return socket.Pass();
+
+    // Tries a fallback socket name.
+    const std::string fallback_address(
+        base::StringPrintf("%s_%d", address_.c_str(), getpid()));
+    if (socket->ListenWithAddressAndPort(fallback_address, port_, backlog_)
+        == net::OK)
+      return socket.Pass();
+
+    return scoped_ptr<net::ServerSocket>();
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(UnixDomainServerSocketFactory);
+};
+
 }  // namespace
 
 DevToolsServer::DevToolsServer()
     : socket_name_(base::StringPrintf(kDevToolsChannelNameFormat,
                                       kDefaultSocketNamePrefix)),
       protocol_handler_(NULL) {
   // Override the default socket name if one is specified on the command line.
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kRemoteDebuggingSocketName)) {
     socket_name_ = command_line.GetSwitchValueASCII(
@@ skipping 14 matching lines @@
 }
 
 DevToolsServer::~DevToolsServer() {
   Stop();
 }
 
 void DevToolsServer::Start() {
   if (protocol_handler_)
     return;
 
+  scoped_ptr<content::DevToolsHttpHandler::ServerSocketFactory> factory(
+      new UnixDomainServerSocketFactory(socket_name_));
   protocol_handler_ = content::DevToolsHttpHandler::Start(
-      new net::UnixDomainSocketWithAbstractNamespaceFactory(
-          socket_name_,
-          base::StringPrintf("%s_%d", socket_name_.c_str(), getpid()),
-          base::Bind(&content::CanUserConnectToDevTools)),
+      factory.Pass(),
       base::StringPrintf(kFrontEndURL, content::GetWebKitRevision().c_str()),
       new DevToolsServerDelegate(),
       base::FilePath());
 }
 
 void DevToolsServer::Stop() {
   if (!protocol_handler_)
     return;
   // Note that the call to Stop() below takes care of |protocol_handler_|
   // deletion.
@@ skipping 31 matching lines @@
                                       jobject obj,
                                       jlong server,
                                       jboolean enabled) {
   DevToolsServer* devtools_server = reinterpret_cast<DevToolsServer*>(server);
   if (enabled) {
     devtools_server->Start();
   } else {
     devtools_server->Stop();
   }
 }