Get rid of multiprocess_test's debug_on_start arguments.

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 <limits>
 
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 126 matching lines @@
   PathService::Get(base::DIR_CACHE, &tmp_dir);
   tmp_dir = tmp_dir.Append(filename);
   return tmp_dir.value();
 #endif
 }
 
 MULTIPROCESS_TEST_MAIN(SimpleChildProcess) {
   return 0;
 }
 
+// TODO(viettrungluu): This should be in a "MultiProcessTestTest".
 TEST_F(ProcessUtilTest, SpawnChild) {
-  base::ProcessHandle handle = this->SpawnChild("SimpleChildProcess", false);
+  base::ProcessHandle handle = SpawnChild("SimpleChildProcess");
   ASSERT_NE(base::kNullProcessHandle, handle);
   EXPECT_TRUE(base::WaitForSingleProcess(
                   handle, TestTimeouts::action_max_timeout()));
   base::CloseProcessHandle(handle);
 }
 
 MULTIPROCESS_TEST_MAIN(SlowChildProcess) {
   WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileSlow).c_str());
   return 0;
 }
 
 TEST_F(ProcessUtilTest, KillSlowChild) {
   const std::string signal_file =
       ProcessUtilTest::GetSignalFilePath(kSignalFileSlow);
   remove(signal_file.c_str());
-  base::ProcessHandle handle = this->SpawnChild("SlowChildProcess", false);
+  base::ProcessHandle handle = SpawnChild("SlowChildProcess");
   ASSERT_NE(base::kNullProcessHandle, handle);
   SignalChildren(signal_file.c_str());
   EXPECT_TRUE(base::WaitForSingleProcess(
                   handle, TestTimeouts::action_max_timeout()));
   base::CloseProcessHandle(handle);
   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::ProcessHandle handle = this->SpawnChild("SlowChildProcess", false);
+  base::ProcessHandle handle = SpawnChild("SlowChildProcess");
   ASSERT_NE(base::kNullProcessHandle, handle);
 
   int exit_code = 42;
   EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING,
             base::GetTerminationStatus(handle, &exit_code));
   EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
 
   SignalChildren(signal_file.c_str());
   exit_code = 42;
   base::TerminationStatus status =
       WaitForChildTermination(handle, &exit_code);
   EXPECT_EQ(base::TERMINATION_STATUS_NORMAL_TERMINATION, status);
   EXPECT_EQ(0, exit_code);
   base::CloseProcessHandle(handle);
   remove(signal_file.c_str());
 }
 
 #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::ProcessHandle handle = this->SpawnChild("SimpleChildProcess", false);
+  base::ProcessHandle handle = SpawnChild("SimpleChildProcess");
   ASSERT_NE(base::kNullProcessHandle, handle);
   base::ProcessId id2 = base::GetProcId(handle);
   EXPECT_NE(0ul, id2);
   EXPECT_NE(id1, id2);
   base::CloseProcessHandle(handle);
 }
 #endif
 
 #if !defined(OS_MACOSX)
 // This test is disabled on Mac, since it's flaky due to ReportCrash
@@ skipping 24 matching lines @@
 // TODO(jschuh): crbug.com/175753 Fix this in Win64 bots.
 #if defined(ADDRESS_SANITIZER) || (defined(OS_WIN) && defined(ARCH_CPU_X86_64))
 #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::ProcessHandle handle = this->SpawnChild("CrashingChildProcess",
-                                                false);
+  base::ProcessHandle handle = SpawnChild("CrashingChildProcess");
   ASSERT_NE(base::kNullProcessHandle, handle);
 
   int exit_code = 42;
   EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING,
             base::GetTerminationStatus(handle, &exit_code));
   EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
 
   SignalChildren(signal_file.c_str());
   exit_code = 42;
   base::TerminationStatus status =
@@ skipping 26 matching lines @@
   // Send a SIGKILL to this process, just like the OOM killer would.
   ::kill(getpid(), SIGKILL);
 #endif
   return 1;
 }
 
 TEST_F(ProcessUtilTest, GetTerminationStatusKill) {
   const std::string signal_file =
     ProcessUtilTest::GetSignalFilePath(kSignalFileKill);
   remove(signal_file.c_str());
-  base::ProcessHandle handle = this->SpawnChild("KilledChildProcess",
-                                                false);
+  base::ProcessHandle handle = SpawnChild("KilledChildProcess");
   ASSERT_NE(base::kNullProcessHandle, handle);
 
   int exit_code = 42;
   EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING,
             base::GetTerminationStatus(handle, &exit_code));
   EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
 
   SignalChildren(signal_file.c_str());
   exit_code = 42;
   base::TerminationStatus status =
       WaitForChildTermination(handle, &exit_code);
   EXPECT_EQ(base::TERMINATION_STATUS_PROCESS_WAS_KILLED, status);
 #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
   base::CloseProcessHandle(handle);
   remove(signal_file.c_str());
 }
 
 // Ensure that the priority of a process is restored correctly after
 // backgrounding and restoring.
 // Note: a platform may not be willing or able to lower the priority of
 // a process. The calls to SetProcessBackground should be noops then.
 TEST_F(ProcessUtilTest, SetProcessBackgrounded) {
-  base::ProcessHandle handle = this->SpawnChild("SimpleChildProcess", false);
+  base::ProcessHandle handle = SpawnChild("SimpleChildProcess");
   base::Process process(handle);
   int old_priority = process.GetPriority();
 #if defined(OS_WIN)
   EXPECT_TRUE(process.SetProcessBackgrounded(true));
   EXPECT_TRUE(process.IsProcessBackgrounded());
   EXPECT_TRUE(process.SetProcessBackgrounded(false));
   EXPECT_FALSE(process.IsProcessBackgrounded());
 #else
   process.SetProcessBackgrounded(true);
   process.SetProcessBackgrounded(false);
@@ skipping 50 matching lines @@
   ASSERT_TRUE(base::GetAppOutput(other_cmd_line, &output));
   EXPECT_EQ("", output);
 }
 
 // TODO(estade): if possible, port this test.
 TEST_F(ProcessUtilTest, LaunchAsUser) {
   base::UserTokenHandle token;
   ASSERT_TRUE(OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &token));
   base::LaunchOptions options;
   options.as_user = token;
-  EXPECT_TRUE(base::LaunchProcess(
-      this->MakeCmdLine("SimpleChildProcess", false), options, NULL));
+  EXPECT_TRUE(base::LaunchProcess(MakeCmdLine("SimpleChildProcess"), options,
+                                  NULL));
 }
 
 static const char kEventToTriggerHandleSwitch[] = "event-to-trigger-handle";
 
 MULTIPROCESS_TEST_MAIN(TriggerEventChildProcess) {
   std::string handle_value_string =
       CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           kEventToTriggerHandleSwitch);
   CHECK(!handle_value_string.empty());
 
@@ skipping 15 matching lines @@
   security_attributes.bInheritHandle = true;
 
   // Takes ownership of the event handle.
   base::WaitableEvent event(
       CreateEvent(&security_attributes, true, false, NULL));
   base::HandlesToInheritVector handles_to_inherit;
   handles_to_inherit.push_back(event.handle());
   base::LaunchOptions options;
   options.handles_to_inherit = &handles_to_inherit;
 
-  CommandLine cmd_line = MakeCmdLine("TriggerEventChildProcess", false);
+  CommandLine cmd_line = MakeCmdLine("TriggerEventChildProcess");
   cmd_line.AppendSwitchASCII(kEventToTriggerHandleSwitch,
       base::Uint64ToString(reinterpret_cast<uint64>(event.handle())));
 
   // This functionality actually requires Vista or later. Make sure that it
   // fails properly on XP.
   if (base::win::GetVersion() < base::win::VERSION_VISTA) {
     EXPECT_FALSE(base::LaunchProcess(cmd_line, options, NULL));
     return;
   }
 
@@ skipping 56 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::ProcessHandle handle = this->SpawnChildWithOptions(
-      "ProcessUtilsLeakFDChildProcess", options, false);
+  base::ProcessHandle handle =
+      SpawnChildWithOptions("ProcessUtilsLeakFDChildProcess", options);
   CHECK(handle);
   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)));
 
@@ skipping 285 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::ProcessHandle child_process =
-      SpawnChild("process_util_test_never_die", false);
+  base::ProcessHandle child_process = SpawnChild("process_util_test_never_die");
   ASSERT_TRUE(child_process);
   base::EnsureProcessTerminated(child_process);
   base::WaitForSingleProcess(child_process, base::TimeDelta::FromSeconds(5));
 
   // Check that process was really killed.
   EXPECT_TRUE(IsProcessDead(child_process));
   base::CloseProcessHandle(child_process);
 }
 
 MULTIPROCESS_TEST_MAIN(process_util_test_never_die) {
   while (1) {
     sleep(500);
   }
   return 0;
 }
 
 TEST_F(ProcessUtilTest, ImmediateTermination) {
   base::ProcessHandle child_process =
-      SpawnChild("process_util_test_die_immediately", false);
+      SpawnChild("process_util_test_die_immediately");
   ASSERT_TRUE(child_process);
   // Give it time to die.
   sleep(2);
   base::EnsureProcessTerminated(child_process);
 
   // Check that process was really killed.
   EXPECT_TRUE(IsProcessDead(child_process));
   base::CloseProcessHandle(child_process);
 }
 
 MULTIPROCESS_TEST_MAIN(process_util_test_die_immediately) {
   return 0;
 }
 
 #endif  // defined(OS_POSIX)