Changing multiprocess test SpawnChild to return a struct.

base/process/process_util_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.
 
 #define _CRT_SECURE_NO_WARNINGS
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 142 matching lines @@
   return tmp_dir.value();
 #endif
 }
 
 MULTIPROCESS_TEST_MAIN(SimpleChildProcess) {
   return kSuccess;
 }
 
 // TODO(viettrungluu): This should be in a "MultiProcessTestTest".
 TEST_F(ProcessUtilTest, SpawnChild) {
-  base::Process process = SpawnChild("SimpleChildProcess");
-  ASSERT_TRUE(process.IsValid());
+  base::SpawnChildResult spawn_child = SpawnChild("SimpleChildProcess");
+  ASSERT_TRUE(spawn_child.process.IsValid());
   int exit_code;
-  EXPECT_TRUE(process.WaitForExitWithTimeout(
-                  TestTimeouts::action_max_timeout(), &exit_code));
+  EXPECT_TRUE(spawn_child.process.WaitForExitWithTimeout(
+      TestTimeouts::action_max_timeout(), &exit_code));
 }
 
 MULTIPROCESS_TEST_MAIN(SlowChildProcess) {
   WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileSlow).c_str());
   return kSuccess;
 }
 
 TEST_F(ProcessUtilTest, KillSlowChild) {
   const std::string signal_file =
       ProcessUtilTest::GetSignalFilePath(kSignalFileSlow);
   remove(signal_file.c_str());
-  base::Process process = SpawnChild("SlowChildProcess");
-  ASSERT_TRUE(process.IsValid());
+  base::SpawnChildResult spawn_child = SpawnChild("SlowChildProcess");
+  ASSERT_TRUE(spawn_child.process.IsValid());
   SignalChildren(signal_file.c_str());
   int exit_code;
-  EXPECT_TRUE(process.WaitForExitWithTimeout(
-                  TestTimeouts::action_max_timeout(), &exit_code));
+  EXPECT_TRUE(spawn_child.process.WaitForExitWithTimeout(
+      TestTimeouts::action_max_timeout(), &exit_code));
   remove(signal_file.c_str());
 }
 
 // Times out on Linux and Win, flakes on other platforms, http://crbug.com/95058
 TEST_F(ProcessUtilTest, DISABLED_GetTerminationStatusExit) {
   const std::string signal_file =
       ProcessUtilTest::GetSignalFilePath(kSignalFileSlow);
   remove(signal_file.c_str());
-  base::Process process = SpawnChild("SlowChildProcess");
-  ASSERT_TRUE(process.IsValid());
+  base::SpawnChildResult spawn_child = SpawnChild("SlowChildProcess");
+  ASSERT_TRUE(spawn_child.process.IsValid());
 
   int exit_code = 42;
-  EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING,
-            base::GetTerminationStatus(process.Handle(), &exit_code));
+  EXPECT_EQ(
+      base::TERMINATION_STATUS_STILL_RUNNING,
+      base::GetTerminationStatus(spawn_child.process.Handle(), &exit_code));
   EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
 
   SignalChildren(signal_file.c_str());
   exit_code = 42;
   base::TerminationStatus status =
-      WaitForChildTermination(process.Handle(), &exit_code);
+      WaitForChildTermination(spawn_child.process.Handle(), &exit_code);
   EXPECT_EQ(base::TERMINATION_STATUS_NORMAL_TERMINATION, status);
   EXPECT_EQ(kSuccess, exit_code);
   remove(signal_file.c_str());
 }
 
 // On Android SpawnProcess() doesn't use LaunchProcess() and doesn't support
 // LaunchOptions::current_directory.
 #if !defined(OS_ANDROID)
 MULTIPROCESS_TEST_MAIN(CheckCwdProcess) {
   base::FilePath expected;
@@ skipping 13 matching lines @@
 
 TEST_F(ProcessUtilTest, CurrentDirectory) {
   // TODO(rickyz): Add support for passing arguments to multiprocess children,
   // then create a special directory for this test.
   base::FilePath tmp_dir;
   ASSERT_TRUE(base::GetTempDir(&tmp_dir));
 
   base::LaunchOptions options;
   options.current_directory = tmp_dir;
 
-  base::Process process(SpawnChildWithOptions("CheckCwdProcess", options));
-  ASSERT_TRUE(process.IsValid());
+  base::SpawnChildResult spawn_child =
+      SpawnChildWithOptions("CheckCwdProcess", options);
+  ASSERT_TRUE(spawn_child.process.IsValid());
 
   int exit_code = 42;
-  EXPECT_TRUE(process.WaitForExit(&exit_code));
+  EXPECT_TRUE(spawn_child.process.WaitForExit(&exit_code));
   EXPECT_EQ(kSuccess, exit_code);
 }
 #endif  // !defined(OS_ANDROID)
 
 #if defined(OS_WIN)
 // TODO(cpu): figure out how to test this in other platforms.
 TEST_F(ProcessUtilTest, GetProcId) {
   base::ProcessId id1 = base::GetProcId(GetCurrentProcess());
   EXPECT_NE(0ul, id1);
-  base::Process process = SpawnChild("SimpleChildProcess");
-  ASSERT_TRUE(process.IsValid());
-  base::ProcessId id2 = process.Pid();
+  base::SpawnChildResult spawn_child = SpawnChild("SimpleChildProcess");
+  ASSERT_TRUE(spawn_child.process.IsValid());
+  base::ProcessId id2 = spawn_child.process.Pid();
   EXPECT_NE(0ul, id2);
   EXPECT_NE(id1, id2);
 }
 #endif  // defined(OS_WIN)
 
 #if !defined(OS_MACOSX) && !defined(OS_ANDROID)
 // This test is disabled on Mac, since it's flaky due to ReportCrash
 // taking a variable amount of time to parse and load the debug and
 // symbol data for this unit test's executable before firing the
 // signal handler.
@@ skipping 23 matching lines @@
 // AddressSanitizer.
 #if defined(ADDRESS_SANITIZER) || defined(SYZYASAN)
 #define MAYBE_GetTerminationStatusCrash DISABLED_GetTerminationStatusCrash
 #else
 #define MAYBE_GetTerminationStatusCrash GetTerminationStatusCrash
 #endif
 TEST_F(ProcessUtilTest, MAYBE_GetTerminationStatusCrash) {
   const std::string signal_file =
     ProcessUtilTest::GetSignalFilePath(kSignalFileCrash);
   remove(signal_file.c_str());
-  base::Process process = SpawnChild("CrashingChildProcess");
-  ASSERT_TRUE(process.IsValid());
+  base::SpawnChildResult spawn_child = SpawnChild("CrashingChildProcess");
+  ASSERT_TRUE(spawn_child.process.IsValid());
 
   int exit_code = 42;
-  EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING,
-            base::GetTerminationStatus(process.Handle(), &exit_code));
+  EXPECT_EQ(
+      base::TERMINATION_STATUS_STILL_RUNNING,
+      base::GetTerminationStatus(spawn_child.process.Handle(), &exit_code));
   EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
 
   SignalChildren(signal_file.c_str());
   exit_code = 42;
   base::TerminationStatus status =
-      WaitForChildTermination(process.Handle(), &exit_code);
+      WaitForChildTermination(spawn_child.process.Handle(), &exit_code);
   EXPECT_EQ(base::TERMINATION_STATUS_PROCESS_CRASHED, status);
 
 #if defined(OS_WIN)
   EXPECT_EQ(static_cast<int>(0xc0000005), exit_code);
 #elif defined(OS_POSIX)
   int signaled = WIFSIGNALED(exit_code);
   EXPECT_NE(0, signaled);
   int signal = WTERMSIG(exit_code);
   EXPECT_EQ(SIGSEGV, signal);
 #endif
@@ skipping 23 matching lines @@
   // Send a SIGTERM to this process.
   ::kill(getpid(), SIGTERM);
   return 1;
 }
 #endif  // defined(OS_POSIX)
 
 TEST_F(ProcessUtilTest, GetTerminationStatusSigKill) {
   const std::string signal_file =
     ProcessUtilTest::GetSignalFilePath(kSignalFileKill);
   remove(signal_file.c_str());
-  base::Process process = SpawnChild("KilledChildProcess");
-  ASSERT_TRUE(process.IsValid());
+  base::SpawnChildResult spawn_child = SpawnChild("KilledChildProcess");
+  ASSERT_TRUE(spawn_child.process.IsValid());
 
   int exit_code = 42;
-  EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING,
-            base::GetTerminationStatus(process.Handle(), &exit_code));
+  EXPECT_EQ(
+      base::TERMINATION_STATUS_STILL_RUNNING,
+      base::GetTerminationStatus(spawn_child.process.Handle(), &exit_code));
   EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
 
   SignalChildren(signal_file.c_str());
   exit_code = 42;
   base::TerminationStatus status =
-      WaitForChildTermination(process.Handle(), &exit_code);
+      WaitForChildTermination(spawn_child.process.Handle(), &exit_code);
 #if defined(OS_CHROMEOS)
   EXPECT_EQ(base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM, status);
 #else
   EXPECT_EQ(base::TERMINATION_STATUS_PROCESS_WAS_KILLED, status);
 #endif
 
 #if defined(OS_WIN)
   EXPECT_EQ(kExpectedKilledExitCode, exit_code);
 #elif defined(OS_POSIX)
   int signaled = WIFSIGNALED(exit_code);
   EXPECT_NE(0, signaled);
   int signal = WTERMSIG(exit_code);
   EXPECT_EQ(SIGKILL, signal);
 #endif
   remove(signal_file.c_str());
 }
 
 #if defined(OS_POSIX)
 TEST_F(ProcessUtilTest, GetTerminationStatusSigTerm) {
   const std::string signal_file =
     ProcessUtilTest::GetSignalFilePath(kSignalFileTerm);
   remove(signal_file.c_str());
-  base::Process process = SpawnChild("TerminatedChildProcess");
-  ASSERT_TRUE(process.IsValid());
+  base::SpawnChildResult spawn_child = SpawnChild("TerminatedChildProcess");
+  ASSERT_TRUE(spawn_child.process.IsValid());
 
   int exit_code = 42;
-  EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING,
-            base::GetTerminationStatus(process.Handle(), &exit_code));
+  EXPECT_EQ(
+      base::TERMINATION_STATUS_STILL_RUNNING,
+      base::GetTerminationStatus(spawn_child.process.Handle(), &exit_code));
   EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
 
   SignalChildren(signal_file.c_str());
   exit_code = 42;
   base::TerminationStatus status =
-      WaitForChildTermination(process.Handle(), &exit_code);
+      WaitForChildTermination(spawn_child.process.Handle(), &exit_code);
   EXPECT_EQ(base::TERMINATION_STATUS_PROCESS_WAS_KILLED, status);
 
   int signaled = WIFSIGNALED(exit_code);
   EXPECT_NE(0, signaled);
   int signal = WTERMSIG(exit_code);
   EXPECT_EQ(SIGTERM, signal);
   remove(signal_file.c_str());
 }
 #endif  // defined(OS_POSIX)
 
@@ skipping 211 matching lines @@
 
 int ProcessUtilTest::CountOpenFDsInChild() {
   int fds[2];
   if (pipe(fds) < 0)
     NOTREACHED();
 
   base::FileHandleMappingVector fd_mapping_vec;
   fd_mapping_vec.push_back(std::pair<int, int>(fds[1], kChildPipe));
   base::LaunchOptions options;
   options.fds_to_remap = &fd_mapping_vec;
-  base::Process process =
+  base::SpawnChildResult spawn_child =
       SpawnChildWithOptions("ProcessUtilsLeakFDChildProcess", options);
-  CHECK(process.IsValid());
+  CHECK(spawn_child.process.IsValid());
   int ret = IGNORE_EINTR(close(fds[1]));
   DPCHECK(ret == 0);
 
   // Read number of open files in client process from pipe;
   int num_open_files = -1;
   ssize_t bytes_read =
       HANDLE_EINTR(read(fds[0], &num_open_files, sizeof(num_open_files)));
   CHECK_EQ(bytes_read, static_cast<ssize_t>(sizeof(num_open_files)));
 
 #if defined(THREAD_SANITIZER)
   // Compiler-based ThreadSanitizer makes this test slow.
   base::TimeDelta timeout = base::TimeDelta::FromSeconds(3);
 #else
   base::TimeDelta timeout = base::TimeDelta::FromSeconds(1);
 #endif
   int exit_code;
-  CHECK(process.WaitForExitWithTimeout(timeout, &exit_code));
+  CHECK(spawn_child.process.WaitForExitWithTimeout(timeout, &exit_code));
   ret = IGNORE_EINTR(close(fds[0]));
   DPCHECK(ret == 0);
 
   return num_open_files;
 }
 
 #if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER)
 // ProcessUtilTest.FDRemapping is flaky when ran under xvfb-run on Precise.
 // The problem is 100% reproducible with both ASan and TSan.
 // See http://crbug.com/136720.
@@ skipping 202 matching lines @@
 // TODO(port): port those unit tests.
 bool IsProcessDead(base::ProcessHandle child) {
   // waitpid() will actually reap the process which is exactly NOT what we
   // want to test for.  The good thing is that if it can't find the process
   // we'll get a nice value for errno which we can test for.
   const pid_t result = HANDLE_EINTR(waitpid(child, NULL, WNOHANG));
   return result == -1 && errno == ECHILD;
 }
 
 TEST_F(ProcessUtilTest, DelayedTermination) {
-  base::Process child_process = SpawnChild("process_util_test_never_die");
-  ASSERT_TRUE(child_process.IsValid());
-  base::EnsureProcessTerminated(child_process.Duplicate());
+  base::SpawnChildResult spawn_child =
+      SpawnChild("process_util_test_never_die");
+  ASSERT_TRUE(spawn_child.process.IsValid());
+  base::EnsureProcessTerminated(spawn_child.process.Duplicate());
   int exit_code;
-  child_process.WaitForExitWithTimeout(base::TimeDelta::FromSeconds(5),
-                                       &exit_code);
+  spawn_child.process.WaitForExitWithTimeout(base::TimeDelta::FromSeconds(5),
+                                             &exit_code);
 
   // Check that process was really killed.
-  EXPECT_TRUE(IsProcessDead(child_process.Handle()));
+  EXPECT_TRUE(IsProcessDead(spawn_child.process.Handle()));
 }
 
 MULTIPROCESS_TEST_MAIN(process_util_test_never_die) {
   while (1) {
     sleep(500);
   }
   return kSuccess;
 }
 
 TEST_F(ProcessUtilTest, ImmediateTermination) {
-  base::Process child_process = SpawnChild("process_util_test_die_immediately");
-  ASSERT_TRUE(child_process.IsValid());
+  base::SpawnChildResult spawn_child =
+      SpawnChild("process_util_test_die_immediately");
+  ASSERT_TRUE(spawn_child.process.IsValid());
   // Give it time to die.
   sleep(2);
-  base::EnsureProcessTerminated(child_process.Duplicate());
+  base::EnsureProcessTerminated(spawn_child.process.Duplicate());
 
   // Check that process was really killed.
-  EXPECT_TRUE(IsProcessDead(child_process.Handle()));
+  EXPECT_TRUE(IsProcessDead(spawn_child.process.Handle()));
 }
 
 MULTIPROCESS_TEST_MAIN(process_util_test_die_immediately) {
   return kSuccess;
 }
 
 #if !defined(OS_ANDROID)
 const char kPipeValue = '\xcc';
 
 class ReadFromPipeDelegate : public base::LaunchOptions::PreExecDelegate {
@@ skipping 18 matching lines @@
 
   base::ScopedFD read_fd(pipe_fds[0]);
   base::ScopedFD write_fd(pipe_fds[1]);
   base::FileHandleMappingVector fds_to_remap;
   fds_to_remap.push_back(std::make_pair(read_fd.get(), read_fd.get()));
 
   ReadFromPipeDelegate read_from_pipe_delegate(read_fd.get());
   base::LaunchOptions options;
   options.fds_to_remap = &fds_to_remap;
   options.pre_exec_delegate = &read_from_pipe_delegate;
-  base::Process process(SpawnChildWithOptions("SimpleChildProcess", options));
-  ASSERT_TRUE(process.IsValid());
+  base::SpawnChildResult spawn_child =
+      SpawnChildWithOptions("SimpleChildProcess", options);
+  ASSERT_TRUE(spawn_child.process.IsValid());
 
   read_fd.reset();
   ASSERT_EQ(1, HANDLE_EINTR(write(write_fd.get(), &kPipeValue, 1)));
 
   int exit_code = 42;
-  EXPECT_TRUE(process.WaitForExit(&exit_code));
+  EXPECT_TRUE(spawn_child.process.WaitForExit(&exit_code));
   EXPECT_EQ(0, exit_code);
 }
 #endif  // !defined(OS_ANDROID)
 
 #endif  // defined(OS_POSIX)
 
 #if defined(OS_LINUX)
 MULTIPROCESS_TEST_MAIN(CheckPidProcess) {
   const pid_t kInitPid = 1;
   const pid_t pid = syscall(__NR_getpid);
   CHECK(pid == kInitPid);
   CHECK(getpid() == pid);
   return kSuccess;
 }
 
 #if defined(CLONE_NEWUSER) && defined(CLONE_NEWPID)
 TEST_F(ProcessUtilTest, CloneFlags) {
   if (RunningOnValgrind() ||
       !base::PathExists(FilePath("/proc/self/ns/user")) ||
       !base::PathExists(FilePath("/proc/self/ns/pid"))) {
     // User or PID namespaces are not supported.
     return;
   }
 
   base::LaunchOptions options;
   options.clone_flags = CLONE_NEWUSER | CLONE_NEWPID;
 
-  base::Process process(SpawnChildWithOptions("CheckPidProcess", options));
-  ASSERT_TRUE(process.IsValid());
+  base::SpawnChildResult spawn_child =
+      SpawnChildWithOptions("CheckPidProcess", options);
+  ASSERT_TRUE(spawn_child.process.IsValid());
 
   int exit_code = 42;
-  EXPECT_TRUE(process.WaitForExit(&exit_code));
+  EXPECT_TRUE(spawn_child.process.WaitForExit(&exit_code));
   EXPECT_EQ(kSuccess, exit_code);
 }
 #endif  // defined(CLONE_NEWUSER) && defined(CLONE_NEWPID)
 
 TEST(ForkWithFlagsTest, UpdatesPidCache) {
   // The libc clone function, which allows ForkWithFlags to keep the pid cache
   // up to date, does not work on Valgrind.
   if (RunningOnValgrind()) {
     return;
   }
@@ skipping 16 matching lines @@
   int status = 42;
   ASSERT_EQ(pid, HANDLE_EINTR(waitpid(pid, &status, 0)));
   ASSERT_TRUE(WIFEXITED(status));
   EXPECT_EQ(kSuccess, WEXITSTATUS(status));
 }
 
 TEST_F(ProcessUtilTest, InvalidCurrentDirectory) {
   base::LaunchOptions options;
   options.current_directory = base::FilePath("/dev/null");
 
-  base::Process process(SpawnChildWithOptions("SimpleChildProcess", options));
-  ASSERT_TRUE(process.IsValid());
+  base::SpawnChildResult spawn_child =
+      SpawnChildWithOptions("SimpleChildProcess", options);
+  ASSERT_TRUE(spawn_child.process.IsValid());
 
   int exit_code = kSuccess;
-  EXPECT_TRUE(process.WaitForExit(&exit_code));
+  EXPECT_TRUE(spawn_child.process.WaitForExit(&exit_code));
   EXPECT_NE(kSuccess, exit_code);
 }
 #endif  // defined(OS_LINUX)