Convert //base to use std::unique_ptr

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 <stddef.h>
 #include <stdint.h>
 
@@ skipping 36 matching lines @@
     MACH_LOG(ERROR, kr) << "Failed to get region info.";
     return false;
   }
 
   *current = basic_info.protection;
   *max = basic_info.max_protection;
   return true;
 }
 
 // Creates a new SharedMemory with the given |size|, filled with 'a'.
-scoped_ptr<SharedMemory> CreateSharedMemory(int size) {
+std::unique_ptr<SharedMemory> CreateSharedMemory(int size) {
   SharedMemoryHandle shm(size);
   if (!shm.IsValid()) {
     LOG(ERROR) << "Failed to make SharedMemoryHandle";
     return nullptr;
   }
-  scoped_ptr<SharedMemory> shared_memory(new SharedMemory(shm, false));
+  std::unique_ptr<SharedMemory> shared_memory(new SharedMemory(shm, false));
   shared_memory->Map(size);
   memset(shared_memory->memory(), 'a', size);
   return shared_memory;
 }
 
 static const std::string g_service_switch_name = "service_name";
 
 // Structs used to pass a mach port from client to server.
 struct MachSendPortMessage {
   mach_msg_header_t header;
@@ skipping 149 matching lines @@
 
   base::Process child_process_;
   DISALLOW_COPY_AND_ASSIGN(SharedMemoryMacMultiProcessTest);
 };
 
 // Tests that content written to shared memory in the server process can be read
 // by the child process.
 TEST_F(SharedMemoryMacMultiProcessTest, MachBasedSharedMemory) {
   SetUpChild("MachBasedSharedMemoryClient");
 
-  scoped_ptr<SharedMemory> shared_memory(CreateSharedMemory(s_memory_size));
+  std::unique_ptr<SharedMemory> shared_memory(
+      CreateSharedMemory(s_memory_size));
 
   // Send the underlying memory object to the client process.
   SendMachPort(client_port_.get(), shared_memory->handle().GetMemoryObject(),
                MACH_MSG_TYPE_COPY_SEND);
   int rv = -1;
   ASSERT_TRUE(child_process_.WaitForExitWithTimeout(
       TestTimeouts::action_timeout(), &rv));
   EXPECT_EQ(0, rv);
 }
 
@@ skipping 80 matching lines @@
   // Closing the SharedMemoryHandle decrements the ref count. The second time
   // destroys the port.
   shm.Close();
   EXPECT_EQ(active_name_count, GetActiveNameCount());
 }
 
 // Tests that Mach shared memory can be mapped and unmapped.
 TEST_F(SharedMemoryMacMultiProcessTest, MachUnmapMap) {
   mach_msg_type_number_t active_name_count = GetActiveNameCount();
 
-  scoped_ptr<SharedMemory> shared_memory = CreateSharedMemory(s_memory_size);
+  std::unique_ptr<SharedMemory> shared_memory =
+      CreateSharedMemory(s_memory_size);
   ASSERT_TRUE(shared_memory->Unmap());
   ASSERT_TRUE(shared_memory->Map(s_memory_size));
   shared_memory.reset();
   EXPECT_EQ(active_name_count, GetActiveNameCount());
 }
 
 // Tests that passing a SharedMemoryHandle to a SharedMemory object also passes
 // ownership, and that destroying the SharedMemory closes the SharedMemoryHandle
 // as well.
 TEST_F(SharedMemoryMacMultiProcessTest, MachSharedMemoryTakesOwnership) {
   mach_msg_type_number_t active_name_count = GetActiveNameCount();
 
   // Making a new SharedMemoryHandle increments the name count.
   SharedMemoryHandle shm(s_memory_size);
   ASSERT_TRUE(shm.IsValid());
   EXPECT_EQ(active_name_count + 1, GetActiveNameCount());
 
   // Name count doesn't change when mapping the memory.
-  scoped_ptr<SharedMemory> shared_memory(new SharedMemory(shm, false));
+  std::unique_ptr<SharedMemory> shared_memory(new SharedMemory(shm, false));
   shared_memory->Map(s_memory_size);
   EXPECT_EQ(active_name_count + 1, GetActiveNameCount());
 
   // Destroying the SharedMemory object frees the resource.
   shared_memory.reset();
   EXPECT_EQ(active_name_count, GetActiveNameCount());
 }
 
 // Tests that the read-only flag works.
 TEST_F(SharedMemoryMacMultiProcessTest, MachReadOnly) {
-  scoped_ptr<SharedMemory> shared_memory(CreateSharedMemory(s_memory_size));
+  std::unique_ptr<SharedMemory> shared_memory(
+      CreateSharedMemory(s_memory_size));
 
   SharedMemoryHandle shm2 = shared_memory->handle().Duplicate();
   ASSERT_TRUE(shm2.IsValid());
   SharedMemory shared_memory2(shm2, true);
   shared_memory2.Map(s_memory_size);
   ASSERT_DEATH(memset(shared_memory2.memory(), 'b', s_memory_size), "");
 }
 
 // Tests that the method ShareToProcess() works.
 TEST_F(SharedMemoryMacMultiProcessTest, MachShareToProcess) {
   mach_msg_type_number_t active_name_count = GetActiveNameCount();
 
   {
-    scoped_ptr<SharedMemory> shared_memory(CreateSharedMemory(s_memory_size));
+    std::unique_ptr<SharedMemory> shared_memory(
+        CreateSharedMemory(s_memory_size));
 
     SharedMemoryHandle shm2;
     ASSERT_TRUE(shared_memory->ShareToProcess(GetCurrentProcId(), &shm2));
     ASSERT_TRUE(shm2.IsValid());
     SharedMemory shared_memory2(shm2, true);
     shared_memory2.Map(s_memory_size);
 
     ASSERT_EQ(0, memcmp(shared_memory->memory(), shared_memory2.memory(),
                         s_memory_size));
   }
 
   EXPECT_EQ(active_name_count, GetActiveNameCount());
 }
 
 // Tests that the method ShareReadOnlyToProcess() creates a memory object that
 // is read only.
 TEST_F(SharedMemoryMacMultiProcessTest, MachShareToProcessReadonly) {
-  scoped_ptr<SharedMemory> shared_memory(CreateSharedMemory(s_memory_size));
+  std::unique_ptr<SharedMemory> shared_memory(
+      CreateSharedMemory(s_memory_size));
 
   // Check the protection levels.
   int current_prot, max_prot;
   ASSERT_TRUE(GetProtections(shared_memory->memory(),
                              shared_memory->mapped_size(), &current_prot,
                              &max_prot));
   ASSERT_EQ(VM_PROT_READ | VM_PROT_WRITE, current_prot);
   ASSERT_EQ(VM_PROT_READ | VM_PROT_WRITE, max_prot);
 
   // Make a new memory object.
@@ skipping 21 matching lines @@
   // The memory should still be readonly, since the underlying memory object
   // is readonly.
   ASSERT_DEATH(memset(shared_memory2.memory(), 'b', s_memory_size), "");
 }
 
 // Tests that the method ShareReadOnlyToProcess() doesn't leak.
 TEST_F(SharedMemoryMacMultiProcessTest, MachShareToProcessReadonlyLeak) {
   mach_msg_type_number_t active_name_count = GetActiveNameCount();
 
   {
-    scoped_ptr<SharedMemory> shared_memory(CreateSharedMemory(s_memory_size));
+    std::unique_ptr<SharedMemory> shared_memory(
+        CreateSharedMemory(s_memory_size));
 
     SharedMemoryHandle shm2;
     ASSERT_TRUE(
         shared_memory->ShareReadOnlyToProcess(GetCurrentProcId(), &shm2));
     ASSERT_TRUE(shm2.IsValid());
 
     // Intentionally map with |readonly| set to |false|.
     SharedMemory shared_memory2(shm2, false);
     shared_memory2.Map(s_memory_size);
   }
 
   EXPECT_EQ(active_name_count, GetActiveNameCount());
 }
 
 }  //  namespace base