Revert "Remove OwnPtr from Blink."

third_party/WebKit/Source/wtf/allocator/PartitionAllocTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "wtf/allocator/PartitionAlloc.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/BitwiseOperations.h"
 #include "wtf/CPU.h"
-#include "wtf/PtrUtil.h"
+#include "wtf/OwnPtr.h"
+#include "wtf/PassOwnPtr.h"
 #include "wtf/Vector.h"
-#include <memory>
 #include <stdlib.h>
 #include <string.h>
 
 #if OS(POSIX)
 #include <sys/mman.h>
 #include <sys/resource.h>
 #include <sys/time.h>
 
 #ifndef MAP_ANONYMOUS
 #define MAP_ANONYMOUS MAP_ANON
@@ skipping 391 matching lines @@
 // free page list metadata bucket.
 TEST(PartitionAllocTest, FreePageListPageTransitions)
 {
     TestSetup();
     PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
 
     size_t numToFillFreeListPage = kPartitionPageSize / (sizeof(PartitionPage) + kExtraAllocSize);
     // The +1 is because we need to account for the fact that the current page
     // never gets thrown on the freelist.
     ++numToFillFreeListPage;
-    std::unique_ptr<PartitionPage*[]> pages = wrapArrayUnique(new PartitionPage*[numToFillFreeListPage]);
+    OwnPtr<PartitionPage*[]> pages = adoptArrayPtr(new PartitionPage*[numToFillFreeListPage]);
 
     size_t i;
     for (i = 0; i < numToFillFreeListPage; ++i) {
         pages[i] = GetFullPage(kTestAllocSize);
     }
     EXPECT_EQ(pages[numToFillFreeListPage - 1], bucket->activePagesHead);
     for (i = 0; i < numToFillFreeListPage; ++i)
         FreeFullPage(pages[i]);
     EXPECT_EQ(&PartitionRootGeneric::gSeedPage, bucket->activePagesHead);
     EXPECT_TRUE(bucket->emptyPagesHead);
@@ skipping 25 matching lines @@
 {
     TestSetup();
     // This is guaranteed to cross a super page boundary because the first
     // partition page "slot" will be taken up by a guard page.
     size_t numPagesNeeded = kNumPartitionPagesPerSuperPage;
     // The super page should begin and end in a guard so we one less page in
     // order to allocate a single page in the new super page.
     --numPagesNeeded;
 
     EXPECT_GT(numPagesNeeded, 1u);
-    std::unique_ptr<PartitionPage*[]> pages;
-    pages = wrapArrayUnique(new PartitionPage*[numPagesNeeded]);
+    OwnPtr<PartitionPage*[]> pages;
+    pages = adoptArrayPtr(new PartitionPage*[numPagesNeeded]);
     uintptr_t firstSuperPageBase = 0;
     size_t i;
     for (i = 0; i < numPagesNeeded; ++i) {
         pages[i] = GetFullPage(kTestAllocSize);
         void* storagePtr = partitionPageToPointer(pages[i]);
         if (!i)
             firstSuperPageBase = reinterpret_cast<uintptr_t>(storagePtr) & kSuperPageBaseMask;
         if (i == numPagesNeeded - 1) {
             uintptr_t secondSuperPageBase = reinterpret_cast<uintptr_t>(storagePtr) & kSuperPageBaseMask;
             uintptr_t secondSuperPageOffset = reinterpret_cast<uintptr_t>(storagePtr) & kSuperPageOffsetMask;
@@ skipping 511 matching lines @@
     TestShutdown();
 }
 
 // Test correct handling if our mapping collides with another.
 TEST(PartitionAllocTest, MappingCollision)
 {
     TestSetup();
     // The -2 is because the first and last partition pages in a super page are
     // guard pages.
     size_t numPartitionPagesNeeded = kNumPartitionPagesPerSuperPage - 2;
-    std::unique_ptr<PartitionPage*[]> firstSuperPagePages = wrapArrayUnique(new PartitionPage*[numPartitionPagesNeeded]);
-    std::unique_ptr<PartitionPage*[]> secondSuperPagePages = wrapArrayUnique(new PartitionPage*[numPartitionPagesNeeded]);
+    OwnPtr<PartitionPage*[]> firstSuperPagePages = adoptArrayPtr(new PartitionPage*[numPartitionPagesNeeded]);
+    OwnPtr<PartitionPage*[]> secondSuperPagePages = adoptArrayPtr(new PartitionPage*[numPartitionPagesNeeded]);
 
     size_t i;
     for (i = 0; i < numPartitionPagesNeeded; ++i)
         firstSuperPagePages[i] = GetFullPage(kTestAllocSize);
 
     char* pageBase = reinterpret_cast<char*>(partitionPageToPointer(firstSuperPagePages[0]));
     EXPECT_EQ(kPartitionPageSize, reinterpret_cast<uintptr_t>(pageBase) & kSuperPageOffsetMask);
     pageBase -= kPartitionPageSize;
     // Map a single system page either side of the mapping for our allocations,
     // with the goal of tripping up alignment of the next mapping.
@@ skipping 917 matching lines @@
     EXPECT_EQ(32u, countLeadingZerosSizet(0u));
     EXPECT_EQ(31u, countLeadingZerosSizet(1u));
     EXPECT_EQ(1u, countLeadingZerosSizet(1u << 30));
     EXPECT_EQ(0u, countLeadingZerosSizet(1u << 31));
 #endif
 }
 
 } // namespace WTF
 
 #endif // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)