Get rid of multiprocess_test's debug_on_start arguments.

(It was only ever given a "true" value once, and even that seemed dubious.)

R=phajdan.jr@chromium.org
TBR=darin@chromium.org, jeremy@chromium.org

Review URL: https://codereview.chromium.org/191483002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@255801 0039d316-1c4b-4281-b951-d872f2087c98

base/debug/stack_trace_unittest.cc

@@ -144,7 +144,7 @@ MULTIPROCESS_TEST_MAIN(MismatchedMallocChildProcess) {
 // and e.g. mismatched new[]/delete would cause a hang because
 // of re-entering malloc.
 TEST_F(StackTraceTest, AsyncSignalUnsafeSignalHandlerHang) {
-  ProcessHandle child = this->SpawnChild("MismatchedMallocChildProcess", false);
+  ProcessHandle child = SpawnChild("MismatchedMallocChildProcess");
   ASSERT_NE(kNullProcessHandle, child);
   ASSERT_TRUE(WaitForSingleProcess(child, TestTimeouts::action_timeout()));
 }

base/memory/shared_memory_unittest.cc

@@ -648,7 +648,7 @@ TEST_F(SharedMemoryProcessTest, Tasks) {
 
   ProcessHandle handles[kNumTasks];
   for (int index = 0; index < kNumTasks; ++index) {
-    handles[index] = SpawnChild("SharedMemoryTestMain", false);
+    handles[index] = SpawnChild("SharedMemoryTestMain");
     ASSERT_TRUE(handles[index]);
   }
 

base/metrics/stats_table_unittest.cc

@@ -211,7 +211,7 @@ TEST_F(StatsTableTest, DISABLED_MultipleProcesses) {
 
   // Spawn the processes.
   for (int16 index = 0; index < kMaxProcs; index++) {
-    procs[index] = this->SpawnChild("StatsTableMultipleProcessMain", false);
+    procs[index] = SpawnChild("StatsTableMultipleProcessMain");
     EXPECT_NE(kNullProcessHandle, procs[index]);
   }
 

base/process/process_util_unittest.cc

@@ -144,8 +144,9 @@ 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()));
@@ -161,7 +162,7 @@ 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(
@@ -175,7 +176,7 @@ 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;
@@ -198,7 +199,7 @@ TEST_F(ProcessUtilTest, DISABLED_GetTerminationStatusExit) {
 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);
@@ -243,8 +244,7 @@ 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;
@@ -291,8 +291,7 @@ 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;
@@ -322,7 +321,7 @@ TEST_F(ProcessUtilTest, GetTerminationStatusKill) {
 // 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)
@@ -393,8 +392,8 @@ TEST_F(ProcessUtilTest, LaunchAsUser) {
   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";
@@ -430,7 +429,7 @@ TEST_F(ProcessUtilTest, InheritSpecifiedHandles) {
   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())));
 
@@ -507,8 +506,8 @@ int ProcessUtilTest::CountOpenFDsInChild() {
   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);
@@ -814,8 +813,7 @@ bool IsProcessDead(base::ProcessHandle child) {
 }
 
 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));
@@ -834,7 +832,7 @@ MULTIPROCESS_TEST_MAIN(process_util_test_never_die) {
 
 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/test/multiprocess_test.cc

@@ -13,17 +13,13 @@ namespace base {
 ProcessHandle SpawnMultiProcessTestChild(
     const std::string& procname,
     const CommandLine& base_command_line,
-    const LaunchOptions& options,
-    bool debug_on_start) {
+    const LaunchOptions& options) {
   CommandLine command_line(base_command_line);
   // TODO(viettrungluu): See comment above |MakeCmdLine()| in the header file.
   // This is a temporary hack, since |MakeCmdLine()| has to provide a full
   // command line.
-  if (!command_line.HasSwitch(switches::kTestChildProcess)) {
+  if (!command_line.HasSwitch(switches::kTestChildProcess))
     command_line.AppendSwitchASCII(switches::kTestChildProcess, procname);
-    if (debug_on_start)
-      command_line.AppendSwitch(switches::kDebugOnStart);
-  }
 
   ProcessHandle handle = kNullProcessHandle;
   LaunchProcess(command_line, options, &handle);
@@ -40,31 +36,23 @@ CommandLine GetMultiProcessTestChildBaseCommandLine() {
 MultiProcessTest::MultiProcessTest() {
 }
 
-ProcessHandle MultiProcessTest::SpawnChild(const std::string& procname,
-                                           bool debug_on_start) {
+ProcessHandle MultiProcessTest::SpawnChild(const std::string& procname) {
   LaunchOptions options;
 #if defined(OS_WIN)
   options.start_hidden = true;
 #endif
-  return SpawnChildWithOptions(procname, options, debug_on_start);
+  return SpawnChildWithOptions(procname, options);
 }
 
 ProcessHandle MultiProcessTest::SpawnChildWithOptions(
     const std::string& procname,
-    const LaunchOptions& options,
-    bool debug_on_start) {
-  return SpawnMultiProcessTestChild(procname,
-                                    MakeCmdLine(procname, debug_on_start),
-                                    options,
-                                    debug_on_start);
+    const LaunchOptions& options) {
+  return SpawnMultiProcessTestChild(procname, MakeCmdLine(procname), options);
 }
 
-CommandLine MultiProcessTest::MakeCmdLine(const std::string& procname,
-                                          bool debug_on_start) {
+CommandLine MultiProcessTest::MakeCmdLine(const std::string& procname) {
   CommandLine command_line = GetMultiProcessTestChildBaseCommandLine();
   command_line.AppendSwitchASCII(switches::kTestChildProcess, procname);
-  if (debug_on_start)
-    command_line.AppendSwitch(switches::kDebugOnStart);
   return command_line;
 }
 

base/test/multiprocess_test.h

@@ -35,7 +35,7 @@ namespace base {
 //     // Start a child process and run |a_test_func|.
 //     base::ProcessHandle test_child_handle =
 //         base::SpawnMultiProcessTestChild("a_test_func", command_line,
-//                                          options, false);
+//                                          options);
 //
 //     // Do stuff involving |test_child_handle| and the child process....
 //
@@ -61,8 +61,7 @@ namespace base {
 ProcessHandle SpawnMultiProcessTestChild(
     const std::string& procname,
     const CommandLine& command_line,
-    const LaunchOptions& options,
-    bool debug_on_start);
+    const LaunchOptions& options);
 
 // Gets the base command line for |SpawnMultiProcessTestChild()|. To this, you
 // may add any flags needed for your child process.
@@ -107,14 +106,13 @@ class MultiProcessTest : public PlatformTest {
   //    }
   //
   // Returns the handle to the child, or NULL on failure
-  ProcessHandle SpawnChild(const std::string& procname, bool debug_on_start);
+  ProcessHandle SpawnChild(const std::string& procname);
 
   // Run a child process using the given launch options.
   //
   // Note: On Windows, you probably want to set |options.start_hidden|.
   ProcessHandle SpawnChildWithOptions(const std::string& procname,
-                                      const LaunchOptions& options,
-                                      bool debug_on_start);
+                                      const LaunchOptions& options);
 
   // Set up the command line used to spawn the child process.
   // Override this to add things to the command line (calling this first in the
@@ -123,8 +121,7 @@ class MultiProcessTest : public PlatformTest {
   // which they then use directly with |LaunchProcess()|.
   // TODO(viettrungluu): Remove this and add a virtual
   // |ModifyChildCommandLine()|; make the two divergent uses more sane.
-  virtual CommandLine MakeCmdLine(const std::string& procname,
-                                  bool debug_on_start);
+  virtual CommandLine MakeCmdLine(const std::string& procname);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MultiProcessTest);

base/test/multiprocess_test_android.cc

@@ -17,11 +17,9 @@ namespace base {
 // minimum to execute the method specified by procname (in the child process).
 //  - |base_command_line| is ignored.
 //  - All options except |fds_to_remap| are ignored.
-//  - |debug_on_start| is ignored.
 ProcessHandle SpawnMultiProcessTestChild(const std::string& procname,
                                          const CommandLine& base_command_line,
-                                         const LaunchOptions& options,
-                                         bool debug_on_start) {
+                                         const LaunchOptions& options) {
   // TODO(viettrungluu): The FD-remapping done below is wrong in the presence of
   // cycles (e.g., fd1 -> fd2, fd2 -> fd1). crbug.com/326576
   FileHandleMappingVector empty;

base/win/scoped_process_information_unittest.cc

@@ -46,8 +46,7 @@ MULTIPROCESS_TEST_MAIN(ReturnNine) {
 
 void ScopedProcessInformationTest::DoCreateProcess(
     const std::string& main_id, PROCESS_INFORMATION* process_handle) {
-  std::wstring cmd_line =
-      this->MakeCmdLine(main_id, false).GetCommandLineString();
+  std::wstring cmd_line = MakeCmdLine(main_id).GetCommandLineString();
   STARTUPINFO startup_info = {};
   startup_info.cb = sizeof(startup_info);
 

base/win/startup_information_unittest.cc

@@ -62,7 +62,7 @@ TEST_F(StartupInformationTest, InheritStdOut) {
       sizeof(events[0])));
 
   std::wstring cmd_line =
-      this->MakeCmdLine("FireInheritedEvents", false).GetCommandLineString();
+      MakeCmdLine("FireInheritedEvents").GetCommandLineString();
 
   PROCESS_INFORMATION temp_process_info = {};
   ASSERT_TRUE(::CreateProcess(NULL, const_cast<wchar_t*>(cmd_line.c_str()),

chrome/browser/printing/cloud_print/test/cloud_print_proxy_process_browsertest.cc

@@ -317,8 +317,7 @@ class CloudPrintProxyPolicyStartupTest : public base::MultiProcessTest,
   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
 
   // MultiProcessTest implementation.
-  virtual CommandLine MakeCmdLine(const std::string& procname,
-                                  bool debug_on_start) OVERRIDE;
+  virtual CommandLine MakeCmdLine(const std::string& procname) OVERRIDE;
 
   bool LaunchBrowser(const CommandLine& command_line, Profile* profile) {
     int return_code = 0;
@@ -434,9 +433,9 @@ base::ProcessHandle CloudPrintProxyPolicyStartupTest::Launch(
       kPrimaryIPCChannel + base::GlobalDescriptors::kBaseDescriptor));
   base::LaunchOptions options;
   options.fds_to_remap = &ipc_file_list;
-  base::ProcessHandle handle = SpawnChildWithOptions(name, options, false);
+  base::ProcessHandle handle = SpawnChildWithOptions(name, options);
 #else
-  base::ProcessHandle handle = SpawnChild(name, false);
+  base::ProcessHandle handle = SpawnChild(name);
 #endif
   EXPECT_TRUE(handle);
   return handle;
@@ -475,9 +474,8 @@ void CloudPrintProxyPolicyStartupTest::OnChannelConnected(int32 peer_pid) {
 }
 
 CommandLine CloudPrintProxyPolicyStartupTest::MakeCmdLine(
-    const std::string& procname,
-    bool debug_on_start) {
-  CommandLine cl = MultiProcessTest::MakeCmdLine(procname, debug_on_start);
+    const std::string& procname) {
+  CommandLine cl = MultiProcessTest::MakeCmdLine(procname);
   cl.AppendSwitchASCII(switches::kProcessChannelID, startup_channel_id_);
 #if defined(OS_MACOSX)
   cl.AppendSwitchASCII(kTestExecutablePath, executable_path_.value());

chrome/common/multi_process_lock_unittest.cc

@@ -51,7 +51,7 @@ std::string MultiProcessLockTest::GenerateLockName() {
 
 void MultiProcessLockTest::ExpectLockIsLocked(const std::string &name) {
   ScopedEnvironmentVariable var(kLockEnviromentVarName, name);
-  base::ProcessHandle handle = SpawnChild("MultiProcessLockTryFailMain", false);
+  base::ProcessHandle handle = SpawnChild("MultiProcessLockTryFailMain");
   ASSERT_TRUE(handle);
   int exit_code = 0;
   EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
@@ -61,8 +61,7 @@ void MultiProcessLockTest::ExpectLockIsLocked(const std::string &name) {
 void MultiProcessLockTest::ExpectLockIsUnlocked(
     const std::string &name) {
   ScopedEnvironmentVariable var(kLockEnviromentVarName, name);
-  base::ProcessHandle handle = SpawnChild("MultiProcessLockTrySucceedMain",
-                                          false);
+  base::ProcessHandle handle = SpawnChild("MultiProcessLockTrySucceedMain");
   ASSERT_TRUE(handle);
   int exit_code = 0;
   EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));

chrome/common/service_process_util_unittest.cc

@@ -95,7 +95,7 @@ void ServiceProcessStateTest::SetUp() {
 }
 
 void ServiceProcessStateTest::LaunchAndWait(const std::string& name) {
-  base::ProcessHandle handle = SpawnChild(name, false);
+  base::ProcessHandle handle = SpawnChild(name);
   ASSERT_TRUE(handle);
   int exit_code = 0;
   ASSERT_TRUE(base::WaitForExitCode(handle, &exit_code));
@@ -185,8 +185,7 @@ TEST_F(ServiceProcessStateTest, SharedMem) {
 }
 
 TEST_F(ServiceProcessStateTest, MAYBE_ForceShutdown) {
-  base::ProcessHandle handle = SpawnChild("ServiceProcessStateTestShutdown",
-                                          true);
+  base::ProcessHandle handle = SpawnChild("ServiceProcessStateTestShutdown");
   ASSERT_TRUE(handle);
   for (int i = 0; !CheckServiceProcessReady() && i < 10; ++i) {
     base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());

content/common/sandbox_mac_diraccess_unittest.mm

@@ -34,8 +34,7 @@ class MacDirAccessSandboxTest : public base::MultiProcessTest {
  public:
   bool CheckSandbox(const std::string& directory_to_try) {
     setenv(kSandboxAccessPathKey, directory_to_try.c_str(), 1);
-    base::ProcessHandle child_process = SpawnChild("mac_sandbox_path_access",
-                                                   false);
+    base::ProcessHandle child_process = SpawnChild("mac_sandbox_path_access");
     if (child_process == base::kNullProcessHandle) {
       LOG(WARNING) << "SpawnChild failed";
       return false;

content/common/sandbox_mac_unittest_helper.mm

@@ -78,8 +78,7 @@ bool MacSandboxTest::RunTestInSandbox(SandboxType sandbox_type,
   if (test_data)
     setenv(kTestDataKey, test_data, 1);
 
-  base::ProcessHandle child_process = SpawnChild("mac_sandbox_test_runner",
-                                                 false);
+  base::ProcessHandle child_process = SpawnChild("mac_sandbox_test_runner");
   if (child_process == base::kNullProcessHandle) {
     LOG(WARNING) << "SpawnChild failed";
     return false;

ipc/ipc_channel_posix_unittest.cc

@@ -285,8 +285,7 @@ TEST_F(IPCChannelPosixTest, AdvancedConnected) {
   ASSERT_TRUE(channel.AcceptsConnections());
   ASSERT_FALSE(channel.HasAcceptedConnection());
 
-  base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc",
-                                          false);
+  base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc");
   ASSERT_TRUE(handle);
   SpinRunLoop(TestTimeouts::action_max_timeout());
   ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
@@ -315,8 +314,7 @@ TEST_F(IPCChannelPosixTest, ResetState) {
   ASSERT_TRUE(channel.AcceptsConnections());
   ASSERT_FALSE(channel.HasAcceptedConnection());
 
-  base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc",
-                                          false);
+  base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc");
   ASSERT_TRUE(handle);
   SpinRunLoop(TestTimeouts::action_max_timeout());
   ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
@@ -324,8 +322,7 @@ TEST_F(IPCChannelPosixTest, ResetState) {
   channel.ResetToAcceptingConnectionState();
   ASSERT_FALSE(channel.HasAcceptedConnection());
 
-  base::ProcessHandle handle2 = SpawnChild("IPCChannelPosixTestConnectionProc",
-                                          false);
+  base::ProcessHandle handle2 = SpawnChild("IPCChannelPosixTestConnectionProc");
   ASSERT_TRUE(handle2);
   SpinRunLoop(TestTimeouts::action_max_timeout());
   ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
@@ -374,14 +371,12 @@ TEST_F(IPCChannelPosixTest, MultiConnection) {
   ASSERT_TRUE(channel.AcceptsConnections());
   ASSERT_FALSE(channel.HasAcceptedConnection());
 
-  base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc",
-                                          false);
+  base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc");
   ASSERT_TRUE(handle);
   SpinRunLoop(TestTimeouts::action_max_timeout());
   ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
   ASSERT_TRUE(channel.HasAcceptedConnection());
-  base::ProcessHandle handle2 = SpawnChild("IPCChannelPosixFailConnectionProc",
-                                           false);
+  base::ProcessHandle handle2 = SpawnChild("IPCChannelPosixFailConnectionProc");
   ASSERT_TRUE(handle2);
   SpinRunLoop(TestTimeouts::action_max_timeout());
   int exit_code = 0;

ipc/ipc_test_base.cc

@@ -12,7 +12,6 @@
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "ipc/ipc_descriptors.h"
-#include "ipc/ipc_switches.h"
 
 #if defined(OS_POSIX)
 #include "base/posix/global_descriptors.h"
@@ -96,11 +95,9 @@ bool IPCTestBase::StartClient() {
   DCHECK(client_process_ == base::kNullProcessHandle);
 
   std::string test_main = test_client_name_ + "TestClientMain";
-  bool debug_on_start =
-      CommandLine::ForCurrentProcess()->HasSwitch(switches::kDebugChildren);
 
 #if defined(OS_WIN)
-  client_process_ = SpawnChild(test_main, debug_on_start);
+  client_process_ = SpawnChild(test_main);
 #elif defined(OS_POSIX)
   base::FileHandleMappingVector fds_to_map;
   const int ipcfd = channel_.get() ? channel_->GetClientFileDescriptor() :
@@ -110,7 +107,7 @@ bool IPCTestBase::StartClient() {
         kPrimaryIPCChannel + base::GlobalDescriptors::kBaseDescriptor));
   base::LaunchOptions options;
   options.fds_to_remap = &fds_to_map;
-  client_process_ = SpawnChildWithOptions(test_main, options, debug_on_start);
+  client_process_ = SpawnChildWithOptions(test_main, options);
 #endif
 
   return client_process_ != base::kNullProcessHandle;

mojo/common/test/multiprocess_test_helper.cc

@@ -48,8 +48,8 @@ void MultiprocessTestHelper::StartChild(const std::string& test_child_name) {
 #error "Not supported yet."
 #endif
 
-  test_child_handle_ = base::SpawnMultiProcessTestChild(
-      test_child_main, command_line, options, false);
+  test_child_handle_ =
+      base::SpawnMultiProcessTestChild(test_child_main, command_line, options);
   platform_channel_pair_->ChildProcessLaunched();
 
   CHECK_NE(test_child_handle_, base::kNullProcessHandle);