Use unique pipe names for IPCChannelPosixTest tests

ipc/ipc_channel_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.
 
 // These tests are POSIX only.
 
 #include "ipc/ipc_channel_posix.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <unistd.h>
 
 #include <memory>
 
+#include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/path_service.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/process/process.h"
+#include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/test/multiprocess_test.h"
 #include "base/test/test_timeouts.h"
 #include "build/build_config.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/unix_domain_socket_util.h"
 #include "testing/multiprocess_func_list.h"
 
 namespace {
 
+const char kSocketNameSwitch[] = "connection-socket-name";
+
 static const uint32_t kQuitMessage = 47;
 
 class IPCChannelPosixTestListener : public IPC::Listener {
  public:
   enum STATUS {
     DISCONNECTED,
     MESSAGE_RECEIVED,
     CHANNEL_ERROR,
     CONNECTED,
     DENIED,
@@ skipping 58 matching lines @@
   // If |quit_only_on_message_| then the listener will only break out of
   // the run loop when kQuitMessage is received.
   bool quit_only_on_message_;
 };
 
 class IPCChannelPosixTest : public base::MultiProcessTest {
  public:
   static void SetUpSocket(IPC::ChannelHandle *handle,
                           IPC::Channel::Mode mode);
   static void SpinRunLoop(base::TimeDelta delay);
-  static const std::string GetConnectionSocketName();
   static const std::string GetChannelDirName();
+  static std::string GetClientConnectionSocketName();
+
+  const std::string& GetConnectionSocketName();
+
+  base::Process SpawnChild(const std::string& procname) {
+    base::CommandLine command_line = MakeCmdLine(procname);
+    command_line.AppendSwitchASCII(
+        kSocketNameSwitch, GetConnectionSocketName());
+    return base::SpawnMultiProcessTestChild(
+        procname, command_line, base::LaunchOptions());
+  }
 
   bool WaitForExit(base::Process& process, int* exit_code) {
 #if defined(OS_ANDROID)
     return AndroidWaitForChildExitWithTimeout(
         process, base::TimeDelta::Max(), exit_code);
 #else
     return process.WaitForExit(exit_code);
 #endif  // defined(OS_ANDROID)
   }
 
  protected:
   void SetUp() override;
   void TearDown() override;
 
  private:
   std::unique_ptr<base::MessageLoopForIO> message_loop_;
+  std::string socket_name_;
 };
 
 const std::string IPCChannelPosixTest::GetChannelDirName() {
   base::FilePath tmp_dir;
   PathService::Get(base::DIR_TEMP, &tmp_dir);
   return tmp_dir.value();
 }
 
-const std::string IPCChannelPosixTest::GetConnectionSocketName() {
-  return GetChannelDirName() + "/chrome_IPCChannelPosixTest__ConnectionSocket";
+const std::string& IPCChannelPosixTest::GetConnectionSocketName() {
+  if (socket_name_.empty()) {
+    uint64_t id = base::RandUint64();
+    socket_name_ = GetChannelDirName() +
+        "/chrome_IPCChannelPosixTest_" +
+        base::HexEncode(&id, sizeof(id));
+  }
+  return socket_name_;
+}
+
+std::string IPCChannelPosixTest::GetClientConnectionSocketName() {
+  DCHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(kSocketNameSwitch));
+  return base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+      kSocketNameSwitch);
 }
 
 void IPCChannelPosixTest::SetUp() {
   MultiProcessTest::SetUp();
   // Construct a fresh IO Message loop for the duration of each test.
   message_loop_.reset(new base::MessageLoopForIO());
 }
 
 void IPCChannelPosixTest::TearDown() {
   message_loop_.reset(NULL);
@@ skipping 279 matching lines @@
   channel->Close();
   ASSERT_FALSE(IPC::Channel::IsNamedServerInitialized(
       connection_socket_name));
   unlink(chan_handle.name.c_str());
 }
 
 // A long running process that connects to us
 MULTIPROCESS_TEST_MAIN(IPCChannelPosixTestConnectionProc) {
   base::MessageLoopForIO message_loop;
   IPCChannelPosixTestListener listener(true);
-  IPC::ChannelHandle handle(IPCChannelPosixTest::GetConnectionSocketName());
+  IPC::ChannelHandle handle(
+      IPCChannelPosixTest::GetClientConnectionSocketName());
   IPCChannelPosixTest::SetUpSocket(&handle, IPC::Channel::MODE_NAMED_CLIENT);
   std::unique_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
       handle, IPC::Channel::MODE_NAMED_CLIENT, &listener));
   EXPECT_TRUE(channel->Connect());
   IPCChannelPosixTest::SpinRunLoop(TestTimeouts::action_max_timeout());
   EXPECT_EQ(IPCChannelPosixTestListener::MESSAGE_RECEIVED, listener.status());
   return 0;
 }
 
 // Simple external process that shouldn't be able to connect to us.
 MULTIPROCESS_TEST_MAIN(IPCChannelPosixFailConnectionProc) {
   base::MessageLoopForIO message_loop;
   IPCChannelPosixTestListener listener(false);
-  IPC::ChannelHandle handle(IPCChannelPosixTest::GetConnectionSocketName());
+  IPC::ChannelHandle handle(
+      IPCChannelPosixTest::GetClientConnectionSocketName());
   IPCChannelPosixTest::SetUpSocket(&handle, IPC::Channel::MODE_NAMED_CLIENT);
   std::unique_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
       handle, IPC::Channel::MODE_NAMED_CLIENT, &listener));
 
   // In this case connect may succeed or fail depending on if the packet
   // actually gets sent at sendmsg. Since we never delay on send, we may not
   // see the error. However even if connect succeeds, eventually we will get an
   // error back since the channel will be closed when we attempt to read from
   // it.
   bool connected = channel->Connect();
   if (connected) {
     IPCChannelPosixTest::SpinRunLoop(TestTimeouts::action_max_timeout());
     EXPECT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
   } else {
     EXPECT_EQ(IPCChannelPosixTestListener::DISCONNECTED, listener.status());
   }
   return 0;
 }
 
 }  // namespace