mac: Make Mach port scopers better ScopedGenerics

ipc/attachment_broker_privileged_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 "ipc/attachment_broker_privileged_mac.h"
 
 #include <mach/mach.h>
 #include <mach/mach_vm.h>
 
 #include <map>
@@ skipping 71 matching lines @@
       cmd_line.GetSwitchValueASCII(g_service_switch_name);
   base::mac::ScopedMachSendRight server_port(
       LookupServer(service_name.c_str()));
   base::mac::ScopedMachReceiveRight client_port(MakeReceivingPort());
 
   // |server_port| is a newly allocated right which will be deallocated once
   // this method returns.
   *original_name_count = GetActiveNameCount() - 1;
 
   // 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.get(), MACH_MSG_TYPE_MAKE_SEND);
 
   // Send the task port for this process.
-  SendMachPort(server_port, mach_task_self(), MACH_MSG_TYPE_COPY_SEND);
+  SendMachPort(server_port.get(), mach_task_self(), MACH_MSG_TYPE_COPY_SEND);
   return client_port;
 }
 
 // Creates a new shared memory region populated with 'a'.
 scoped_ptr<base::SharedMemory> CreateAndPopulateSharedMemoryHandle(
     size_t size) {
   base::SharedMemoryHandle shm(size);
   scoped_ptr<base::SharedMemory> shared_memory(
       new base::SharedMemory(shm, false));
   shared_memory->Map(size);
@@ skipping 25 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()).release());
     child_process_ = SpawnChild(name);
-    client_port_.reset(ReceiveMachPort(server_port_).release());
-    client_task_port_.reset(ReceiveMachPort(server_port_).release());
+    client_port_.reset(ReceiveMachPort(server_port_.get()).release());
+    client_task_port_.reset(ReceiveMachPort(server_port_.get()).release());
   }
 
   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.
   base::mac::ScopedMachReceiveRight server_port_;
@@ skipping 19 matching lines @@
   // Create some shared memory.
   scoped_ptr<base::SharedMemory> shared_memory =
       CreateAndPopulateSharedMemoryHandle(s_memory_size);
   ASSERT_TRUE(shared_memory->handle().IsValid());
 
   // Insert the memory object into the destination task, via an intermediate
   // port.
   IncrementMachRefCount(shared_memory->handle().GetMemoryObject(),
                         MACH_PORT_RIGHT_SEND);
   mach_port_name_t inserted_memory_object = broker.CreateIntermediateMachPort(
-      client_task_port_, base::mac::ScopedMachSendRight(
-                             shared_memory->handle().GetMemoryObject()));
+      client_task_port_.get(), base::mac::ScopedMachSendRight(
+                                   shared_memory->handle().GetMemoryObject()));
   EXPECT_NE(inserted_memory_object,
             static_cast<mach_port_name_t>(MACH_PORT_NULL));
-  SendUInt32(client_port_, inserted_memory_object);
+  SendUInt32(client_port_.get(), inserted_memory_object);
 
   // Check that no names have been leaked.
   shared_memory.reset();
   EXPECT_EQ(original_name_count, GetActiveNameCount());
 
   int rv = -1;
   ASSERT_TRUE(child_process_.WaitForExitWithTimeout(
       TestTimeouts::action_timeout(), &rv));
   EXPECT_EQ(0, rv);
 }
 
 MULTIPROCESS_TEST_MAIN(InsertRightClient) {
   mach_msg_type_number_t original_name_count = 0;
   base::mac::ScopedMachReceiveRight client_port(
       CommonChildProcessSetUp(&original_name_count).release());
-  base::mac::ScopedMachReceiveRight inserted_port(ReceiveUInt32(client_port));
-  base::mac::ScopedMachSendRight memory_object(ReceiveMachPort(inserted_port));
+  base::mac::ScopedMachReceiveRight inserted_port(
+      ReceiveUInt32(client_port.get()));
+  base::mac::ScopedMachSendRight memory_object(
+      ReceiveMachPort(inserted_port.get()));
   inserted_port.reset();
 
   // The server should have inserted a right into this process.
   EXPECT_EQ(original_name_count + 1, GetActiveNameCount());
 
   // Map the memory object and check its contents.
   scoped_ptr<base::SharedMemory> shared_memory(MapMemoryObject(
       memory_object.release(),
       AttachmentBrokerPrivilegedMacMultiProcessTest::s_memory_size));
   const char* start = static_cast<const char*>(shared_memory->memory());
@@ skipping 20 matching lines @@
   scoped_ptr<base::SharedMemory> shared_memory =
       CreateAndPopulateSharedMemoryHandle(s_memory_size);
   ASSERT_TRUE(shared_memory->handle().IsValid());
 
   // Insert the memory object into the destination task, via an intermediate
   // port, twice.
   for (int i = 0; i < 2; ++i) {
     IncrementMachRefCount(shared_memory->handle().GetMemoryObject(),
                           MACH_PORT_RIGHT_SEND);
     mach_port_name_t inserted_memory_object = broker.CreateIntermediateMachPort(
-        client_task_port_, base::mac::ScopedMachSendRight(
-                               shared_memory->handle().GetMemoryObject()));
+        client_task_port_.get(),
+        base::mac::ScopedMachSendRight(
+            shared_memory->handle().GetMemoryObject()));
     EXPECT_NE(inserted_memory_object,
               static_cast<mach_port_name_t>(MACH_PORT_NULL));
-    SendUInt32(client_port_, inserted_memory_object);
+    SendUInt32(client_port_.get(), inserted_memory_object);
   }
 
   // Check that no names have been leaked.
   shared_memory.reset();
   EXPECT_EQ(original_name_count, GetActiveNameCount());
 
   int rv = -1;
   ASSERT_TRUE(child_process_.WaitForExitWithTimeout(
       TestTimeouts::action_timeout(), &rv));
   EXPECT_EQ(0, rv);
 }
 
 MULTIPROCESS_TEST_MAIN(InsertSameRightTwiceClient) {
   mach_msg_type_number_t original_name_count = 0;
   base::mac::ScopedMachReceiveRight client_port(
       CommonChildProcessSetUp(&original_name_count).release());
 
   // Receive two memory objects.
-  base::mac::ScopedMachReceiveRight inserted_port(ReceiveUInt32(client_port));
-  base::mac::ScopedMachReceiveRight inserted_port2(ReceiveUInt32(client_port));
-  base::mac::ScopedMachSendRight memory_object(ReceiveMachPort(inserted_port));
+  base::mac::ScopedMachReceiveRight inserted_port(
+      ReceiveUInt32(client_port.get()));
+  base::mac::ScopedMachReceiveRight inserted_port2(
+      ReceiveUInt32(client_port.get()));
+  base::mac::ScopedMachSendRight memory_object(
+      ReceiveMachPort(inserted_port.get()));
   base::mac::ScopedMachSendRight memory_object2(
-      ReceiveMachPort(inserted_port2));
+      ReceiveMachPort(inserted_port2.get()));
   inserted_port.reset();
   inserted_port2.reset();
 
   // Both rights are for the same Mach port, so only one new name should appear.
   EXPECT_EQ(original_name_count + 1, GetActiveNameCount());
 
   // Map both memory objects and check their contents.
   scoped_ptr<base::SharedMemory> shared_memory(MapMemoryObject(
       memory_object.release(),
       AttachmentBrokerPrivilegedMacMultiProcessTest::s_memory_size));
@@ skipping 40 matching lines @@
     // Create some shared memory.
     scoped_ptr<base::SharedMemory> shared_memory =
         CreateAndPopulateSharedMemoryHandle(s_memory_size);
     ASSERT_TRUE(shared_memory->handle().IsValid());
 
     // Insert the memory object into the destination task, via an intermediate
     // port.
     IncrementMachRefCount(shared_memory->handle().GetMemoryObject(),
                           MACH_PORT_RIGHT_SEND);
     mach_port_name_t inserted_memory_object = broker.CreateIntermediateMachPort(
-        client_task_port_, base::mac::ScopedMachSendRight(
-                               shared_memory->handle().GetMemoryObject()));
+        client_task_port_.get(),
+        base::mac::ScopedMachSendRight(
+            shared_memory->handle().GetMemoryObject()));
     EXPECT_NE(inserted_memory_object,
               static_cast<mach_port_name_t>(MACH_PORT_NULL));
-    SendUInt32(client_port_, inserted_memory_object);
+    SendUInt32(client_port_.get(), inserted_memory_object);
   }
 
   // Check that no names have been leaked.
   EXPECT_EQ(original_name_count, GetActiveNameCount());
 
   int rv = -1;
   ASSERT_TRUE(child_process_.WaitForExitWithTimeout(
       TestTimeouts::action_timeout(), &rv));
   EXPECT_EQ(0, rv);
 }
 
 MULTIPROCESS_TEST_MAIN(InsertTwoRightsClient) {
   mach_msg_type_number_t original_name_count = 0;
   base::mac::ScopedMachReceiveRight client_port(
       CommonChildProcessSetUp(&original_name_count).release());
 
   // Receive two memory objects.
-  base::mac::ScopedMachReceiveRight inserted_port(ReceiveUInt32(client_port));
-  base::mac::ScopedMachReceiveRight inserted_port2(ReceiveUInt32(client_port));
-  base::mac::ScopedMachSendRight memory_object(ReceiveMachPort(inserted_port));
+  base::mac::ScopedMachReceiveRight inserted_port(
+      ReceiveUInt32(client_port.get()));
+  base::mac::ScopedMachReceiveRight inserted_port2(
+      ReceiveUInt32(client_port.get()));
+  base::mac::ScopedMachSendRight memory_object(
+      ReceiveMachPort(inserted_port.get()));
   base::mac::ScopedMachSendRight memory_object2(
-      ReceiveMachPort(inserted_port2));
+      ReceiveMachPort(inserted_port2.get()));
   inserted_port.reset();
   inserted_port2.reset();
 
   // There should be two new names to reflect the two new shared memory regions.
   EXPECT_EQ(original_name_count + 2, GetActiveNameCount());
 
   // Map both memory objects and check their contents.
   scoped_ptr<base::SharedMemory> shared_memory(MapMemoryObject(
       memory_object.release(),
       AttachmentBrokerPrivilegedMacMultiProcessTest::s_memory_size));
@@ skipping 19 matching lines @@
   // After releasing one shared memory region, the name count should decrement.
   shared_memory.reset();
   EXPECT_EQ(original_name_count + 1, GetActiveNameCount());
   shared_memory2.reset();
   EXPECT_EQ(original_name_count, GetActiveNameCount());
 
   return 0;
 }
 
 }  //  namespace IPC