Convert //base to use std::unique_ptr

base/metrics/persistent_memory_allocator_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 "base/metrics/persistent_memory_allocator.h"
 
+#include <memory>
+
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/files/scoped_temp_dir.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/strings/safe_sprintf.h"
 #include "base/threading/simple_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace {
 
 const uint32_t TEST_MEMORY_SIZE = 1 << 20;   // 1 MiB
@@ skipping 50 matching lines @@
     uint32_t type;
     unsigned count = 0;
     for (allocator_->CreateIterator(&iter);
          allocator_->GetNextIterable(&iter, &type) != 0;) {
       count++;
     }
     return count;
   }
 
  protected:
-  scoped_ptr<char[]> mem_segment_;
-  scoped_ptr<PersistentMemoryAllocator> allocator_;
+  std::unique_ptr<char[]> mem_segment_;
+  std::unique_ptr<PersistentMemoryAllocator> allocator_;
 };
 
 TEST_F(PersistentMemoryAllocatorTest, AllocateAndIterate) {
   std::string base_name(TEST_NAME);
   EXPECT_EQ(TEST_ID, allocator_->Id());
   EXPECT_TRUE(allocator_->used_histogram_);
   EXPECT_EQ("UMA.PersistentAllocator." + base_name + ".UsedPct",
             allocator_->used_histogram_->histogram_name());
   EXPECT_TRUE(allocator_->allocs_histogram_);
   EXPECT_EQ("UMA.PersistentAllocator." + base_name + ".Allocs",
@@ skipping 53 matching lines @@
   allocator_->CreateIterator(&iter, block1);
   EXPECT_EQ(block2, allocator_->GetNextIterable(&iter, &type));
   EXPECT_EQ(0U, allocator_->GetNextIterable(&iter, &type));
 
   // Ensure nothing has gone noticably wrong.
   EXPECT_FALSE(allocator_->IsFull());
   EXPECT_FALSE(allocator_->IsCorrupt());
 
   // Check the internal histogram record of used memory.
   allocator_->UpdateTrackingHistograms();
-  scoped_ptr<HistogramSamples> used_samples(
+  std::unique_ptr<HistogramSamples> used_samples(
       allocator_->used_histogram_->SnapshotSamples());
   EXPECT_TRUE(used_samples);
   EXPECT_EQ(1, used_samples->TotalCount());
 
   // Check the internal histogram record of allocation requests.
-  scoped_ptr<HistogramSamples> allocs_samples(
+  std::unique_ptr<HistogramSamples> allocs_samples(
       allocator_->allocs_histogram_->SnapshotSamples());
   EXPECT_TRUE(allocs_samples);
   EXPECT_EQ(2, allocs_samples->TotalCount());
   EXPECT_EQ(0, allocs_samples->GetCount(0));
   EXPECT_EQ(1, allocs_samples->GetCount(sizeof(TestObject1)));
   EXPECT_EQ(1, allocs_samples->GetCount(sizeof(TestObject2)));
 #if !DCHECK_IS_ON()  // DCHECK builds will die at a NOTREACHED().
   EXPECT_EQ(0U, allocator_->Allocate(TEST_MEMORY_SIZE + 1, 0));
   allocs_samples = allocator_->allocs_histogram_->SnapshotSamples();
   EXPECT_EQ(3, allocs_samples->TotalCount());
   EXPECT_EQ(1, allocs_samples->GetCount(0));
 #endif
 
   // Check that an objcet's type can be changed.
   EXPECT_EQ(2U, allocator_->GetType(block2));
   allocator_->SetType(block2, 3);
   EXPECT_EQ(3U, allocator_->GetType(block2));
   allocator_->SetType(block2, 2);
   EXPECT_EQ(2U, allocator_->GetType(block2));
 
   // Create second allocator (read/write) using the same memory segment.
-  scoped_ptr<PersistentMemoryAllocator> allocator2(
-      new PersistentMemoryAllocator(
-          mem_segment_.get(), TEST_MEMORY_SIZE, TEST_MEMORY_PAGE, 0, "",
-          false));
+  std::unique_ptr<PersistentMemoryAllocator> allocator2(
+      new PersistentMemoryAllocator(mem_segment_.get(), TEST_MEMORY_SIZE,
+                                    TEST_MEMORY_PAGE, 0, "", false));
   EXPECT_EQ(TEST_ID, allocator2->Id());
   EXPECT_FALSE(allocator2->used_histogram_);
   EXPECT_FALSE(allocator2->allocs_histogram_);
   EXPECT_NE(allocator2->allocs_histogram_, allocator_->allocs_histogram_);
 
   // Ensure that iteration and access through second allocator works.
   allocator2->CreateIterator(&iter);
   EXPECT_EQ(block1, allocator2->GetNextIterable(&iter, &type));
   EXPECT_EQ(block2, allocator2->GetNextIterable(&iter, &type));
   EXPECT_EQ(0U, allocator2->GetNextIterable(&iter, &type));
   EXPECT_NE(nullptr, allocator2->GetAsObject<TestObject1>(block1, 1));
   EXPECT_NE(nullptr, allocator2->GetAsObject<TestObject2>(block2, 2));
 
   // Create a third allocator (read-only) using the same memory segment.
-  scoped_ptr<const PersistentMemoryAllocator> allocator3(
-      new PersistentMemoryAllocator(
-          mem_segment_.get(), TEST_MEMORY_SIZE, TEST_MEMORY_PAGE, 0, "", true));
+  std::unique_ptr<const PersistentMemoryAllocator> allocator3(
+      new PersistentMemoryAllocator(mem_segment_.get(), TEST_MEMORY_SIZE,
+                                    TEST_MEMORY_PAGE, 0, "", true));
   EXPECT_EQ(TEST_ID, allocator3->Id());
   EXPECT_FALSE(allocator3->used_histogram_);
   EXPECT_FALSE(allocator3->allocs_histogram_);
 
   // Ensure that iteration and access through third allocator works.
   allocator3->CreateIterator(&iter);
   EXPECT_EQ(block1, allocator3->GetNextIterable(&iter, &type));
   EXPECT_EQ(block2, allocator3->GetNextIterable(&iter, &type));
   EXPECT_EQ(0U, allocator3->GetNextIterable(&iter, &type));
   EXPECT_NE(nullptr, allocator3->GetAsObject<TestObject1>(block1, 1));
@@ skipping 173 matching lines @@
 
 
 //----- SharedPersistentMemoryAllocator ----------------------------------------
 
 TEST(SharedPersistentMemoryAllocatorTest, CreationTest) {
   SharedMemoryHandle shared_handle;
 
   PersistentMemoryAllocator::MemoryInfo meminfo1;
   Reference r123, r456, r789;
   {
-    scoped_ptr<SharedMemory> shmem1(new SharedMemory());
+    std::unique_ptr<SharedMemory> shmem1(new SharedMemory());
     ASSERT_TRUE(shmem1->CreateAndMapAnonymous(TEST_MEMORY_SIZE));
     SharedPersistentMemoryAllocator local(std::move(shmem1), TEST_ID, "",
                                           false);
     EXPECT_FALSE(local.IsReadonly());
     r123 = local.Allocate(123, 123);
     r456 = local.Allocate(456, 456);
     r789 = local.Allocate(789, 789);
     local.MakeIterable(r123);
     local.SetType(r456, 654);
     local.MakeIterable(r789);
     local.GetMemoryInfo(&meminfo1);
     EXPECT_FALSE(local.IsFull());
     EXPECT_FALSE(local.IsCorrupt());
 
     ASSERT_TRUE(local.shared_memory()->ShareToProcess(
                     GetCurrentProcessHandle(),
                     &shared_handle));
   }
 
   // Read-only test.
-  scoped_ptr<SharedMemory> shmem2(new SharedMemory(shared_handle,
-                                                   /*readonly=*/true));
+  std::unique_ptr<SharedMemory> shmem2(new SharedMemory(shared_handle,
+                                                        /*readonly=*/true));
   ASSERT_TRUE(shmem2->Map(TEST_MEMORY_SIZE));
 
   SharedPersistentMemoryAllocator shalloc2(std::move(shmem2), 0, "", true);
   EXPECT_TRUE(shalloc2.IsReadonly());
   EXPECT_EQ(TEST_ID, shalloc2.Id());
   EXPECT_FALSE(shalloc2.IsFull());
   EXPECT_FALSE(shalloc2.IsCorrupt());
 
   PersistentMemoryAllocator::Iterator iter2;
   uint32_t type;
   shalloc2.CreateIterator(&iter2);
   EXPECT_EQ(r123, shalloc2.GetNextIterable(&iter2, &type));
   EXPECT_EQ(r789, shalloc2.GetNextIterable(&iter2, &type));
   EXPECT_EQ(0U, shalloc2.GetNextIterable(&iter2, &type));
 
   EXPECT_EQ(123U, shalloc2.GetType(r123));
   EXPECT_EQ(654U, shalloc2.GetType(r456));
   EXPECT_EQ(789U, shalloc2.GetType(r789));
 
   PersistentMemoryAllocator::MemoryInfo meminfo2;
   shalloc2.GetMemoryInfo(&meminfo2);
   EXPECT_EQ(meminfo1.total, meminfo2.total);
   EXPECT_EQ(meminfo1.free, meminfo2.free);
 
   // Read/write test.
-  scoped_ptr<SharedMemory> shmem3(new SharedMemory(shared_handle,
-                                                   /*readonly=*/false));
+  std::unique_ptr<SharedMemory> shmem3(new SharedMemory(shared_handle,
+                                                        /*readonly=*/false));
   ASSERT_TRUE(shmem3->Map(TEST_MEMORY_SIZE));
 
   SharedPersistentMemoryAllocator shalloc3(std::move(shmem3), 0, "", false);
   EXPECT_FALSE(shalloc3.IsReadonly());
   EXPECT_EQ(TEST_ID, shalloc3.Id());
   EXPECT_FALSE(shalloc3.IsFull());
   EXPECT_FALSE(shalloc3.IsCorrupt());
 
   PersistentMemoryAllocator::Iterator iter3;
   shalloc3.CreateIterator(&iter3);
@@ skipping 39 matching lines @@
     local.MakeIterable(r789);
     local.GetMemoryInfo(&meminfo1);
     EXPECT_FALSE(local.IsFull());
     EXPECT_FALSE(local.IsCorrupt());
 
     File writer(file_path, File::FLAG_CREATE | File::FLAG_WRITE);
     ASSERT_TRUE(writer.IsValid());
     writer.Write(0, (const char*)local.data(), local.used());
   }
 
-  scoped_ptr<MemoryMappedFile> mmfile(new MemoryMappedFile());
+  std::unique_ptr<MemoryMappedFile> mmfile(new MemoryMappedFile());
   mmfile->Initialize(file_path);
   EXPECT_TRUE(mmfile->IsValid());
   const size_t mmlength = mmfile->length();
   EXPECT_GE(meminfo1.total, mmlength);
 
   FilePersistentMemoryAllocator file(std::move(mmfile), 0, "");
   EXPECT_TRUE(file.IsReadonly());
   EXPECT_EQ(TEST_ID, file.Id());
   EXPECT_FALSE(file.IsFull());
   EXPECT_FALSE(file.IsCorrupt());
@@ skipping 19 matching lines @@
 
 TEST(FilePersistentMemoryAllocatorTest, AcceptableTest) {
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   FilePath file_path_base = temp_dir.path().AppendASCII("persistent_memory_");
 
   LocalPersistentMemoryAllocator local(TEST_MEMORY_SIZE, TEST_ID, "");
   local.Allocate(1, 1);
   local.Allocate(11, 11);
   const size_t minsize = local.used();
-  scoped_ptr<char[]> garbage(new char[minsize]);
+  std::unique_ptr<char[]> garbage(new char[minsize]);
   RandBytes(garbage.get(), minsize);
 
-  scoped_ptr<MemoryMappedFile> mmfile;
+  std::unique_ptr<MemoryMappedFile> mmfile;
   char filename[100];
   for (size_t filesize = minsize; filesize > 0; --filesize) {
     strings::SafeSPrintf(filename, "memory_%d_A", filesize);
     FilePath file_path = temp_dir.path().AppendASCII(filename);
     ASSERT_FALSE(PathExists(file_path));
     {
       File writer(file_path, File::FLAG_CREATE | File::FLAG_WRITE);
       ASSERT_TRUE(writer.IsValid());
       writer.Write(0, (const char*)local.data(), filesize);
     }
@@ skipping 49 matching lines @@
     } else {
       // For filesize >= minsize, the file must be acceptable. This
       // else clause (file-not-acceptable) should be reached only if
       // filesize < minsize.
       EXPECT_GT(minsize, filesize);
     }
   }
 }
 
 }  // namespace base