Convert //base to use std::unique_ptr

base/security_unittest.cc

 // Copyright (c) 2013 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 <fcntl.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include <algorithm>
 #include <limits>
+#include <memory>
 
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/memory/free_deleter.h"
-#include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_POSIX)
 #include <sys/mman.h>
 #include <unistd.h>
 #endif
 
 using std::nothrow;
 using std::numeric_limits;
@@ skipping 73 matching lines @@
   // We want something "dynamic" here, so that the compiler doesn't
   // immediately reject crazy arrays.
   const size_t kDynamicArraySize = HideValueFromCompiler(kArraySize);
   // numeric_limits are still not constexpr until we switch to C++11, so we
   // use an ugly cast.
   const size_t kMaxSizeT = ~static_cast<size_t>(0);
   ASSERT_EQ(numeric_limits<size_t>::max(), kMaxSizeT);
   const size_t kArraySize2 = kMaxSizeT / kArraySize + 10;
   const size_t kDynamicArraySize2 = HideValueFromCompiler(kArraySize2);
   {
-    scoped_ptr<char[][kArraySize]> array_pointer(new (nothrow)
-        char[kDynamicArraySize2][kArraySize]);
+    std::unique_ptr<char[][kArraySize]> array_pointer(
+        new (nothrow) char[kDynamicArraySize2][kArraySize]);
     OverflowTestsSoftExpectTrue(!array_pointer);
   }
   // On windows, the compiler prevents static array sizes of more than
   // 0x7fffffff (error C2148).
 #if defined(OS_WIN) && defined(ARCH_CPU_64_BITS)
   ALLOW_UNUSED_LOCAL(kDynamicArraySize);
 #else
   {
-    scoped_ptr<char[][kArraySize2]> array_pointer(new (nothrow)
-        char[kDynamicArraySize][kArraySize2]);
+    std::unique_ptr<char[][kArraySize2]> array_pointer(
+        new (nothrow) char[kDynamicArraySize][kArraySize2]);
     OverflowTestsSoftExpectTrue(!array_pointer);
   }
 #endif  // !defined(OS_WIN) || !defined(ARCH_CPU_64_BITS)
 }
 
 #if defined(OS_LINUX) && defined(__x86_64__)
 // Check if ptr1 and ptr2 are separated by less than size chars.
 bool ArePointersToSameArea(void* ptr1, void* ptr2, size_t size) {
   ptrdiff_t ptr_diff = reinterpret_cast<char*>(std::max(ptr1, ptr2)) -
                        reinterpret_cast<char*>(std::min(ptr1, ptr2));
@@ skipping 15 matching lines @@
            MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
   ASSERT_NE(default_mmap_heap_address,
             static_cast<void*>(MAP_FAILED));
   ASSERT_EQ(munmap(default_mmap_heap_address, kPageSize), 0);
   void* brk_heap_address = sbrk(0);
   ASSERT_NE(brk_heap_address, reinterpret_cast<void*>(-1));
   ASSERT_TRUE(brk_heap_address != NULL);
   // 1 MB should get us past what TCMalloc pre-allocated before initializing
   // the sophisticated allocators.
   size_t kAllocSize = 1<<20;
-  scoped_ptr<char, base::FreeDeleter> ptr(
+  std::unique_ptr<char, base::FreeDeleter> ptr(
       static_cast<char*>(malloc(kAllocSize)));
   ASSERT_TRUE(ptr != NULL);
   // If two pointers are separated by less than 512MB, they are considered
   // to be in the same area.
   // Our random pointer could be anywhere within 0x3fffffffffff (46bits),
   // and we are checking that it's not withing 1GB (30 bits) from two
   // addresses (brk and mmap heap). We have roughly one chance out of
   // 2^15 to flake.
   const size_t kAreaRadius = 1<<29;
   bool in_default_mmap_heap = ArePointersToSameArea(
       ptr.get(), default_mmap_heap_address, kAreaRadius);
   EXPECT_FALSE(in_default_mmap_heap);
 
   bool in_default_brk_heap = ArePointersToSameArea(
       ptr.get(), brk_heap_address, kAreaRadius);
   EXPECT_FALSE(in_default_brk_heap);
 
   // In the implementation, we always mask our random addresses with
   // kRandomMask, so we use it as an additional detection mechanism.
   const uintptr_t kRandomMask = 0x3fffffffffffULL;
   bool impossible_random_address =
       reinterpret_cast<uintptr_t>(ptr.get()) & ~kRandomMask;
   EXPECT_FALSE(impossible_random_address);
 }
 
 #endif  // defined(OS_LINUX) && defined(__x86_64__)
 
 }  // namespace