Remove OwnPtr from Blink.

third_party/WebKit/Source/platform/heap/Heap.h

 /*
  * 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 24 matching lines @@
 #include "platform/heap/GCInfo.h"
 #include "platform/heap/HeapPage.h"
 #include "platform/heap/PageMemory.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/heap/Visitor.h"
 #include "wtf/AddressSanitizer.h"
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/Atomics.h"
 #include "wtf/Forward.h"
+#include <memory>
 
 namespace blink {
 
 class PLATFORM_EXPORT HeapAllocHooks {
 public:
     // TODO(hajimehoshi): Pass a type name of the allocated object.
     typedef void AllocationHook(Address, size_t, const char*);
     typedef void FreeHook(Address);
 
     static void setAllocationHook(AllocationHook* hook) { m_allocationHook = hook; }
@@ skipping 341 matching lines @@
     void resetHeapCounters();
 
     static int arenaIndexForObjectSize(size_t);
     static bool isNormalArenaIndex(int);
 
     void decommitCallbackStacks();
 
     RecursiveMutex m_threadAttachMutex;
     ThreadStateSet m_threads;
     ThreadHeapStats m_stats;
-    OwnPtr<RegionTree> m_regionTree;
-    OwnPtr<HeapDoesNotContainCache> m_heapDoesNotContainCache;
-    OwnPtr<SafePointBarrier> m_safePointBarrier;
-    OwnPtr<FreePagePool> m_freePagePool;
-    OwnPtr<OrphanedPagePool> m_orphanedPagePool;
-    OwnPtr<CallbackStack> m_markingStack;
-    OwnPtr<CallbackStack> m_postMarkingCallbackStack;
-    OwnPtr<CallbackStack> m_globalWeakCallbackStack;
-    OwnPtr<CallbackStack> m_ephemeronStack;
+    std::unique_ptr<RegionTree> m_regionTree;
+    std::unique_ptr<HeapDoesNotContainCache> m_heapDoesNotContainCache;
+    std::unique_ptr<SafePointBarrier> m_safePointBarrier;
+    std::unique_ptr<FreePagePool> m_freePagePool;
+    std::unique_ptr<OrphanedPagePool> m_orphanedPagePool;
+    std::unique_ptr<CallbackStack> m_markingStack;
+    std::unique_ptr<CallbackStack> m_postMarkingCallbackStack;
+    std::unique_ptr<CallbackStack> m_globalWeakCallbackStack;
+    std::unique_ptr<CallbackStack> m_ephemeronStack;
     BlinkGC::GCReason m_lastGCReason;
 
     static ThreadHeap* s_mainThreadHeap;
 
     friend class ThreadState;
 };
 
 template<typename T>
 struct IsEagerlyFinalizedType {
     STATIC_ONLY(IsEagerlyFinalizedType);
@@ skipping 196 matching lines @@
 void VisitorHelper<Derived>::handleWeakCell(Visitor* self, void* object)
 {
     T** cell = reinterpret_cast<T**>(object);
     if (*cell && !ObjectAliveTrait<T>::isHeapObjectAlive(*cell))
         *cell = nullptr;
 }
 
 } // namespace blink
 
 #endif // Heap_h