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

net/socket/unix_domain_socket_posix_unittest.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 <errno.h>
 #include <fcntl.h>
 #include <poll.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/time.h>
@@ skipping 21 matching lines @@
 #include "net/socket/unix_domain_socket_posix.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::queue;
 using std::string;
 
 namespace net {
 namespace {
 
 const char kSocketFilename[] = "unix_domain_socket_for_testing";
+const char kFallbackSocketName[] = "unix_domain_socket_for_testing_2";
 const char kInvalidSocketPath[] = "/invalid/path";
 const char kMsg[] = "hello";
 
 enum EventType {
   EVENT_ACCEPT,
   EVENT_AUTH_DENIED,
   EVENT_AUTH_GRANTED,
   EVENT_CLOSE,
   EVENT_LISTEN,
   EVENT_READ,
 };
 
-string MakeSocketPath() {
+string MakeSocketPath(const string& socket_file_name) {
   base::FilePath temp_dir;
   file_util::GetTempDir(&temp_dir);
-  return temp_dir.Append(kSocketFilename).value();
+  return temp_dir.Append(socket_file_name).value();
+}
+
+string MakeSocketPath() {
+  return MakeSocketPath(kSocketFilename);
 }
 
 class EventManager : public base::RefCounted<EventManager> {
  public:
   EventManager() : condition_(&mutex_) {}
 
   bool HasPendingEvent() {
     base::AutoLock lock(mutex_);
     return !events_.empty();
   }
@@ skipping 179 matching lines @@
   CreateAndListen();
   EXPECT_TRUE(socket_.get() == NULL);
 }
 
 #ifdef SOCKET_ABSTRACT_NAMESPACE_SUPPORTED
 // Test with an invalid path to make sure that the socket is not backed by a
 // file.
 TEST_F(UnixDomainSocketTestWithInvalidPath,
        CreateAndListenWithAbstractNamespace) {
   socket_ = UnixDomainSocket::CreateAndListenWithAbstractNamespace(
-      file_path_.value(), socket_delegate_.get(), MakeAuthCallback());
+      file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback());
   EXPECT_FALSE(socket_.get() == NULL);
 }
+
+TEST_F(UnixDomainSocketTest, TestFallbackName) {
+  scoped_refptr<UnixDomainSocket> existing_socket =
+      UnixDomainSocket::CreateAndListenWithAbstractNamespace(
+          file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback());
+  EXPECT_FALSE(existing_socket.get() == NULL);
+  // First, try to bind socket with the same name with no fallback name.
+  socket_ =
+      UnixDomainSocket::CreateAndListenWithAbstractNamespace(
+          file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback());
+  EXPECT_TRUE(socket_.get() == NULL);
+  // Now with a fallback name.
+  socket_ = UnixDomainSocket::CreateAndListenWithAbstractNamespace(
+      file_path_.value(),
+      MakeSocketPath(kFallbackSocketName),
+      socket_delegate_.get(),
+      MakeAuthCallback());
+  EXPECT_FALSE(socket_.get() == NULL);
+  existing_socket = NULL;
+}
 #endif
 
 TEST_F(UnixDomainSocketTest, TestWithClient) {
   const scoped_ptr<base::Thread> server_thread = CreateAndRunServerThread();
   EventType event = event_manager_->WaitForEvent();
   ASSERT_EQ(EVENT_LISTEN, event);
 
   // Create the client socket.
   const SocketDescriptor sock = CreateClientSocket();
   ASSERT_NE(StreamListenSocket::kInvalidSocket, sock);
@@ skipping 34 matching lines @@
 
   // Send() must fail.
   ssize_t ret = HANDLE_EINTR(send(sock, kMsg, sizeof(kMsg), 0));
   ASSERT_EQ(-1, ret);
   ASSERT_EQ(EPIPE, errno);
   ASSERT_FALSE(event_manager_->HasPendingEvent());
 }
 
 }  // namespace
 }  // namespace net