MultiProcessTest: Update SpawnChild* to return a Process.

chrome/browser/printing/cloud_print/test/cloud_print_proxy_process_browsertest.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.
 
 // Create a service process that uses a Mock to respond to the browser in order
 // to test launching the browser using the cloud print policy check command
 // line switch.
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/kill.h"
+#include "base/process/process.h"
 #include "base/rand_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/multiprocess_test.h"
 #include "base/test/test_timeouts.h"
 #include "base/time/default_tick_clock.h"
 #include "base/time/time.h"
 #include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service_factory.h"
@@ skipping 278 matching lines @@
  public:
   CloudPrintProxyPolicyStartupTest();
   ~CloudPrintProxyPolicyStartupTest() override;
 
   void SetUp() override;
   void TearDown() override;
 
   scoped_refptr<base::MessageLoopProxy> IOMessageLoopProxy() {
     return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
   }
-  base::ProcessHandle Launch(const std::string& name);
+  base::Process Launch(const std::string& name);
   void WaitForConnect();
   bool Send(IPC::Message* message);
-  void ShutdownAndWaitForExitWithTimeout(base::ProcessHandle handle);
+  void ShutdownAndWaitForExitWithTimeout(base::Process process);
 
   // IPC::Listener implementation
   bool OnMessageReceived(const IPC::Message& message) override { return false; }
   void OnChannelConnected(int32 peer_pid) override;
 
   // MultiProcessTest implementation.
   base::CommandLine MakeCmdLine(const std::string& procname) override;
 
   bool LaunchBrowser(const base::CommandLine& command_line, Profile* profile) {
     int return_code = 0;
@@ skipping 98 matching lines @@
 }
 
 void CloudPrintProxyPolicyStartupTest::TearDown() {
   browser_content_client_.reset();
   content_client_.reset();
   content::SetContentClient(NULL);
 
   TestingBrowserProcess::DeleteInstance();
 }
 
-base::ProcessHandle CloudPrintProxyPolicyStartupTest::Launch(
+base::Process CloudPrintProxyPolicyStartupTest::Launch(
     const std::string& name) {
   EXPECT_FALSE(CheckServiceProcessReady());
 
   startup_channel_id_ =
       base::StringPrintf("%d.%p.%d",
                          base::GetCurrentProcId(), this,
                          base::RandInt(0, std::numeric_limits<int>::max()));
   startup_channel_ = IPC::ChannelProxy::Create(startup_channel_id_,
                                                IPC::Channel::MODE_SERVER,
                                                this,
                                                IOMessageLoopProxy());
 
 #if defined(OS_POSIX)
   base::FileHandleMappingVector ipc_file_list;
   ipc_file_list.push_back(std::make_pair(
       startup_channel_->TakeClientFileDescriptor().release(),
       kPrimaryIPCChannel + base::GlobalDescriptors::kBaseDescriptor));
   base::LaunchOptions options;
   options.fds_to_remap = &ipc_file_list;
-  base::ProcessHandle handle = SpawnChildWithOptions(name, options);
+  base::Process process = SpawnChildWithOptions(name, options);
 #else
-  base::ProcessHandle handle = SpawnChild(name);
+  base::Process process = SpawnChild(name);
 #endif
-  EXPECT_TRUE(handle);
-  return handle;
+  EXPECT_TRUE(process.IsValid());
+  return process.Pass();
 }
 
 void CloudPrintProxyPolicyStartupTest::WaitForConnect() {
   observer_.Wait();
   EXPECT_TRUE(CheckServiceProcessReady());
   EXPECT_TRUE(base::MessageLoopProxy::current().get());
   ServiceProcessControl::GetInstance()->SetChannel(
       IPC::ChannelProxy::Create(GetServiceProcessChannel(),
                                 IPC::Channel::MODE_NAMED_CLIENT,
                                 ServiceProcessControl::GetInstance(),
                                 IOMessageLoopProxy()));
 }
 
 bool CloudPrintProxyPolicyStartupTest::Send(IPC::Message* message) {
   return ServiceProcessControl::GetInstance()->Send(message);
 }
 
 void CloudPrintProxyPolicyStartupTest::ShutdownAndWaitForExitWithTimeout(
-    base::ProcessHandle handle) {
+    base::Process process) {
   ASSERT_TRUE(Send(new ServiceMsg_Shutdown()));
 
   int exit_code = -100;
-  bool exited =
-      base::WaitForExitCodeWithTimeout(handle, &exit_code,
-                                       TestTimeouts::action_timeout());
+  bool exited = process.WaitForExitWithTimeout(TestTimeouts::action_timeout(),
+                                               &exit_code);
   EXPECT_TRUE(exited);
   EXPECT_EQ(exit_code, 0);
-  base::CloseProcessHandle(handle);
 }
 
 void CloudPrintProxyPolicyStartupTest::OnChannelConnected(int32 peer_pid) {
   observer_.Notify();
 }
 
 base::CommandLine CloudPrintProxyPolicyStartupTest::MakeCmdLine(
     const std::string& procname) {
   base::CommandLine cl = MultiProcessTest::MakeCmdLine(procname);
   cl.AppendSwitchASCII(switches::kProcessChannelID, startup_channel_id_);
 #if defined(OS_MACOSX)
   cl.AppendSwitchASCII(kTestExecutablePath, executable_path_.value());
 #endif
   return cl;
 }
 
 TEST_F(CloudPrintProxyPolicyStartupTest, StartAndShutdown) {
   TestingBrowserProcess* browser_process =
       TestingBrowserProcess::GetGlobal();
   TestingProfileManager profile_manager(browser_process);
   ASSERT_TRUE(profile_manager.SetUp());
 
   // Must be created after the TestingProfileManager since that creates the
   // LocalState for the BrowserProcess.  Must be created before profiles are
   // constructed.
   chrome::TestingIOThreadState testing_io_thread_state;
 
-  base::ProcessHandle handle =
+  base::Process process =
       Launch("CloudPrintMockService_StartEnabledWaitForQuit");
   WaitForConnect();
-  ShutdownAndWaitForExitWithTimeout(handle);
+  ShutdownAndWaitForExitWithTimeout(process.Pass());
   content::RunAllPendingInMessageLoop();
 }
 
 KeyedService* CloudPrintProxyServiceFactoryForPolicyTest(
     content::BrowserContext* profile) {
   CloudPrintProxyService* service =
       new CloudPrintProxyService(static_cast<Profile*>(profile));
   service->Initialize();
   return service;
 }
 
 TEST_F(CloudPrintProxyPolicyStartupTest, StartBrowserWithoutPolicy) {
-  base::ProcessHandle handle =
+  base::Process process =
       Launch("CloudPrintMockService_StartEnabledWaitForQuit");
 
   // Setup the Browser Process with a full IOThread::Globals.
   TestingBrowserProcess* browser_process =
       TestingBrowserProcess::GetGlobal();
 
   TestingProfileManager profile_manager(browser_process);
   ASSERT_TRUE(profile_manager.SetUp());
 
   // Must be created after the TestingProfileManager since that creates the
@@ skipping 23 matching lines @@
       TestTimeouts::action_timeout());
 
   bool should_run_loop = LaunchBrowser(command_line, profile);
   EXPECT_FALSE(should_run_loop);
   if (should_run_loop)
     run_loop.Run();
 
   EXPECT_EQ(MockServiceIPCServer::EnabledUserId(),
             prefs->GetString(prefs::kCloudPrintEmail));
 
-  ShutdownAndWaitForExitWithTimeout(handle);
+  ShutdownAndWaitForExitWithTimeout(process.Pass());
   content::RunAllPendingInMessageLoop();
   profile_manager.DeleteTestingProfile("StartBrowserWithoutPolicy");
 }
 
 TEST_F(CloudPrintProxyPolicyStartupTest, StartBrowserWithPolicy) {
-  base::ProcessHandle handle =
+  base::Process process =
       Launch("CloudPrintMockService_StartEnabledExpectDisabled");
 
   TestingBrowserProcess* browser_process =
       TestingBrowserProcess::GetGlobal();
   TestingProfileManager profile_manager(browser_process);
   ASSERT_TRUE(profile_manager.SetUp());
 
   // Must be created after the TestingProfileManager since that creates the
   // LocalState for the BrowserProcess.  Must be created before profiles are
   // constructed.
@@ skipping 24 matching lines @@
 
   bool should_run_loop = LaunchBrowser(command_line, profile);
 
   // No expectations on run_loop being true here; that would be a race
   // condition.
   if (should_run_loop)
     run_loop.Run();
 
   EXPECT_EQ("", prefs->GetString(prefs::kCloudPrintEmail));
 
-  ShutdownAndWaitForExitWithTimeout(handle);
+  ShutdownAndWaitForExitWithTimeout(process.Pass());
   content::RunAllPendingInMessageLoop();
   profile_manager.DeleteTestingProfile("StartBrowserWithPolicy");
 }