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

handler/mac/exception_handler_server.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 23 matching lines @@
       UniversalMachExcServer::Interface* exception_interface)
       : UniversalMachExcServer::Interface(),
         NotifyServer::Interface(),
         mach_exc_server_(this),
         notify_server_(this),
         composite_mach_message_server_(),
         exception_interface_(exception_interface),
         exception_port_(exception_port),
         notify_port_(NewMachPort(MACH_PORT_RIGHT_RECEIVE)),
         running_(true) {
-    CHECK_NE(notify_port_, kMachPortNull);
+    CHECK(notify_port_.is_valid());
 
     composite_mach_message_server_.AddHandler(&mach_exc_server_);
     composite_mach_message_server_.AddHandler(&notify_server_);
   }
 
   ~ExceptionHandlerServerRun() {
   }
 
   void Run() {
     DCHECK(running_);
 
     // Request that a no-senders notification for exception_port_ be sent to
     // notify_port_.
     mach_port_t previous;
     kern_return_t kr =
         mach_port_request_notification(mach_task_self(),
                                        exception_port_,
                                        MACH_NOTIFY_NO_SENDERS,
                                        0,
-                                       notify_port_,
+                                       notify_port_.get(),
                                        MACH_MSG_TYPE_MAKE_SEND_ONCE,
                                        &previous);
     MACH_CHECK(kr == KERN_SUCCESS, kr) << "mach_port_request_notification";
 
     if (previous != MACH_PORT_NULL) {
       kr = mach_port_deallocate(mach_task_self(), previous);
       MACH_CHECK(kr == KERN_SUCCESS, kr) << "mach_port_deallocate";
     }
 
     // A single CompositeMachMessageServer will dispatch both exception messages
     // and the no-senders notification. Put both receive rights into a port set.
     //
     // A single receive right can’t be used because the notification request
     // requires a send-once right, which would prevent the no-senders condition
     // from ever existing. Using distinct receive rights also allows the handler
     // methods to ensure that the messages they process were sent by a holder of
     // the proper send right.
     base::mac::ScopedMachPortSet server_port_set(
         NewMachPort(MACH_PORT_RIGHT_PORT_SET));
 
     kr = mach_port_insert_member(
-        mach_task_self(), exception_port_, server_port_set);
+        mach_task_self(), exception_port_, server_port_set.get());
     MACH_CHECK(kr == KERN_SUCCESS, kr) << "mach_port_insert_member";
 
     kr = mach_port_insert_member(
-        mach_task_self(), notify_port_, server_port_set);
+        mach_task_self(), notify_port_.get(), server_port_set.get());
     MACH_CHECK(kr == KERN_SUCCESS, kr) << "mach_port_insert_member";
 
     // Run the server in kOneShot mode so that running_ can be reevaluated after
     // each message. Receipt of a valid no-senders notification causes it to be
     // set to false.
     while (running_) {
       // This will result in a call to CatchMachException() or
       // DoMachNotifyNoSenders() as appropriate.
       mach_msg_return_t mr =
           MachMessageServer::Run(&composite_mach_message_server_,
-                                 server_port_set,
+                                 server_port_set.get(),
                                  kMachMessageReceiveAuditTrailer,
                                  MachMessageServer::kOneShot,
                                  MachMessageServer::kReceiveLargeIgnore,
                                  kMachMessageTimeoutWaitIndefinitely);
       MACH_CHECK(mr == MACH_MSG_SUCCESS, mr) << "MachMessageServer::Run";
     }
   }
 
   // UniversalMachExcServer::Interface:
 
@@ skipping 102 matching lines @@
   base::mac::ScopedMachReceiveRight notify_port_;
   bool running_;
 
   DISALLOW_COPY_AND_ASSIGN(ExceptionHandlerServerRun);
 };
 
 }  // namespace
 
 ExceptionHandlerServer::ExceptionHandlerServer()
     : receive_port_(NewMachPort(MACH_PORT_RIGHT_RECEIVE)) {
-  CHECK_NE(receive_port_, kMachPortNull);
+  CHECK(receive_port_.is_valid());
 }
 
 ExceptionHandlerServer::~ExceptionHandlerServer() {
 }
 
 void ExceptionHandlerServer::Run(
     UniversalMachExcServer::Interface* exception_interface) {
-  ExceptionHandlerServerRun run(receive_port_, exception_interface);
+  ExceptionHandlerServerRun run(receive_port_.get(), exception_interface);
   run.Run();
 }
 
 }  // namespace crashpad