Remove OwnPtr from Blink.

third_party/WebKit/Source/platform/heap/ThreadState.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 27 matching lines @@
 #include "public/platform/WebThread.h"
 #include "wtf/AddressSanitizer.h"
 #include "wtf/Allocator.h"
 #include "wtf/Forward.h"
 #include "wtf/Functional.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/ThreadSpecific.h"
 #include "wtf/Threading.h"
 #include "wtf/ThreadingPrimitives.h"
+#include <memory>
 
 namespace v8 {
 class Isolate;
 };
 
 namespace blink {
 
 class BasePage;
 class CallbackStack;
 struct GCInfo;
@@ skipping 13 matching lines @@
 // that may be collected in the same GC cycle. If you cannot avoid touching
 // on-heap objects in a destructor (which is not allowed), you can consider
 // using the pre-finalizer. The only restriction is that the pre-finalizer
 // must not resurrect dead objects (e.g., store unmarked objects into
 // Members etc). The pre-finalizer is called on the thread that registered
 // the pre-finalizer.
 //
 // Since a pre-finalizer adds pressure on GC performance, you should use it
 // only if necessary.
 //
-// A pre-finalizer is similar to the HeapHashMap<WeakMember<Foo>, OwnPtr<Disposer>>
+// A pre-finalizer is similar to the HeapHashMap<WeakMember<Foo>, std::unique_ptr<Disposer>>
 // idiom.  The difference between this and the idiom is that pre-finalizer
 // function is called whenever an object is destructed with this feature.  The
-// HeapHashMap<WeakMember<Foo>, OwnPtr<Disposer>> idiom requires an assumption
+// HeapHashMap<WeakMember<Foo>, std::unique_ptr<Disposer>> idiom requires an assumption
 // that the HeapHashMap outlives objects pointed by WeakMembers.
-// FIXME: Replace all of the HeapHashMap<WeakMember<Foo>, OwnPtr<Disposer>>
+// FIXME: Replace all of the HeapHashMap<WeakMember<Foo>, std::unique_ptr<Disposer>>
 // idiom usages with the pre-finalizer if the replacement won't cause
 // performance regressions.
 //
 // Usage:
 //
 // class Foo : GarbageCollected<Foo> {
 //     USING_PRE_FINALIZER(Foo, dispose);
 // public:
 //     Foo()
 //     {
@@ skipping 230 matching lines @@
 
     // Check if GC is requested by another thread and pause this thread if this is the case.
     // Can only be called when current thread is in a consistent state.
     void safePoint(BlinkGC::StackState);
 
     // Mark current thread as running inside safepoint.
     void enterSafePoint(BlinkGC::StackState, void*);
     void leaveSafePoint(SafePointAwareMutexLocker* = nullptr);
     bool isAtSafePoint() const { return m_atSafePoint; }
 
-    void addInterruptor(PassOwnPtr<BlinkGCInterruptor>);
+    void addInterruptor(std::unique_ptr<BlinkGCInterruptor>);
 
     void recordStackEnd(intptr_t* endOfStack)
     {
         m_endOfStack = endOfStack;
     }
 
     // Get one of the heap structures for this thread.
     // The thread heap is split into multiple heap parts based on object types
     // and object sizes.
     BaseArena* arena(int arenaIndex) const
@@ skipping 245 matching lines @@
 
     void invokePreFinalizers();
 
     void takeSnapshot(SnapshotType);
     void clearArenaAges();
     int arenaIndexOfVectorArenaLeastRecentlyExpanded(int beginArenaIndex, int endArenaIndex);
 
     void reportMemoryToV8();
 
     // Should only be called under protection of threadAttachMutex().
-    const Vector<OwnPtr<BlinkGCInterruptor>>& interruptors() const { return m_interruptors; }
+    const Vector<std::unique_ptr<BlinkGCInterruptor>>& interruptors() const { return m_interruptors; }
 
     friend class SafePointAwareMutexLocker;
     friend class SafePointBarrier;
     friend class SafePointScope;
 
     static WTF::ThreadSpecific<ThreadState*>* s_threadSpecific;
     static uintptr_t s_mainThreadStackStart;
     static uintptr_t s_mainThreadUnderestimatedStackSize;
 
     // We can't create a static member of type ThreadState here
     // because it will introduce global constructor and destructor.
     // We would like to manage lifetime of the ThreadState attached
     // to the main thread explicitly instead and still use normal
     // constructor and destructor for the ThreadState class.
     // For this we reserve static storage for the main ThreadState
     // and lazily construct ThreadState in it using placement new.
     static uint8_t s_mainThreadStateStorage[];
 
     ThreadHeap* m_heap;
     ThreadIdentifier m_thread;
-    OwnPtr<PersistentRegion> m_persistentRegion;
+    std::unique_ptr<PersistentRegion> m_persistentRegion;
     BlinkGC::StackState m_stackState;
 #if OS(WIN) && COMPILER(MSVC)
     size_t m_threadStackSize;
 #endif
     intptr_t* m_startOfStack;
     intptr_t* m_endOfStack;
 
     void* m_safePointScopeMarker;
     Vector<Address> m_safePointStackCopy;
     bool m_atSafePoint;
-    Vector<OwnPtr<BlinkGCInterruptor>> m_interruptors;
+    Vector<std::unique_ptr<BlinkGCInterruptor>> m_interruptors;
     bool m_sweepForbidden;
     size_t m_noAllocationCount;
     size_t m_gcForbiddenCount;
     double m_accumulatedSweepingTime;
 
     BaseArena* m_arenas[BlinkGC::NumberOfArenas];
     int m_vectorBackingArenaIndex;
     size_t m_arenaAges[BlinkGC::NumberOfArenas];
     size_t m_currentArenaAges;
 
@@ skipping 29 matching lines @@
     // Count that controls scoped disabling of persistent registration.
     size_t m_disabledStaticPersistentsRegistration;
 #endif
 
     // Ideally we want to allocate an array of size |gcInfoTableMax| but it will
     // waste memory. Thus we limit the array size to 2^8 and share one entry
     // with multiple types of vectors. This won't be an issue in practice,
     // since there will be less than 2^8 types of objects in common cases.
     static const int likelyToBePromptlyFreedArraySize = (1 << 8);
     static const int likelyToBePromptlyFreedArrayMask = likelyToBePromptlyFreedArraySize - 1;
-    OwnPtr<int[]> m_likelyToBePromptlyFreed;
+    std::unique_ptr<int[]> m_likelyToBePromptlyFreed;
 
     // Stats for heap memory of this thread.
     size_t m_allocatedObjectSize;
     size_t m_markedObjectSize;
     size_t m_reportedMemoryToV8;
 };
 
 template<ThreadAffinity affinity> class ThreadStateFor;
 
 template<> class ThreadStateFor<MainThreadOnly> {
     STATIC_ONLY(ThreadStateFor);
 public:
     static ThreadState* state()
     {
         // This specialization must only be used from the main thread.
         ASSERT(ThreadState::current()->isMainThread());
         return ThreadState::mainThreadState();
     }
 };
 
 template<> class ThreadStateFor<AnyThread> {
     STATIC_ONLY(ThreadStateFor);
 public:
     static ThreadState* state() { return ThreadState::current(); }
 };
 
 } // namespace blink
 
 #endif // ThreadState_h