[Android] Use a "unique" remote debugging socket name on bind failure

net/socket/unix_domain_socket_posix.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 "net/socket/unix_domain_socket_posix.h"
 
 #include <cstring>
 #include <string>
 
 #include <errno.h>
@@ skipping 37 matching lines @@
 }  // namespace
 
 // static
 UnixDomainSocket::AuthCallback NoAuthentication() {
   return base::Bind(NoAuthenticationCallback);
 }
 
 // static
 UnixDomainSocket* UnixDomainSocket::CreateAndListenInternal(
     const std::string& path,
+    const std::string& fallback_path,
     StreamListenSocket::Delegate* del,
     const AuthCallback& auth_callback,
     bool use_abstract_namespace) {
   SocketDescriptor s = CreateAndBind(path, use_abstract_namespace);
+  if (s == kInvalidSocket && !fallback_path.empty())
+    s = CreateAndBind(fallback_path, use_abstract_namespace);
   if (s == kInvalidSocket)
     return NULL;
   UnixDomainSocket* sock = new UnixDomainSocket(s, del, auth_callback);
   sock->Listen();
   return sock;
 }
 
 // static
 scoped_refptr<UnixDomainSocket> UnixDomainSocket::CreateAndListen(
     const std::string& path,
     StreamListenSocket::Delegate* del,
     const AuthCallback& auth_callback) {
-  return CreateAndListenInternal(path, del, auth_callback, false);
+  return CreateAndListenInternal(path, "", del, auth_callback, false);
 }
 
 #if defined(SOCKET_ABSTRACT_NAMESPACE_SUPPORTED)
 // static
 scoped_refptr<UnixDomainSocket>
 UnixDomainSocket::CreateAndListenWithAbstractNamespace(
     const std::string& path,
+    const std::string& fallback_path,
     StreamListenSocket::Delegate* del,
     const AuthCallback& auth_callback) {
   return make_scoped_refptr(
-      CreateAndListenInternal(path, del, auth_callback, true));
+      CreateAndListenInternal(path, fallback_path, del, auth_callback, true));
 }
 #endif
 
 UnixDomainSocket::UnixDomainSocket(
     SocketDescriptor s,
     StreamListenSocket::Delegate* del,
     const AuthCallback& auth_callback)
     : StreamListenSocket(s, del),
       auth_callback_(auth_callback) {}
 
@@ skipping 57 matching lines @@
 UnixDomainSocketFactory::UnixDomainSocketFactory(
     const std::string& path,
     const UnixDomainSocket::AuthCallback& auth_callback)
     : path_(path),
       auth_callback_(auth_callback) {}
 
 UnixDomainSocketFactory::~UnixDomainSocketFactory() {}
 
 scoped_refptr<StreamListenSocket> UnixDomainSocketFactory::CreateAndListen(
     StreamListenSocket::Delegate* delegate) const {
-  return UnixDomainSocket::CreateAndListen(path_, delegate, auth_callback_);
+  return UnixDomainSocket::CreateAndListen(
+      path_, delegate, auth_callback_);
 }
 
 #if defined(SOCKET_ABSTRACT_NAMESPACE_SUPPORTED)
 
 UnixDomainSocketWithAbstractNamespaceFactory::
 UnixDomainSocketWithAbstractNamespaceFactory(
     const std::string& path,
+    const std::string& fallback_path,
     const UnixDomainSocket::AuthCallback& auth_callback)
-    : UnixDomainSocketFactory(path, auth_callback) {}
+    : UnixDomainSocketFactory(path, auth_callback),
+      fallback_path_(fallback_path) {}
 
 UnixDomainSocketWithAbstractNamespaceFactory::
 ~UnixDomainSocketWithAbstractNamespaceFactory() {}
 
 scoped_refptr<StreamListenSocket>
 UnixDomainSocketWithAbstractNamespaceFactory::CreateAndListen(
     StreamListenSocket::Delegate* delegate) const {
   return UnixDomainSocket::CreateAndListenWithAbstractNamespace(
-      path_, delegate, auth_callback_);
+      path_, fallback_path_, delegate, auth_callback_);
 }
 
 #endif
 
 }  // namespace net