Changing multiprocess test SpawnChild to return a struct.

chrome/browser/process_singleton_win_unittest.cc

 // Copyright 2015 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 "chrome/browser/process_singleton.h"
 
 #include <windows.h>
 
 #include <memory>
 
@@ skipping 143 matching lines @@
     ASSERT_NO_FATAL_FAILURE(base::MultiProcessTest::SetUp());
 
     // Drop the process finder notification timeout to one second for testing.
     old_notification_timeout_ = chrome::SetNotificationTimeoutForTesting(
         base::TimeDelta::FromSeconds(1));
   }
 
   void TearDown() override {
     chrome::SetNotificationTimeoutForTesting(old_notification_timeout_);
 
-    if (browser_victim_.IsValid()) {
+    if (browser_victim_.process.IsValid()) {
       EXPECT_TRUE(::SetEvent(continue_event_.Get()));
-      EXPECT_TRUE(browser_victim_.WaitForExit(nullptr));
+      EXPECT_TRUE(browser_victim_.process.WaitForExit(nullptr));
     }
 
     base::MultiProcessTest::TearDown();
   }
 
   void LaunchHungBrowserProcess(WindowOption window_option) {
     // Create a unique user data dir to rendezvous on.
     ASSERT_TRUE(user_data_dir_.CreateUniqueTempDir());
 
     // Create the named "ready" event, this is unique to our process.
@@ skipping 11 matching lines @@
     ASSERT_TRUE(continue_event_.IsValid());
 
     window_option_ = window_option;
 
     base::LaunchOptions options;
     options.start_hidden = true;
     browser_victim_ =
         SpawnChildWithOptions("ProcessSingletonTestProcessMain", options);
 
     // Wait for the ready event (or process exit).
-    HANDLE handles[] = {ready_event.Get(), browser_victim_.Handle()};
+    HANDLE handles[] = {ready_event.Get(), browser_victim_.process.Handle()};
     // The wait should always return because either |ready_event| is signaled or
     // |browser_victim_| died unexpectedly or exited on error.
     DWORD result =
         ::WaitForMultipleObjects(arraysize(handles), handles, FALSE, INFINITE);
     ASSERT_EQ(WAIT_OBJECT_0, result);
   }
 
   base::CommandLine MakeCmdLine(const std::string& procname) override {
     base::CommandLine cmd_line = base::MultiProcessTest::MakeCmdLine(procname);
 
@@ skipping 12 matching lines @@
     // The ready event has been signalled - the process singleton is held by
     // the hung sub process.
     test_singleton_.reset(new ProcessSingleton(
         user_data_dir(), base::Bind(&NotificationCallback)));
 
     test_singleton_->OverrideShouldKillRemoteProcessCallbackForTesting(
         base::Bind(&ProcessSingletonTest::MockShouldKillRemoteProcess,
                    base::Unretained(this), allow_kill));
   }
 
-  base::Process* browser_victim() { return &browser_victim_; }
+  base::Process* browser_victim() { return &(browser_victim_.process); }
   const base::FilePath& user_data_dir() const {
     return user_data_dir_.GetPath();
   }
   ProcessSingleton* test_singleton() const { return test_singleton_.get(); }
   bool should_kill_called() const { return should_kill_called_; }
 
  private:
   bool MockShouldKillRemoteProcess(bool allow_kill) {
     should_kill_called_ = true;
     return allow_kill;
   }
 
   base::string16 ready_event_name_;
   base::string16 continue_event_name_;
 
   WindowOption window_option_;
   base::ScopedTempDir user_data_dir_;
-  base::Process browser_victim_;
+  base::SpawnChildResult browser_victim_;
   base::win::ScopedHandle continue_event_;
 
   std::unique_ptr<ProcessSingleton> test_singleton_;
 
   base::TimeDelta old_notification_timeout_;
   bool should_kill_called_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessSingletonTest);
 };
 
@@ skipping 58 matching lines @@
   // visible window.
   EXPECT_TRUE(should_kill_called());
 
   // Verify that the hung browser has been terminated with the
   // RESULT_CODE_HUNG exit code.
   int exit_code = 0;
   EXPECT_TRUE(
       browser_victim()->WaitForExitWithTimeout(base::TimeDelta(), &exit_code));
   EXPECT_EQ(content::RESULT_CODE_HUNG, exit_code);
 }