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

net/socket/unix_domain_socket_posix.h

 // 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.
 
 #ifndef NET_SOCKET_UNIX_DOMAIN_SOCKET_POSIX_H_
 #define NET_SOCKET_UNIX_DOMAIN_SOCKET_POSIX_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 27 matching lines @@
 
   // Note that the returned UnixDomainSocket instance does not take ownership of
   // |del|.
   static scoped_refptr<UnixDomainSocket> CreateAndListen(
       const std::string& path,
       StreamListenSocket::Delegate* del,
       const AuthCallback& auth_callback);
 
 #if defined(SOCKET_ABSTRACT_NAMESPACE_SUPPORTED)
   // Same as above except that the created socket uses the abstract namespace
-  // which is a Linux-only feature.
+  // which is a Linux-only feature. If |fallback_path| is not empty,
+  // make the second attempt with the provided fallback name.
   static scoped_refptr<UnixDomainSocket> CreateAndListenWithAbstractNamespace(
       const std::string& path,
+      const std::string& fallback_path,
       StreamListenSocket::Delegate* del,
       const AuthCallback& auth_callback);
 #endif
 
  private:
   UnixDomainSocket(SocketDescriptor s,
                    StreamListenSocket::Delegate* del,
                    const AuthCallback& auth_callback);
   virtual ~UnixDomainSocket();
 
   static UnixDomainSocket* CreateAndListenInternal(
       const std::string& path,
+      const std::string& fallback_path,
       StreamListenSocket::Delegate* del,
       const AuthCallback& auth_callback,
       bool use_abstract_namespace);
 
   static SocketDescriptor CreateAndBind(const std::string& path,
                                         bool use_abstract_namespace);
 
   // StreamListenSocket:
   virtual void Accept() OVERRIDE;
 
@@ skipping 23 matching lines @@
 };
 
 #if defined(SOCKET_ABSTRACT_NAMESPACE_SUPPORTED)
 // Use this factory to instantiate UnixDomainSocket using the abstract
 // namespace feature (only supported on Linux).
 class NET_EXPORT UnixDomainSocketWithAbstractNamespaceFactory
     : public UnixDomainSocketFactory {
  public:
   UnixDomainSocketWithAbstractNamespaceFactory(
       const std::string& path,
+      const std::string& fallback_path,
       const UnixDomainSocket::AuthCallback& auth_callback);
   virtual ~UnixDomainSocketWithAbstractNamespaceFactory();
 
   // UnixDomainSocketFactory:
   virtual scoped_refptr<StreamListenSocket> CreateAndListen(
       StreamListenSocket::Delegate* delegate) const OVERRIDE;
 
  private:
+  std::string fallback_path_;
+
   DISALLOW_COPY_AND_ASSIGN(UnixDomainSocketWithAbstractNamespaceFactory);
 };
 #endif
 
 }  // namespace net
 
 #endif  // NET_SOCKET_UNIX_DOMAIN_SOCKET_POSIX_H_