MultiProcessTest: Update SpawnChild* to return a Process.

ipc/ipc_test_base.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.
 
 #include "build/build_config.h"
 
 #include "ipc/ipc_test_base.h"
 
 #include "base/command_line.h"
 #include "base/process/kill.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "ipc/ipc_descriptors.h"
 
 #if defined(OS_POSIX)
 #include "base/posix/global_descriptors.h"
 #endif
 
 // static
 std::string IPCTestBase::GetChannelName(const std::string& test_client_name) {
   DCHECK(!test_client_name.empty());
   return test_client_name + "__Channel";
 }
 
-IPCTestBase::IPCTestBase()
-    : client_process_(base::kNullProcessHandle) {
+IPCTestBase::IPCTestBase() {
 }
 
 IPCTestBase::~IPCTestBase() {
 }
 
 void IPCTestBase::TearDown() {
   message_loop_.reset();
   MultiProcessTest::TearDown();
 }
 
@@ skipping 60 matching lines @@
 void IPCTestBase::DestroyChannelProxy() {
   CHECK(channel_proxy_.get());
   channel_proxy_.reset();
 }
 
 std::string IPCTestBase::GetTestMainName() const {
   return test_client_name_ + "TestClientMain";
 }
 
 bool IPCTestBase::DidStartClient() {
-  DCHECK_NE(base::kNullProcessHandle, client_process_);
-  return client_process_ != base::kNullProcessHandle;
+  DCHECK(client_process_.IsValid());
+  return client_process_.IsValid();
 }
 
 #if defined(OS_POSIX)
 
 bool IPCTestBase::StartClient() {
   return StartClientWithFD(channel_
                                ? channel_->GetClientFileDescriptor()
                                : channel_proxy_->GetClientFileDescriptor());
 }
 
 bool IPCTestBase::StartClientWithFD(int ipcfd) {
-  DCHECK_EQ(client_process_, base::kNullProcessHandle);
+  DCHECK(!client_process_.IsValid());
 
   base::FileHandleMappingVector fds_to_map;
   if (ipcfd > -1)
     fds_to_map.push_back(std::pair<int, int>(ipcfd,
         kPrimaryIPCChannel + base::GlobalDescriptors::kBaseDescriptor));
   base::LaunchOptions options;
   options.fds_to_remap = &fds_to_map;
   client_process_ = SpawnChildWithOptions(GetTestMainName(), options);
 
   return DidStartClient();
 }
 
 #elif defined(OS_WIN)
 
 bool IPCTestBase::StartClient() {
-  DCHECK_EQ(client_process_, base::kNullProcessHandle);
+  DCHECK(!client_process_.IsValid());
   client_process_ = SpawnChild(GetTestMainName());
   return DidStartClient();
 }
 
 #endif
 
 bool IPCTestBase::WaitForClientShutdown() {
-  DCHECK(client_process_ != base::kNullProcessHandle);
+  DCHECK(client_process_.IsValid());
 
-  bool rv = base::WaitForSingleProcess(client_process_,
+  bool rv = base::WaitForSingleProcess(client_process_.Handle(),
                                        base::TimeDelta::FromSeconds(5));
-  base::CloseProcessHandle(client_process_);
-  client_process_ = base::kNullProcessHandle;
+  client_process_.Close();
   return rv;
 }
 
 IPC::ChannelHandle IPCTestBase::GetTestChannelHandle() {
   return GetChannelName(test_client_name_);
 }
 
 scoped_refptr<base::TaskRunner> IPCTestBase::task_runner() {
   return message_loop_->message_loop_proxy();
 }
 
 scoped_ptr<IPC::ChannelFactory> IPCTestBase::CreateChannelFactory(
     const IPC::ChannelHandle& handle,
     base::TaskRunner* runner) {
   return IPC::ChannelFactory::Create(handle, IPC::Channel::MODE_SERVER);
 }