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

util/mach/child_port_handshake.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 87 matching lines @@
   PCHECK(errno == 0) << "pthread_threadid_np";
   std::string service_name = base::StringPrintf(
       "com.googlecode.crashpad.child_port_handshake.%d.%llu.%016llx",
       getpid(),
       thread_id,
       base::RandUint64());
 
   // Check the new service in with the bootstrap server, obtaining a receive
   // right for it.
   base::mac::ScopedMachReceiveRight server_port(BootstrapCheckIn(service_name));
-  CHECK_NE(server_port, kMachPortNull);
+  CHECK(server_port.is_valid());
 
   // Share the service name with the client via the pipe.
   uint32_t service_name_length = service_name.size();
   if (!LoggingWriteFile(
           pipe_write, &service_name_length, sizeof(service_name_length))) {
     LOG(WARNING) << "no client check-in";
     return MACH_PORT_NULL;
   }
 
   if (!LoggingWriteFile(
           pipe_write, service_name.c_str(), service_name_length)) {
     LOG(WARNING) << "no client check-in";
     return MACH_PORT_NULL;
   }
 
   // A kqueue cannot monitor a raw Mach receive right with EVFILT_MACHPORT. It
   // requires a port set. Create a new port set and add the receive right to it.
   base::mac::ScopedMachPortSet server_port_set(
       NewMachPort(MACH_PORT_RIGHT_PORT_SET));
-  CHECK_NE(server_port_set, kMachPortNull);
+  CHECK(server_port_set.is_valid());
 
-  kern_return_t kr =
-      mach_port_insert_member(mach_task_self(), server_port, server_port_set);
+  kern_return_t kr = mach_port_insert_member(
+      mach_task_self(), server_port.get(), server_port_set.get());
   MACH_CHECK(kr == KERN_SUCCESS, kr) << "mach_port_insert_member";
 
   // Set up a kqueue to monitor both the server’s receive right and the write
   // side of the pipe. Messages from the client will be received via the receive
   // right, and the pipe will show EOF if the client closes its read side
   // prematurely.
   base::ScopedFD kq(kqueue());
   PCHECK(kq != -1) << "kqueue";
 
   struct kevent changelist[2];
   EV_SET(&changelist[0],
-         server_port_set,
+         server_port_set.get(),
          EVFILT_MACHPORT,
          EV_ADD | EV_CLEAR,
          0,
          0,
          nullptr);
   EV_SET(&changelist[1],
          pipe_write,
          EVFILT_WRITE,
          EV_ADD | EV_CLEAR,
          0,
@@ skipping 33 matching lines @@
 
     if (event.flags & EV_ERROR) {
       // kevent() may have put its error here.
       errno = event.data;
       PLOG(FATAL) << "kevent";
     }
 
     switch (event.filter) {
       case EVFILT_MACHPORT: {
         // There’s something to receive on the port set.
-        DCHECK_EQ(event.ident, server_port_set);
+        DCHECK_EQ(event.ident, server_port_set.get());
 
         // Run the message server in an inner loop instead of using
         // MachMessageServer::kPersistent. This allows the loop to exit as soon
         // as child_port_ is set, even if other messages are queued. This needs
         // to drain all messages, because the use of edge triggering (EV_CLEAR)
         // means that if more than one message is in the queue when kevent()
         // returns, no more notifications will be generated.
         while (!checked_in_) {
           // If a proper message is received from child_port_check_in(),
           // this will call HandleChildPortCheckIn().
           mach_msg_return_t mr =
               MachMessageServer::Run(&child_port_server,
-                                     server_port_set,
+                                     server_port_set.get(),
                                      MACH_MSG_OPTION_NONE,
                                      MachMessageServer::kOneShot,
                                      MachMessageServer::kReceiveLargeIgnore,
                                      kMachMessageTimeoutNonblocking);
           if (mr == MACH_RCV_TIMED_OUT) {
             break;
           } else if (mr != MACH_MSG_SUCCESS) {
             MACH_LOG(ERROR, mr) << "MachMessageServer::Run";
             return MACH_PORT_NULL;
           }
@@ skipping 101 matching lines @@
 
 // static
 void ChildPortHandshake::RunClientInternal_SendCheckIn(
     const std::string& service_name,
     child_port_token_t token,
     mach_port_t port,
     mach_msg_type_name_t right_type) {
   // Get a send right to the server by looking up the service with the bootstrap
   // server by name.
   base::mac::ScopedMachSendRight server_port(BootstrapLookUp(service_name));
-  CHECK_NE(server_port, kMachPortNull);
+  CHECK(server_port.is_valid());
 
   // Check in with the server.
-  kern_return_t kr = child_port_check_in(server_port, token, port, right_type);
+  kern_return_t kr =
+      child_port_check_in(server_port.get(), token, port, right_type);
   MACH_CHECK(kr == KERN_SUCCESS, kr) << "child_port_check_in";
 }
 
 }  // namespace crashpad