Mach port scopers should use get() instead of type conversion operators

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,
@@ skipping 80 matching lines @@
 
   // 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'));
   }
 
   info_->local_port = BootstrapCheckIn(info_->service_name);
-  ASSERT_NE(kMachPortNull, info_->local_port);
+  ASSERT_TRUE(info_->local_port.is_valid());
 }
 
 mach_port_t MachMultiprocess::LocalPort() const {
-  EXPECT_NE(kMachPortNull, info_->local_port);
-  return info_->local_port;
+  EXPECT_TRUE(info_->local_port.is_valid());
+  return info_->local_port.get();
 }
 
 mach_port_t MachMultiprocess::RemotePort() const {
-  EXPECT_NE(kMachPortNull, info_->remote_port);
-  return info_->remote_port;
+  EXPECT_TRUE(info_->remote_port.is_valid());
+  return info_->remote_port.get();
 }
 
 task_t MachMultiprocess::ChildTask() const {
-  EXPECT_NE(TASK_NULL, info_->child_task);
-  return info_->child_task;
+  EXPECT_TRUE(info_->child_task.is_valid());
+  return info_->child_task.get();
 }
 
 void MachMultiprocess::MultiprocessParent() {
   ReceiveHelloMessage message = {};
 
   kern_return_t kr = mach_msg(&message.header,
                               MACH_RCV_MSG | kMachMessageReceiveAuditTrailer,
                               0,
                               sizeof(message),
-                              info_->local_port,
+                              info_->local_port.get(),
                               MACH_MSG_TIMEOUT_NONE,
                               MACH_PORT_NULL);
   ASSERT_EQ(MACH_MSG_SUCCESS, kr) << MachErrorMessage(kr, "mach_msg");
 
   // Comb through the entire message, checking every field against its expected
   // value.
   EXPECT_EQ(MACH_MSGH_BITS(MACH_MSG_TYPE_MOVE_SEND, MACH_MSG_TYPE_MOVE_SEND) |
                 MACH_MSGH_BITS_COMPLEX,
             message.header.msgh_bits);
   ASSERT_EQ(sizeof(SendHelloMessage), message.header.msgh_size);
@@ skipping 54 matching lines @@
   EXPECT_EQ(audit_info.ai_auid, audit_auid);
   EXPECT_EQ(audit_info.ai_asid, audit_asid);
 
   // Retrieve the remote port from the message header, and the child’s task port
   // from the message body.
   info_->remote_port.reset(message.header.msgh_remote_port);
   info_->child_task.reset(message.port_descriptor.name);
 
   // Verify that the child’s task port is what it purports to be.
   int mach_pid;
-  kr = pid_for_task(info_->child_task, &mach_pid);
+  kr = pid_for_task(info_->child_task.get(), &mach_pid);
   ASSERT_EQ(KERN_SUCCESS, kr) << MachErrorMessage(kr, "pid_for_task");
   ASSERT_EQ(ChildPID(), mach_pid);
 
   MachMultiprocessParent();
 
   info_->remote_port.reset();
   info_->local_port.reset();
 }
 
 void MachMultiprocess::MultiprocessChild() {
@@ skipping 10 matching lines @@
   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.header.msgh_remote_port = info_->remote_port.get();
+  message.header.msgh_local_port = info_->local_port.get();
   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;
 
   kern_return_t kr = mach_msg(&message.header,
                               MACH_SEND_MSG,
                               message.header.msgh_size,
                               0,
                               MACH_PORT_NULL,
@@ skipping 18 matching lines @@
   if (testing::Test::HasFailure()) {
     // Trigger the ScopedForbidReturn destructor.
     return;
   }
 
   forbid_return.Disarm();
 }
 
 }  // namespace test
 }  // namespace crashpad