Convert //base to use std::unique_ptr

base/memory/shared_memory_unittest.cc

 // Copyright (c) 2012 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/memory/shared_memory.h"
+
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/atomicops.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/shared_memory.h"
 #include "base/memory/shared_memory_handle.h"
 #include "base/process/kill.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/test/multiprocess_test.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 217 matching lines @@
   // On POSIX we have a problem when 2 threads try to create the shmem
   // (a file) at exactly the same time, since create both creates the
   // file and zerofills it.  We solve the problem for this unit test
   // (make it not flaky) by starting with 1 thread, then
   // intentionally don't clean up its shmem before running with
   // kNumThreads.
 
   int threadcounts[] = { 1, kNumThreads };
   for (size_t i = 0; i < arraysize(threadcounts); i++) {
     int numthreads = threadcounts[i];
-    scoped_ptr<PlatformThreadHandle[]> thread_handles;
-    scoped_ptr<MultipleThreadMain*[]> thread_delegates;
+    std::unique_ptr<PlatformThreadHandle[]> thread_handles;
+    std::unique_ptr<MultipleThreadMain* []> thread_delegates;
 
     thread_handles.reset(new PlatformThreadHandle[numthreads]);
     thread_delegates.reset(new MultipleThreadMain*[numthreads]);
 
     // Spawn the threads.
     for (int16_t index = 0; index < numthreads; index++) {
       PlatformThreadHandle pth;
       thread_delegates[index] = new MultipleThreadMain(index);
       EXPECT_TRUE(PlatformThread::Create(0, thread_delegates[index], &pth));
       thread_handles[index] = pth;
@@ skipping 11 matching lines @@
 
 // Allocate private (unique) shared memory with an empty string for a
 // name.  Make sure several of them don't point to the same thing as
 // we might expect if the names are equal.
 TEST(SharedMemoryTest, AnonymousPrivate) {
   int i, j;
   int count = 4;
   bool rv;
   const uint32_t kDataSize = 8192;
 
-  scoped_ptr<SharedMemory[]> memories(new SharedMemory[count]);
-  scoped_ptr<int*[]> pointers(new int*[count]);
+  std::unique_ptr<SharedMemory[]> memories(new SharedMemory[count]);
+  std::unique_ptr<int* []> pointers(new int*[count]);
   ASSERT_TRUE(memories.get());
   ASSERT_TRUE(pointers.get());
 
   for (i = 0; i < count; i++) {
     rv = memories[i].CreateAndMapAnonymous(kDataSize);
     EXPECT_TRUE(rv);
     int* ptr = static_cast<int*>(memories[i].memory());
     EXPECT_TRUE(ptr);
     pointers[i] = ptr;
   }
@@ skipping 410 matching lines @@
   memory.Close();
   SharedMemoryProcessTest::CleanUp();
 }
 
 MULTIPROCESS_TEST_MAIN(SharedMemoryTestMain) {
   return SharedMemoryProcessTest::TaskTestMain();
 }
 #endif  // !defined(OS_IOS) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
 
 }  // namespace base