Add NewMachPort() and its test, and switch call sites to use it

util/mach/notify_server_test.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 20 matching lines @@
 using testing::Eq;
 using testing::Invoke;
 using testing::Ne;
 using testing::Pointee;
 using testing::ResultOf;
 using testing::Return;
 using testing::SetArgPointee;
 using testing::StrictMock;
 using testing::WithArg;
 
-//! \brief Allocates and returns a new receive right.
-//!
-//! \return The new receive right. On failure, `MACH_PORT_NULL` with a gtest
-//!     failure added.
-mach_port_t NewReceiveRight() {
-  mach_port_t receive_right;
-  kern_return_t kr = mach_port_allocate(
-      mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &receive_right);
-  if (kr != KERN_SUCCESS) {
-    EXPECT_EQ(KERN_SUCCESS, kr) << MachErrorMessage(kr, "mach_port_allocate");
-    return MACH_PORT_NULL;
-  }
-  return receive_right;
-}
-
 //! \brief Adds a send right to an existing receive right.
 //!
 //! \param[in] receive_right The receive right to add a send right to.
 //!
 //! \return The send right, which will have the same name as the receive right.
 //!     On failure, `MACH_PORT_NULL` with a gtest failure added.
 mach_port_t SendRightFromReceiveRight(mach_port_t receive_right) {
   kern_return_t kr = mach_port_insert_right(
       mach_task_self(), receive_right, receive_right, MACH_MSG_TYPE_MAKE_SEND);
   if (kr != KERN_SUCCESS) {
@@ skipping 199 matching lines @@
   //! \brief Returns the receive right to be used for the server.
   //!
   //! This receive right is created lazily on a per-test basis. It is destroyed
   //! by TearDown() at the conclusion of each test.
   //!
   //! \return The server port receive right, creating it if one has not yet been
   //!     established for the current test. On failure, returns `MACH_PORT_NULL`
   //!     with a gtest failure added.
   mach_port_t ServerPort() {
     if (!server_port_) {
-      server_port_.reset(NewReceiveRight());
+      server_port_.reset(NewMachPort(MACH_PORT_RIGHT_RECEIVE));
+      EXPECT_NE(kMachPortNull, server_port_);
     }
 
     return server_port_;
   }
 
   // testing::Test:
   void TearDown() override {
     server_port_.reset();
   }
 
@@ skipping 28 matching lines @@
 }
 
 // When no notifications are requested, nothing should happen.
 TEST_F(NotifyServerTest, NoNotification) {
   RunServer();
 }
 
 // When a send-once right with a dead-name notification request is deallocated,
 // a port-deleted notification should be generated.
 TEST_F(NotifyServerTest, MachNotifyPortDeleted) {
-  base::mac::ScopedMachReceiveRight receive_right(NewReceiveRight());
+  base::mac::ScopedMachReceiveRight receive_right(
+      NewMachPort(MACH_PORT_RIGHT_RECEIVE));
   ASSERT_NE(kMachPortNull, receive_right);
 
   base::mac::ScopedMachSendRight send_once_right(
       SendOnceRightFromReceiveRight(receive_right));
   ASSERT_NE(kMachPortNull, send_once_right);
 
   ASSERT_TRUE(RequestMachPortNotification(
       send_once_right, MACH_NOTIFY_DEAD_NAME, 0));
 
   EXPECT_CALL(*this, DoMachNotifyPortDeleted(ServerPort(),
                                              send_once_right.get(),
                                              Ne(nullptr)))
       .WillOnce(Return(MIG_NO_REPLY))
       .RetiresOnSaturation();
 
   send_once_right.reset();
 
   RunServer();
 }
 
 // When a receive right with a port-destroyed notification request is destroyed,
 // a port-destroyed notification should be generated.
 TEST_F(NotifyServerTest, MachNotifyPortDestroyed) {
-  base::mac::ScopedMachReceiveRight receive_right(NewReceiveRight());
+  base::mac::ScopedMachReceiveRight receive_right(
+      NewMachPort(MACH_PORT_RIGHT_RECEIVE));
   ASSERT_NE(kMachPortNull, receive_right);
 
   ASSERT_TRUE(RequestMachPortNotification(
       receive_right, MACH_NOTIFY_PORT_DESTROYED, 0));
 
   EXPECT_CALL(*this, DoMachNotifyPortDestroyed(ServerPort(),
                                                ResultOf(IsReceiveRight, true),
                                                Ne(nullptr),
                                                Pointee(Eq(false))))
       .WillOnce(DoAll(SetArgPointee<3>(true), Return(MIG_NO_REPLY)))
       .RetiresOnSaturation();
 
   receive_right.reset();
 
   RunServer();
 }
 
 // When a receive right with a port-destroyed notification request is not
 // destroyed, no port-destroyed notification should be generated.
 TEST_F(NotifyServerTest, MachNotifyPortDestroyed_NoNotification) {
-  base::mac::ScopedMachReceiveRight receive_right(NewReceiveRight());
+  base::mac::ScopedMachReceiveRight receive_right(
+      NewMachPort(MACH_PORT_RIGHT_RECEIVE));
   ASSERT_NE(kMachPortNull, receive_right);
 
   ASSERT_TRUE(RequestMachPortNotification(
       receive_right, MACH_NOTIFY_PORT_DESTROYED, 0));
 
   RunServer();
 }
 
 // When a no-senders notification request is registered for a receive right with
 // no senders, a no-senders notification should be generated.
 TEST_F(NotifyServerTest, MachNotifyNoSenders_NoSendRight) {
-  base::mac::ScopedMachReceiveRight receive_right(NewReceiveRight());
+  base::mac::ScopedMachReceiveRight receive_right(
+      NewMachPort(MACH_PORT_RIGHT_RECEIVE));
   ASSERT_NE(kMachPortNull, receive_right);
 
   ASSERT_TRUE(RequestMachPortNotification(
       receive_right, MACH_NOTIFY_NO_SENDERS, 0));
 
   EXPECT_CALL(*this, DoMachNotifyNoSenders(ServerPort(), 0, Ne(nullptr)))
       .WillOnce(Return(MIG_NO_REPLY))
       .RetiresOnSaturation();
 
   RunServer();
 }
 
 // When the last send right corresponding to a receive right with a no-senders
 // notification request is deallocated, a no-senders notification should be
 // generated.
 TEST_F(NotifyServerTest, MachNotifyNoSenders_SendRightDeallocated) {
-  base::mac::ScopedMachReceiveRight receive_right(NewReceiveRight());
+  base::mac::ScopedMachReceiveRight receive_right(
+      NewMachPort(MACH_PORT_RIGHT_RECEIVE));
   ASSERT_NE(kMachPortNull, receive_right);
 
   base::mac::ScopedMachSendRight send_right(
       SendRightFromReceiveRight(receive_right));
   ASSERT_NE(kMachPortNull, send_right);
 
   ASSERT_TRUE(RequestMachPortNotification(
       receive_right, MACH_NOTIFY_NO_SENDERS, 1));
 
   EXPECT_CALL(*this, DoMachNotifyNoSenders(ServerPort(), 1, Ne(nullptr)))
       .WillOnce(Return(MIG_NO_REPLY))
       .RetiresOnSaturation();
 
   send_right.reset();
 
   RunServer();
 }
 
 // When the a receive right with a no-senders notification request never loses
 // all senders, no no-senders notification should be generated.
 TEST_F(NotifyServerTest, MachNotifyNoSenders_NoNotification) {
-  base::mac::ScopedMachReceiveRight receive_right(NewReceiveRight());
+  base::mac::ScopedMachReceiveRight receive_right(
+      NewMachPort(MACH_PORT_RIGHT_RECEIVE));
   ASSERT_NE(kMachPortNull, receive_right);
 
   base::mac::ScopedMachSendRight send_right_0(
       SendRightFromReceiveRight(receive_right));
   ASSERT_NE(kMachPortNull, send_right_0);
 
   base::mac::ScopedMachSendRight send_right_1(
       SendRightFromReceiveRight(receive_right));
   ASSERT_NE(kMachPortNull, send_right_1);
 
@@ skipping 21 matching lines @@
 
   send_once_right.reset();
 
   RunServer();
 }
 
 // When a send-once right is sent to a receiver that never dequeues the message,
 // the send-once right is destroyed, and a send-once notification should appear
 // on the reply port.
 TEST_F(NotifyServerTest, MachNotifySendOnce_ImplicitDeallocation) {
-  base::mac::ScopedMachReceiveRight receive_right(NewReceiveRight());
+  base::mac::ScopedMachReceiveRight receive_right(
+      NewMachPort(MACH_PORT_RIGHT_RECEIVE));
   ASSERT_NE(kMachPortNull, receive_right);
 
   mach_msg_empty_send_t message = {};
   message.header.msgh_bits =
       MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND, MACH_MSG_TYPE_MAKE_SEND_ONCE);
   message.header.msgh_size = sizeof(message);
   message.header.msgh_remote_port = receive_right;
   message.header.msgh_local_port = ServerPort();
   mach_msg_return_t mr = mach_msg(&message.header,
                                   MACH_SEND_MSG | MACH_SEND_TIMEOUT,
@@ skipping 10 matching lines @@
 
   receive_right.reset();
 
   RunServer();
 }
 
 // When the receive right corresponding to a send-once right with a dead-name
 // notification request is destroyed, a dead-name notification should be
 // generated.
 TEST_F(NotifyServerTest, MachNotifyDeadName) {
-  base::mac::ScopedMachReceiveRight receive_right(NewReceiveRight());
+  base::mac::ScopedMachReceiveRight receive_right(
+      NewMachPort(MACH_PORT_RIGHT_RECEIVE));
   ASSERT_NE(kMachPortNull, receive_right);
 
   base::mac::ScopedMachSendRight send_once_right(
       SendOnceRightFromReceiveRight(receive_right));
   ASSERT_NE(kMachPortNull, send_once_right);
 
   ASSERT_TRUE(RequestMachPortNotification(
       send_once_right, MACH_NOTIFY_DEAD_NAME, 0));
 
   // send_once_right becomes a dead name with the send-once right’s original
@@ skipping 16 matching lines @@
   EXPECT_TRUE(IsRight(send_once_right, MACH_PORT_TYPE_DEAD_NAME));
 
   EXPECT_EQ(0u, RightRefCount(send_once_right, MACH_PORT_RIGHT_SEND_ONCE));
   EXPECT_EQ(1u, DeadNameRightRefCount(send_once_right));
 }
 
 // When the receive right corresponding to a send-once right with a dead-name
 // notification request is not destroyed, no dead-name notification should be
 // generated.
 TEST_F(NotifyServerTest, MachNotifyDeadName_NoNotification) {
-  base::mac::ScopedMachReceiveRight receive_right(NewReceiveRight());
+  base::mac::ScopedMachReceiveRight receive_right(
+      NewMachPort(MACH_PORT_RIGHT_RECEIVE));
   ASSERT_NE(kMachPortNull, receive_right);
 
   base::mac::ScopedMachSendRight send_once_right(
       SendOnceRightFromReceiveRight(receive_right));
   ASSERT_NE(kMachPortNull, send_once_right);
 
   ASSERT_TRUE(RequestMachPortNotification(
       send_once_right, MACH_NOTIFY_DEAD_NAME, 0));
 
   RunServer();
 
   EXPECT_FALSE(IsRight(send_once_right, MACH_PORT_TYPE_DEAD_NAME));
 
   EXPECT_EQ(1u, RightRefCount(send_once_right, MACH_PORT_RIGHT_SEND_ONCE));
   EXPECT_EQ(0u, DeadNameRightRefCount(send_once_right));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad