mac: Make Mach port scopers better ScopedGenerics

base/memory/shared_memory_mac_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <mach/mach.h>
 #include <mach/mach_vm.h>
 #include <servers/bootstrap.h>
 
 #include "base/command_line.h"
 #include "base/mac/mach_logging.h"
@@ skipping 108 matching lines @@
 // Sets up the mach communication ports with the server. Returns a port to which
 // the server will send mach objects.
 mach_port_t CommonChildProcessSetUp() {
   CommandLine cmd_line = *CommandLine::ForCurrentProcess();
   std::string service_name =
       cmd_line.GetSwitchValueASCII(g_service_switch_name);
   mac::ScopedMachSendRight server_port(LookupServer(service_name.c_str()));
   mach_port_t client_port = MakeReceivingPort();
 
   // Send the port that this process is listening on to the server.
-  SendMachPort(server_port, client_port, MACH_MSG_TYPE_MAKE_SEND);
+  SendMachPort(server_port.get(), client_port, MACH_MSG_TYPE_MAKE_SEND);
   return client_port;
 }
 
 // The number of active names in the current task's port name space.
 mach_msg_type_number_t GetActiveNameCount() {
   mach_port_name_array_t name_array;
   mach_msg_type_number_t names_count;
   mach_port_type_array_t type_array;
   mach_msg_type_number_t types_count;
   kern_return_t kr = mach_port_names(mach_task_self(), &name_array,
@@ skipping 14 matching lines @@
     command_line.AppendSwitchASCII(g_service_switch_name, service_name_);
     return command_line;
   }
 
   void SetUpChild(const std::string& name) {
     // Make a random service name so that this test doesn't conflict with other
     // similar tests.
     service_name_ = CreateRandomServiceName();
     server_port_.reset(BecomeMachServer(service_name_.c_str()));
     child_process_ = SpawnChild(name);
-    client_port_.reset(ReceiveMachPort(server_port_));
+    client_port_.reset(ReceiveMachPort(server_port_.get()));
   }
 
   static const int s_memory_size = 99999;
 
  protected:
   std::string service_name_;
 
   // A port on which the main process listens for mach messages from the child
   // process.
   mac::ScopedMachReceiveRight server_port_;
@@ skipping 11 matching lines @@
 TEST_F(SharedMemoryMacMultiProcessTest, MachBasedSharedMemory) {
   SetUpChild("MachBasedSharedMemoryClient");
 
   SharedMemoryHandle shm(s_memory_size);
   ASSERT_TRUE(shm.IsValid());
   SharedMemory shared_memory(shm, false);
   shared_memory.Map(s_memory_size);
   memset(shared_memory.memory(), 'a', s_memory_size);
 
   // Send the underlying memory object to the client process.
-  SendMachPort(client_port_, shm.GetMemoryObject(), MACH_MSG_TYPE_COPY_SEND);
+  SendMachPort(
+      client_port_.get(), shm.GetMemoryObject(), MACH_MSG_TYPE_COPY_SEND);
   int rv = -1;
   ASSERT_TRUE(child_process_.WaitForExitWithTimeout(
       TestTimeouts::action_timeout(), &rv));
   EXPECT_EQ(0, rv);
 }
 
 MULTIPROCESS_TEST_MAIN(MachBasedSharedMemoryClient) {
   mac::ScopedMachReceiveRight client_port(CommonChildProcessSetUp());
   // The next mach port should be for a memory object.
-  mach_port_t memory_object = ReceiveMachPort(client_port);
+  mach_port_t memory_object = ReceiveMachPort(client_port.get());
   SharedMemoryHandle shm(memory_object,
                          SharedMemoryMacMultiProcessTest::s_memory_size,
                          GetCurrentProcId());
   SharedMemory shared_memory(shm, false);
   shared_memory.Map(SharedMemoryMacMultiProcessTest::s_memory_size);
   const char* start = static_cast<const char*>(shared_memory.memory());
   for (int i = 0; i < SharedMemoryMacMultiProcessTest::s_memory_size; ++i) {
     DCHECK_EQ(start[i], 'a');
   }
   return 0;
 }
 
 // Tests that mapping shared memory with an offset works correctly.
 TEST_F(SharedMemoryMacMultiProcessTest, MachBasedSharedMemoryWithOffset) {
   SetUpChild("MachBasedSharedMemoryWithOffsetClient");
 
   SharedMemoryHandle shm(s_memory_size);
   ASSERT_TRUE(shm.IsValid());
   SharedMemory shared_memory(shm, false);
   shared_memory.Map(s_memory_size);
 
   size_t page_size = SysInfo::VMAllocationGranularity();
   char* start = static_cast<char*>(shared_memory.memory());
   memset(start, 'a', page_size);
   memset(start + page_size, 'b', page_size);
   memset(start + 2 * page_size, 'c', page_size);
 
   // Send the underlying memory object to the client process.
-  SendMachPort(client_port_, shm.GetMemoryObject(), MACH_MSG_TYPE_COPY_SEND);
+  SendMachPort(
+      client_port_.get(), shm.GetMemoryObject(), MACH_MSG_TYPE_COPY_SEND);
   int rv = -1;
   ASSERT_TRUE(child_process_.WaitForExitWithTimeout(
       TestTimeouts::action_timeout(), &rv));
   EXPECT_EQ(0, rv);
 }
 
 MULTIPROCESS_TEST_MAIN(MachBasedSharedMemoryWithOffsetClient) {
   mac::ScopedMachReceiveRight client_port(CommonChildProcessSetUp());
   // The next mach port should be for a memory object.
-  mach_port_t memory_object = ReceiveMachPort(client_port);
+  mach_port_t memory_object = ReceiveMachPort(client_port.get());
   SharedMemoryHandle shm(memory_object,
                          SharedMemoryMacMultiProcessTest::s_memory_size,
                          GetCurrentProcId());
   SharedMemory shared_memory(shm, false);
   size_t page_size = SysInfo::VMAllocationGranularity();
   shared_memory.MapAt(page_size, 2 * page_size);
   const char* start = static_cast<const char*>(shared_memory.memory());
   for (size_t i = 0; i < page_size; ++i) {
     DCHECK_EQ(start[i], 'b');
   }
@@ skipping 59 matching lines @@
   memset(shared_memory.memory(), 'a', s_memory_size);
 
   SharedMemoryHandle shm2 = shm.Duplicate();
   ASSERT_TRUE(shm2.IsValid());
   SharedMemory shared_memory2(shm, true);
   shared_memory2.Map(s_memory_size);
   ASSERT_DEATH(memset(shared_memory2.memory(), 'b', s_memory_size), "");
 }
 
 }  //  namespace base