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

util/mach/exception_ports_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 358 matching lines @@
     kern_return_t kr = task_threads(ChildTask(), &threads, &thread_count);
     ASSERT_EQ(KERN_SUCCESS, kr) << MachErrorMessage(kr, "task_threads");
 
     ScopedForbidReturn threads_need_owners;
     ASSERT_EQ(2u, thread_count);
     base::mac::ScopedMachSendRight main_thread(threads[0]);
     base::mac::ScopedMachSendRight other_thread(threads[1]);
     threads_need_owners.Disarm();
 
     ExceptionPorts main_thread_ports(ExceptionPorts::kTargetTypeThread,
-                                     main_thread);
+                                     main_thread.get());
     ExceptionPorts other_thread_ports(ExceptionPorts::kTargetTypeThread,
-                                      other_thread);
+                                      other_thread.get());
     EXPECT_STREQ("thread", main_thread_ports.TargetTypeName());
     EXPECT_STREQ("thread", other_thread_ports.TargetTypeName());
 
     if (set_type_ == kSetOutOfProcess) {
       // Test ExceptionPorts::SetExceptionPorts() being called from
       // out-of-process.
       //
       // local_port is only a receive right, but a send right is needed for
       // ExceptionPorts::SetExceptionPort(). Make a send right, which can be
       // deallocated once the calls to ExceptionPorts::SetExceptionPort() are
@@ skipping 187 matching lines @@
   // make sure that TargetTypeName() returns the right string, and that the
   // underlying host_get_exception_ports() function appears to be called by
   // looking for a KERN_INVALID_ARGUMENT return value. Or, on the off chance
   // that the test is being run as root, just look for KERN_SUCCESS.
   // host_set_exception_ports() is not tested, because if the test were running
   // as root and the call succeeded, it would have global effects.
 
   const bool expect_success = geteuid() == 0;
 
   base::mac::ScopedMachSendRight host(mach_host_self());
-  ExceptionPorts explicit_host_ports(ExceptionPorts::kTargetTypeHost, host);
+  ExceptionPorts explicit_host_ports(ExceptionPorts::kTargetTypeHost,
+                                     host.get());
   EXPECT_STREQ("host", explicit_host_ports.TargetTypeName());
 
   ExceptionPorts::ExceptionHandlerVector explicit_handlers;
   bool rv =
       explicit_host_ports.GetExceptionPorts(ExcMaskValid(), &explicit_handlers);
   EXPECT_EQ(expect_success, rv);
 
   ExceptionPorts implicit_host_ports(ExceptionPorts::kTargetTypeHost,
                                      HOST_NULL);
   EXPECT_STREQ("host", implicit_host_ports.TargetTypeName());
 
   ExceptionPorts::ExceptionHandlerVector implicit_handlers;
   rv =
       implicit_host_ports.GetExceptionPorts(ExcMaskValid(), &implicit_handlers);
   EXPECT_EQ(expect_success, rv);
 
   EXPECT_EQ(explicit_handlers.size(), implicit_handlers.size());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad