Revert "Remove OwnPtr from Blink."

third_party/WebKit/Source/platform/heap/Heap.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 30 matching lines @@
 #include "platform/heap/PagePool.h"
 #include "platform/heap/SafePoint.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/web_memory_allocator_dump.h"
 #include "platform/web_process_memory_dump.h"
 #include "public/platform/Platform.h"
 #include "wtf/Assertions.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/DataLog.h"
 #include "wtf/LeakAnnotations.h"
-#include "wtf/PtrUtil.h"
 #include "wtf/allocator/Partitions.h"
-#include <memory>
 
 namespace blink {
 
 HeapAllocHooks::AllocationHook* HeapAllocHooks::m_allocationHook = nullptr;
 HeapAllocHooks::FreeHook* HeapAllocHooks::m_freeHook = nullptr;
 
 class ParkThreadsScope final {
     STACK_ALLOCATED();
 public:
     explicit ParkThreadsScope(ThreadState* state)
@@ skipping 148 matching lines @@
     ProcessHeap::increaseTotalAllocatedSpace(delta);
 }
 
 void ThreadHeapStats::decreaseAllocatedSpace(size_t delta)
 {
     atomicSubtract(&m_allocatedSpace, static_cast<long>(delta));
     ProcessHeap::decreaseTotalAllocatedSpace(delta);
 }
 
 ThreadHeap::ThreadHeap()
-    : m_regionTree(wrapUnique(new RegionTree()))
-    , m_heapDoesNotContainCache(wrapUnique(new HeapDoesNotContainCache))
-    , m_safePointBarrier(wrapUnique(new SafePointBarrier()))
-    , m_freePagePool(wrapUnique(new FreePagePool))
-    , m_orphanedPagePool(wrapUnique(new OrphanedPagePool))
-    , m_markingStack(wrapUnique(new CallbackStack()))
-    , m_postMarkingCallbackStack(wrapUnique(new CallbackStack()))
-    , m_globalWeakCallbackStack(wrapUnique(new CallbackStack()))
-    , m_ephemeronStack(wrapUnique(new CallbackStack(CallbackStack::kMinimalBlockSize)))
+    : m_regionTree(adoptPtr(new RegionTree()))
+    , m_heapDoesNotContainCache(adoptPtr(new HeapDoesNotContainCache))
+    , m_safePointBarrier(adoptPtr(new SafePointBarrier()))
+    , m_freePagePool(adoptPtr(new FreePagePool))
+    , m_orphanedPagePool(adoptPtr(new OrphanedPagePool))
+    , m_markingStack(adoptPtr(new CallbackStack()))
+    , m_postMarkingCallbackStack(adoptPtr(new CallbackStack()))
+    , m_globalWeakCallbackStack(adoptPtr(new CallbackStack()))
+    , m_ephemeronStack(adoptPtr(new CallbackStack(CallbackStack::kMinimalBlockSize)))
 {
     if (ThreadState::current()->isMainThread())
         s_mainThreadHeap = this;
 
     MutexLocker locker(ThreadHeap::allHeapsMutex());
     allHeaps().add(this);
 }
 
 ThreadHeap::~ThreadHeap()
 {
@@ skipping 240 matching lines @@
 
 void ThreadHeap::collectGarbage(BlinkGC::StackState stackState, BlinkGC::GCType gcType, BlinkGC::GCReason reason)
 {
     ASSERT(gcType != BlinkGC::ThreadTerminationGC);
 
     ThreadState* state = ThreadState::current();
     // Nested collectGarbage() invocations aren't supported.
     RELEASE_ASSERT(!state->isGCForbidden());
     state->completeSweep();
 
-    std::unique_ptr<Visitor> visitor = Visitor::create(state, gcType);
+    OwnPtr<Visitor> visitor = Visitor::create(state, gcType);
 
     SafePointScope safePointScope(stackState, state);
 
     // Resume all parked threads upon leaving this scope.
     ParkThreadsScope parkThreadsScope(state);
 
     // Try to park the other threads. If we're unable to, bail out of the GC.
     if (!parkThreadsScope.parkThreads())
         return;
 
@@ skipping 72 matching lines @@
     state->heap().decommitCallbackStacks();
 }
 
 void ThreadHeap::collectGarbageForTerminatingThread(ThreadState* state)
 {
     {
         // A thread-specific termination GC must not allow other global GCs to go
         // ahead while it is running, hence the termination GC does not enter a
         // safepoint. VisitorScope will not enter also a safepoint scope for
         // ThreadTerminationGC.
-        std::unique_ptr<Visitor> visitor = Visitor::create(state, BlinkGC::ThreadTerminationGC);
+        OwnPtr<Visitor> visitor = Visitor::create(state, BlinkGC::ThreadTerminationGC);
 
         ThreadState::NoAllocationScope noAllocationScope(state);
 
         state->preGC();
 
         // 1. Trace the thread local persistent roots. For thread local GCs we
         // don't trace the stack (ie. no conservative scanning) since this is
         // only called during thread shutdown where there should be no objects
         // on the stack.
         // We also assume that orphaned pages have no objects reachable from
@@ skipping 201 matching lines @@
     ProcessHeap::decreaseTotalMarkedObjectSize(m_stats.markedObjectSize());
 
     m_stats.reset();
     for (ThreadState* state : m_threads)
         state->resetHeapCounters();
 }
 
 ThreadHeap* ThreadHeap::s_mainThreadHeap = nullptr;
 
 } // namespace blink