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

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 238 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_) {
+    if (!server_port_.is_valid()) {
       server_port_.reset(NewMachPort(MACH_PORT_RIGHT_RECEIVE));
-      EXPECT_NE(kMachPortNull, server_port_);
+      EXPECT_TRUE(server_port_.is_valid());
     }
 
-    return server_port_;
+    return server_port_.get();
   }
 
   // testing::Test:
   void TearDown() override {
     server_port_.reset();
   }
 
  private:
   base::mac::ScopedMachReceiveRight server_port_;
 
@@ skipping 27 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(
       NewMachPort(MACH_PORT_RIGHT_RECEIVE));
-  ASSERT_NE(kMachPortNull, receive_right);
+  ASSERT_TRUE(receive_right.is_valid());
 
   base::mac::ScopedMachSendRight send_once_right(
-      SendOnceRightFromReceiveRight(receive_right));
-  ASSERT_NE(kMachPortNull, send_once_right);
+      SendOnceRightFromReceiveRight(receive_right.get()));
+  ASSERT_TRUE(send_once_right.is_valid());
 
-  ASSERT_TRUE(
-      RequestMachPortNotification(send_once_right, MACH_NOTIFY_DEAD_NAME, 0));
+  ASSERT_TRUE(RequestMachPortNotification(
+      send_once_right.get(), MACH_NOTIFY_DEAD_NAME, 0));
 
   EXPECT_CALL(
       *this,
       DoMachNotifyPortDeleted(ServerPort(),
                               send_once_right.get(),
                               ResultOf(AuditPIDFromMachMessageTrailer, 0)))
       .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(
       NewMachPort(MACH_PORT_RIGHT_RECEIVE));
-  ASSERT_NE(kMachPortNull, receive_right);
+  ASSERT_TRUE(receive_right.is_valid());
 
   ASSERT_TRUE(RequestMachPortNotification(
-      receive_right, MACH_NOTIFY_PORT_DESTROYED, 0));
+      receive_right.get(), MACH_NOTIFY_PORT_DESTROYED, 0));
 
   EXPECT_CALL(
       *this,
       DoMachNotifyPortDestroyed(ServerPort(),
                                 ResultOf(IsReceiveRight, true),
                                 ResultOf(AuditPIDFromMachMessageTrailer, 0),
                                 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(
       NewMachPort(MACH_PORT_RIGHT_RECEIVE));
-  ASSERT_NE(kMachPortNull, receive_right);
+  ASSERT_TRUE(receive_right.is_valid());
 
   ASSERT_TRUE(RequestMachPortNotification(
-      receive_right, MACH_NOTIFY_PORT_DESTROYED, 0));
+      receive_right.get(), 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(
       NewMachPort(MACH_PORT_RIGHT_RECEIVE));
-  ASSERT_NE(kMachPortNull, receive_right);
+  ASSERT_TRUE(receive_right.is_valid());
 
-  ASSERT_TRUE(
-      RequestMachPortNotification(receive_right, MACH_NOTIFY_NO_SENDERS, 0));
+  ASSERT_TRUE(RequestMachPortNotification(
+      receive_right.get(), MACH_NOTIFY_NO_SENDERS, 0));
 
   EXPECT_CALL(*this,
               DoMachNotifyNoSenders(
                   ServerPort(), 0, ResultOf(AuditPIDFromMachMessageTrailer, 0)))
       .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(
       NewMachPort(MACH_PORT_RIGHT_RECEIVE));
-  ASSERT_NE(kMachPortNull, receive_right);
+  ASSERT_TRUE(receive_right.is_valid());
 
   base::mac::ScopedMachSendRight send_right(
-      SendRightFromReceiveRight(receive_right));
-  ASSERT_NE(kMachPortNull, send_right);
+      SendRightFromReceiveRight(receive_right.get()));
+  ASSERT_TRUE(send_right.is_valid());
 
-  ASSERT_TRUE(
-      RequestMachPortNotification(receive_right, MACH_NOTIFY_NO_SENDERS, 1));
+  ASSERT_TRUE(RequestMachPortNotification(
+      receive_right.get(), MACH_NOTIFY_NO_SENDERS, 1));
 
   EXPECT_CALL(*this,
               DoMachNotifyNoSenders(
                   ServerPort(), 1, ResultOf(AuditPIDFromMachMessageTrailer, 0)))
       .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(
       NewMachPort(MACH_PORT_RIGHT_RECEIVE));
-  ASSERT_NE(kMachPortNull, receive_right);
+  ASSERT_TRUE(receive_right.is_valid());
 
   base::mac::ScopedMachSendRight send_right_0(
-      SendRightFromReceiveRight(receive_right));
-  ASSERT_NE(kMachPortNull, send_right_0);
+      SendRightFromReceiveRight(receive_right.get()));
+  ASSERT_TRUE(send_right_0.is_valid());
 
   base::mac::ScopedMachSendRight send_right_1(
-      SendRightFromReceiveRight(receive_right));
-  ASSERT_NE(kMachPortNull, send_right_1);
+      SendRightFromReceiveRight(receive_right.get()));
+  ASSERT_TRUE(send_right_1.is_valid());
 
-  ASSERT_TRUE(
-      RequestMachPortNotification(receive_right, MACH_NOTIFY_NO_SENDERS, 1));
+  ASSERT_TRUE(RequestMachPortNotification(
+      receive_right.get(), MACH_NOTIFY_NO_SENDERS, 1));
 
   send_right_1.reset();
 
   RunServer();
 
-  EXPECT_EQ(1u, RightRefCount(receive_right, MACH_PORT_RIGHT_RECEIVE));
-  EXPECT_EQ(1u, RightRefCount(receive_right, MACH_PORT_RIGHT_SEND));
+  EXPECT_EQ(1u, RightRefCount(receive_right.get(), MACH_PORT_RIGHT_RECEIVE));
+  EXPECT_EQ(1u, RightRefCount(receive_right.get(), MACH_PORT_RIGHT_SEND));
 }
 
 // When a send-once right is deallocated without being used, a send-once
 // notification notification should be sent via the send-once right.
 TEST_F(NotifyServerTest, MachNotifySendOnce_ExplicitDeallocation) {
   base::mac::ScopedMachSendRight send_once_right(
       SendOnceRightFromReceiveRight(ServerPort()));
-  ASSERT_NE(kMachPortNull, send_once_right);
+  ASSERT_TRUE(send_once_right.is_valid());
 
   EXPECT_CALL(*this,
               DoMachNotifySendOnce(ServerPort(),
                                    ResultOf(AuditPIDFromMachMessageTrailer, 0)))
       .WillOnce(Return(MIG_NO_REPLY))
       .RetiresOnSaturation();
 
   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(
       NewMachPort(MACH_PORT_RIGHT_RECEIVE));
-  ASSERT_NE(kMachPortNull, receive_right);
+  ASSERT_TRUE(receive_right.is_valid());
 
   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_remote_port = receive_right.get();
   message.header.msgh_local_port = ServerPort();
   mach_msg_return_t mr = mach_msg(&message.header,
                                   MACH_SEND_MSG | MACH_SEND_TIMEOUT,
                                   message.header.msgh_size,
                                   0,
                                   MACH_PORT_NULL,
                                   0,
                                   MACH_PORT_NULL);
   ASSERT_EQ(MACH_MSG_SUCCESS, mr) << MachErrorMessage(mr, "mach_msg");
 
   EXPECT_CALL(*this,
               DoMachNotifySendOnce(ServerPort(),
                                    ResultOf(AuditPIDFromMachMessageTrailer, 0)))
       .WillOnce(Return(MIG_NO_REPLY))
       .RetiresOnSaturation();
 
   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(
       NewMachPort(MACH_PORT_RIGHT_RECEIVE));
-  ASSERT_NE(kMachPortNull, receive_right);
+  ASSERT_TRUE(receive_right.is_valid());
 
   base::mac::ScopedMachSendRight send_once_right(
-      SendOnceRightFromReceiveRight(receive_right));
-  ASSERT_NE(kMachPortNull, send_once_right);
+      SendOnceRightFromReceiveRight(receive_right.get()));
+  ASSERT_TRUE(send_once_right.is_valid());
 
-  ASSERT_TRUE(
-      RequestMachPortNotification(send_once_right, MACH_NOTIFY_DEAD_NAME, 0));
+  ASSERT_TRUE(RequestMachPortNotification(
+      send_once_right.get(), MACH_NOTIFY_DEAD_NAME, 0));
 
   // send_once_right becomes a dead name with the send-once right’s original
   // user reference count of 1, but the dead-name notification increments the
   // dead-name reference count, so it becomes 2. Take care to deallocate that
   // reference. The original reference is managed by send_once_right_owner.
   EXPECT_CALL(*this,
               DoMachNotifyDeadName(ServerPort(),
                                    AllOf(send_once_right.get(),
                                          ResultOf(DeadNameRightRefCount, 2)),
                                    ResultOf(AuditPIDFromMachMessageTrailer, 0)))
       .WillOnce(
            DoAll(WithArg<1>(Invoke(MachPortDeallocate)), Return(MIG_NO_REPLY)))
       .RetiresOnSaturation();
 
   receive_right.reset();
 
   RunServer();
 
-  EXPECT_TRUE(IsRight(send_once_right, MACH_PORT_TYPE_DEAD_NAME));
+  EXPECT_TRUE(IsRight(send_once_right.get(), MACH_PORT_TYPE_DEAD_NAME));
 
-  EXPECT_EQ(0u, RightRefCount(send_once_right, MACH_PORT_RIGHT_SEND_ONCE));
-  EXPECT_EQ(1u, DeadNameRightRefCount(send_once_right));
+  EXPECT_EQ(0u,
+            RightRefCount(send_once_right.get(), MACH_PORT_RIGHT_SEND_ONCE));
+  EXPECT_EQ(1u, DeadNameRightRefCount(send_once_right.get()));
 }
 
 // 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(
       NewMachPort(MACH_PORT_RIGHT_RECEIVE));
-  ASSERT_NE(kMachPortNull, receive_right);
+  ASSERT_TRUE(receive_right.is_valid());
 
   base::mac::ScopedMachSendRight send_once_right(
-      SendOnceRightFromReceiveRight(receive_right));
-  ASSERT_NE(kMachPortNull, send_once_right);
+      SendOnceRightFromReceiveRight(receive_right.get()));
+  ASSERT_TRUE(send_once_right.is_valid());
 
-  ASSERT_TRUE(
-      RequestMachPortNotification(send_once_right, MACH_NOTIFY_DEAD_NAME, 0));
+  ASSERT_TRUE(RequestMachPortNotification(
+      send_once_right.get(), MACH_NOTIFY_DEAD_NAME, 0));
 
   RunServer();
 
-  EXPECT_FALSE(IsRight(send_once_right, MACH_PORT_TYPE_DEAD_NAME));
+  EXPECT_FALSE(IsRight(send_once_right.get(), MACH_PORT_TYPE_DEAD_NAME));
 
-  EXPECT_EQ(1u, RightRefCount(send_once_right, MACH_PORT_RIGHT_SEND_ONCE));
-  EXPECT_EQ(0u, DeadNameRightRefCount(send_once_right));
+  EXPECT_EQ(1u,
+            RightRefCount(send_once_right.get(), MACH_PORT_RIGHT_SEND_ONCE));
+  EXPECT_EQ(0u, DeadNameRightRefCount(send_once_right.get()));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad