Add and use scoped-right-returning wrappers for Mach bootstrap routines

test/mac/mach_multiprocess.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "test/mac/mach_multiprocess.h"
 
 #include <AvailabilityMacros.h>
 #include <bsm/libbsm.h>
-#include <servers/bootstrap.h>
 
 #include <string>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/mac/scoped_mach_port.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "gtest/gtest.h"
 #include "test/errors.h"
@@ skipping 61 matching lines @@
   ASSERT_NO_FATAL_FAILURE(Multiprocess::PreFork());
 
   // Set up the parent port and register it with the bootstrap server before
   // forking, so that it’s guaranteed to be there when the child attempts to
   // look it up.
   info_->service_name = "com.googlecode.crashpad.test.mach_multiprocess.";
   for (int index = 0; index < 16; ++index) {
     info_->service_name.append(1, base::RandInt('A', 'Z'));
   }
 
-  mach_port_t local_port;
-  kern_return_t kr = bootstrap_check_in(bootstrap_port,
-                                        info_->service_name.c_str(),
-                                        &local_port);
-  ASSERT_EQ(BOOTSTRAP_SUCCESS, kr)
-      << BootstrapErrorMessage(kr, "bootstrap_check_in");
-  info_->local_port.reset(local_port);
+  info_->local_port = BootstrapCheckIn(info_->service_name);
+  ASSERT_NE(kMachPortNull, info_->local_port);
 }
 
 mach_port_t MachMultiprocess::LocalPort() const {
   EXPECT_NE(kMachPortNull, info_->local_port);
   return info_->local_port;
 }
 
 mach_port_t MachMultiprocess::RemotePort() const {
   EXPECT_NE(kMachPortNull, info_->remote_port);
   return info_->remote_port;
@@ skipping 99 matching lines @@
 void MachMultiprocess::MultiprocessChild() {
   ScopedForbidReturn forbid_return;;
 
   // local_port is not valid in the forked child process.
   ignore_result(info_->local_port.release());
 
   info_->local_port.reset(NewMachPort(MACH_PORT_RIGHT_RECEIVE));
   ASSERT_NE(kMachPortNull, info_->local_port);
 
   // The remote port can be obtained from the bootstrap server.
-  mach_port_t remote_port;
-  kern_return_t kr = bootstrap_look_up(
-      bootstrap_port, info_->service_name.c_str(), &remote_port);
-  ASSERT_EQ(BOOTSTRAP_SUCCESS, kr)
-      << BootstrapErrorMessage(kr, "bootstrap_look_up");
-  info_->remote_port.reset(remote_port);
+  info_->remote_port = BootstrapLookUp(info_->service_name);
+  ASSERT_NE(kMachPortNull, info_->remote_port);
 
   // The “hello” message will provide the parent with its remote port, a send
   // right to the child task’s local port receive right. It will also carry a
   // send right to the child task’s task port.
   SendHelloMessage message = {};
   message.header.msgh_bits =
       MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND) |
       MACH_MSGH_BITS_COMPLEX;
   message.header.msgh_size = sizeof(message);
   message.header.msgh_remote_port = info_->remote_port;
   message.header.msgh_local_port = info_->local_port;
   message.body.msgh_descriptor_count = 1;
   message.port_descriptor.name = mach_task_self();
   message.port_descriptor.disposition = MACH_MSG_TYPE_COPY_SEND;
   message.port_descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
 
-  kr = mach_msg(&message.header,
-                MACH_SEND_MSG,
-                message.header.msgh_size,
-                0,
-                MACH_PORT_NULL,
-                MACH_MSG_TIMEOUT_NONE,
-                MACH_PORT_NULL);
+  kern_return_t kr = mach_msg(&message.header,
+                              MACH_SEND_MSG,
+                              message.header.msgh_size,
+                              0,
+                              MACH_PORT_NULL,
+                              MACH_MSG_TIMEOUT_NONE,
+                              MACH_PORT_NULL);
   ASSERT_EQ(MACH_MSG_SUCCESS, kr) << MachErrorMessage(kr, "mach_msg");
 
   MachMultiprocessChild();
 
   info_->remote_port.reset();
   info_->local_port.reset();
 
   // Close the write pipe now, for cases where the parent is waiting on it to
   // be closed as an indication that the child has finished.
   CloseWritePipe();
 
   // Wait for the parent process to close its end of the pipe. The child process
   // needs to remain alive until then because the parent process will attempt to
   // verify it using the task port it has access to via ChildTask().
   CheckedReadFileAtEOF(ReadPipeHandle());
 
   if (testing::Test::HasFailure()) {
     // Trigger the ScopedForbidReturn destructor.
     return;
   }
 
   forbid_return.Disarm();
 }
 
 }  // namespace test
 }  // namespace crashpad