MultiProcessTest: Update SpawnChild* to return a Process.

sandbox/mac/bootstrap_sandbox_unittest.mm

 // Copyright 2014 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 "sandbox/mac/bootstrap_sandbox.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 #import <Foundation/Foundation.h>
 #include <mach/mach.h>
 #include <servers/bootstrap.h>
@@ skipping 82 matching lines @@
       policy.rules["com.apple.SecurityServer"] = Rule(POLICY_ALLOW);
     return policy;
   }
 
   void RunChildWithPolicy(int policy_id,
                           const char* child_name,
                           base::ProcessHandle* out_pid) {
     sandbox_->PrepareToForkWithPolicy(policy_id);
     base::LaunchOptions options;
     options.replacement_bootstrap_name = sandbox_->server_bootstrap_name();
-    base::ProcessHandle pid = SpawnChildWithOptions(child_name, options);
-    ASSERT_GT(pid, 0);
-    sandbox_->FinishedFork(pid);
+    base::Process process = SpawnChildWithOptions(child_name, options);
+    ASSERT_TRUE(process.IsValid());
+    sandbox_->FinishedFork(process.Handle());
     int code = 0;
-    EXPECT_TRUE(base::WaitForExitCode(pid, &code));
+    EXPECT_TRUE(process.WaitForExit(&code));
     EXPECT_EQ(0, code);
     if (out_pid)
-      *out_pid = pid;
+      *out_pid = process.pid();
   }
 
  protected:
   scoped_ptr<BootstrapSandbox> sandbox_;
 };
 
 const char kNotificationTestMain[] = "PostNotification";
 
 // Run the test without the sandbox.
 TEST_F(BootstrapSandboxTest, DistributedNotifications_Unsandboxed) {
   base::scoped_nsobject<DistributedNotificationObserver> observer(
       [[DistributedNotificationObserver alloc] init]);
 
-  base::ProcessHandle pid = SpawnChild(kNotificationTestMain);
-  ASSERT_GT(pid, 0);
+  base::Process process = SpawnChild(kNotificationTestMain);
+  ASSERT_TRUE(process.IsValid());
   int code = 0;
-  EXPECT_TRUE(base::WaitForExitCode(pid, &code));
+  EXPECT_TRUE(process.WaitForExit(&code));
   EXPECT_EQ(0, code);
 
   [observer waitForNotification];
   EXPECT_EQ(1, [observer receivedCount]);
-  EXPECT_EQ(pid, [[observer object] intValue]);
+  EXPECT_EQ(process.pid(), [[observer object] intValue]);
 }
 
 // Run the test with the sandbox enabled without notifications on the policy
 // whitelist.
 TEST_F(BootstrapSandboxTest, DistributedNotifications_SandboxDeny) {
   base::scoped_nsobject<DistributedNotificationObserver> observer(
       [[DistributedNotificationObserver alloc] init]);
 
   sandbox_->RegisterSandboxPolicy(1, BaselinePolicy());
   RunChildWithPolicy(1, kNotificationTestMain, NULL);
@@ skipping 289 matching lines @@
 
   // Set up the policy and register the port.
   BootstrapSandboxPolicy policy(BaselinePolicy());
   policy.rules["sync"] = Rule(port);
   sandbox_->RegisterSandboxPolicy(kTestPolicyId, policy);
 
   // Launch the child.
   sandbox_->PrepareToForkWithPolicy(kTestPolicyId);
   base::LaunchOptions options;
   options.replacement_bootstrap_name = sandbox_->server_bootstrap_name();
-  base::ProcessHandle pid =
-      SpawnChildWithOptions("ChildOutliveSandbox", options);
-  ASSERT_GT(pid, 0);
-  sandbox_->FinishedFork(pid);
+  base::Process process = SpawnChildWithOptions("ChildOutliveSandbox", options);
+  ASSERT_TRUE(process.IsValid());
+  sandbox_->FinishedFork(process.Handle());
 
   // Synchronize with the child.
   mach_msg_empty_rcv_t rcv_msg;
   bzero(&rcv_msg, sizeof(rcv_msg));
   kern_return_t kr = mach_msg(&rcv_msg.header, MACH_RCV_MSG, 0,
       sizeof(rcv_msg), port,
       TestTimeouts::tiny_timeout().InMilliseconds(), MACH_PORT_NULL);
   ASSERT_EQ(KERN_SUCCESS, kr) << mach_error_string(kr);
 
   // Destroy the sandbox.
   sandbox_.reset();
 
   // Synchronize again with the child.
   mach_msg_empty_send_t send_msg;
   bzero(&send_msg, sizeof(send_msg));
   send_msg.header.msgh_size = sizeof(send_msg);
   send_msg.header.msgh_remote_port = rcv_msg.header.msgh_remote_port;
   send_msg.header.msgh_bits =
       MACH_MSGH_BITS_REMOTE(MACH_MSG_TYPE_MOVE_SEND_ONCE);
   kr = mach_msg(&send_msg.header, MACH_SEND_MSG, send_msg.header.msgh_size, 0,
       MACH_PORT_NULL, TestTimeouts::tiny_timeout().InMilliseconds(),
       MACH_PORT_NULL);
   EXPECT_EQ(KERN_SUCCESS, kr) << mach_error_string(kr);
 
   int code = 0;
-  EXPECT_TRUE(base::WaitForExitCode(pid, &code));
+  EXPECT_TRUE(process.WaitForExit(&code));
   EXPECT_EQ(0, code);
 }
 
 MULTIPROCESS_TEST_MAIN(ChildOutliveSandbox) {
   // Get the synchronization channel.
   mach_port_t port = MACH_PORT_NULL;
   CHECK_EQ(KERN_SUCCESS, bootstrap_look_up(bootstrap_port, "sync", &port));
 
   // Create a reply port.
   mach_port_t reply_port;
@@ skipping 28 matching lines @@
   kr = mach_msg_receive(&rcv_msg.header);
   MACH_CHECK(kr == KERN_SUCCESS, kr) << "mach_msg_receive";
 
   // Try to message the sandbox.
   bootstrap_look_up(bootstrap_port, "test", &port);
 
   return 0;
 }
 
 }  // namespace sandbox