Refactor the bootstrap sandbox process launching integration.

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>
 
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/mach_logging.h"
 #include "base/mac/scoped_mach_port.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/process/kill.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/multiprocess_test.h"
 #include "base/test/test_timeouts.h"
+#include "sandbox/mac/pre_exec_delegate.h"
 #include "sandbox/mac/xpc.h"
 #import "testing/gtest_mac.h"
 #include "testing/multiprocess_func_list.h"
 
 NSString* const kTestNotification = @"org.chromium.bootstrap_sandbox_test";
 
 @interface DistributedNotificationObserver : NSObject {
  @private
   int receivedCount_;
   base::scoped_nsobject<NSString> object_;
@@ skipping 66 matching lines @@
     BootstrapSandboxPolicy policy;
     policy.rules["com.apple.cfprefsd.daemon"] = Rule(POLICY_ALLOW);
     if (base::mac::IsOSSnowLeopard())
       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);
+    scoped_ptr<PreExecDelegate> pre_exec_delegate(
+        sandbox_->NewClient(policy_id));
+
     base::LaunchOptions options;
-    options.replacement_bootstrap_name = sandbox_->server_bootstrap_name();
+    options.pre_exec_delegate = pre_exec_delegate.get();
+
     base::Process process = SpawnChildWithOptions(child_name, options);
     ASSERT_TRUE(process.IsValid());
-    sandbox_->FinishedFork(process.Handle());
     int code = 0;
     EXPECT_TRUE(process.WaitForExit(&code));
     EXPECT_EQ(0, code);
     if (out_pid)
       *out_pid = process.Pid();
   }
 
  protected:
   scoped_ptr<BootstrapSandbox> sandbox_;
 };
@@ skipping 323 matching lines @@
   ASSERT_EQ(KERN_SUCCESS, mach_port_insert_right(task, port, port,
       MACH_MSG_TYPE_MAKE_SEND));
   base::mac::ScopedMachSendRight scoped_port_send(port);
 
   // 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);
+  scoped_ptr<PreExecDelegate> pre_exec_delegate(
+      sandbox_->NewClient(kTestPolicyId));
   base::LaunchOptions options;
-  options.replacement_bootstrap_name = sandbox_->server_bootstrap_name();
+  options.pre_exec_delegate = pre_exec_delegate.get();
   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.
@@ skipping 56 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