Revert "Remove OwnPtr from Blink."

third_party/WebKit/Source/platform/heap/HeapTest.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 26 matching lines @@
 #include "platform/heap/SelfKeepAlive.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/heap/Visitor.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTaskRunner.h"
 #include "public/platform/WebTraceLocation.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/HashTraits.h"
 #include "wtf/LinkedHashSet.h"
-#include "wtf/PtrUtil.h"
-#include <memory>
 
 namespace blink {
 
 static void preciselyCollectGarbage()
 {
     ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
 }
 
 static void conservativelyCollectGarbage()
 {
@@ skipping 401 matching lines @@
     int m_x;
 };
 
 int IntWrapper::s_destructorCalls = 0;
 int OffHeapInt::s_destructorCalls = 0;
 
 class ThreadedTesterBase {
 protected:
     static void test(ThreadedTesterBase* tester)
     {
-        Vector<std::unique_ptr<WebThread>, numberOfThreads> m_threads;
+        Vector<OwnPtr<WebThread>, numberOfThreads> m_threads;
         for (int i = 0; i < numberOfThreads; i++) {
-            m_threads.append(wrapUnique(Platform::current()->createThread("blink gc testing thread")));
+            m_threads.append(adoptPtr(Platform::current()->createThread("blink gc testing thread")));
             m_threads.last()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(threadFunc, AllowCrossThreadAccess(tester)));
         }
         while (tester->m_threadsToFinish) {
             SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
             testing::yieldCurrentThread();
         }
         delete tester;
     }
 
     virtual void runThread() = 0;
@@ skipping 41 matching lines @@
         for (auto& globalIntWrapper : m_crossPersistents) {
             ASSERT(globalIntWrapper.get());
             EXPECT_FALSE(globalIntWrapper.get()->get());
         }
     }
 
 protected:
     using GlobalIntWrapperPersistent = CrossThreadPersistent<IntWrapper>;
 
     Mutex m_mutex;
-    Vector<std::unique_ptr<GlobalIntWrapperPersistent>> m_crossPersistents;
+    Vector<OwnPtr<GlobalIntWrapperPersistent>> m_crossPersistents;
 
-    std::unique_ptr<GlobalIntWrapperPersistent> createGlobalPersistent(int value)
+    PassOwnPtr<GlobalIntWrapperPersistent> createGlobalPersistent(int value)
     {
-        return wrapUnique(new GlobalIntWrapperPersistent(IntWrapper::create(value)));
+        return adoptPtr(new GlobalIntWrapperPersistent(IntWrapper::create(value)));
     }
 
     void addGlobalPersistent()
     {
         MutexLocker lock(m_mutex);
         m_crossPersistents.append(createGlobalPersistent(0x2a2a2a2a));
     }
 
     void runThread() override
     {
         ThreadState::attachCurrentThread(false);
 
         // Add a cross-thread persistent from this thread; the test object
         // verifies that it will have been cleared out after the threads
         // have all detached, running their termination GCs while doing so.
         addGlobalPersistent();
 
         int gcCount = 0;
         while (!done()) {
             ThreadState::current()->safePoint(BlinkGC::NoHeapPointersOnStack);
             {
                 Persistent<IntWrapper> wrapper;
 
-                std::unique_ptr<GlobalIntWrapperPersistent> globalPersistent = createGlobalPersistent(0x0ed0cabb);
+                OwnPtr<GlobalIntWrapperPersistent> globalPersistent = createGlobalPersistent(0x0ed0cabb);
 
                 for (int i = 0; i < numberOfAllocations; i++) {
                     wrapper = IntWrapper::create(0x0bbac0de);
                     if (!(i % 10)) {
                         globalPersistent = createGlobalPersistent(0x0ed0cabb);
                     }
                     SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
                     testing::yieldCurrentThread();
                 }
 
@@ skipping 810 matching lines @@
         , m_didCallWillFinalize(false)
     {
     }
 
     WeakMember<T> m_data;
     bool m_didCallWillFinalize;
 };
 
 class FinalizationObserverWithHashMap {
 public:
-    typedef HeapHashMap<WeakMember<Observable>, std::unique_ptr<FinalizationObserverWithHashMap>> ObserverMap;
+    typedef HeapHashMap<WeakMember<Observable>, OwnPtr<FinalizationObserverWithHashMap>> ObserverMap;
 
     explicit FinalizationObserverWithHashMap(Observable& target) : m_target(target) { }
     ~FinalizationObserverWithHashMap()
     {
         m_target.willFinalize();
         s_didCallWillFinalize = true;
     }
 
     static ObserverMap& observe(Observable& target)
     {
         ObserverMap& map = observers();
         ObserverMap::AddResult result = map.add(&target, nullptr);
         if (result.isNewEntry)
-            result.storedValue->value = wrapUnique(new FinalizationObserverWithHashMap(target));
+            result.storedValue->value = adoptPtr(new FinalizationObserverWithHashMap(target));
         else
             ASSERT(result.storedValue->value);
         return map;
     }
 
     static void clearObservers()
     {
         delete s_observerMap;
         s_observerMap = nullptr;
     }
@@ skipping 3371 matching lines @@
         }
     }
 
     EXPECT_FALSE(RefCountedWithDestructor::s_wasDestructed);
     set.clear();
     EXPECT_TRUE(RefCountedWithDestructor::s_wasDestructed);
 }
 
 TEST(HeapTest, DestructorsCalled)
 {
-    HeapHashMap<Member<IntWrapper>, std::unique_ptr<SimpleClassWithDestructor>> map;
+    HeapHashMap<Member<IntWrapper>, OwnPtr<SimpleClassWithDestructor>> map;
     SimpleClassWithDestructor* hasDestructor = new SimpleClassWithDestructor();
-    map.add(IntWrapper::create(1), wrapUnique(hasDestructor));
+    map.add(IntWrapper::create(1), adoptPtr(hasDestructor));
     SimpleClassWithDestructor::s_wasDestructed = false;
     map.clear();
     EXPECT_TRUE(SimpleClassWithDestructor::s_wasDestructed);
 }
 
 class MixinA : public GarbageCollectedMixin {
 public:
     MixinA() : m_obj(IntWrapper::create(100)) { }
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
@@ skipping 124 matching lines @@
         EXPECT_EQ(2, MixinA::s_traceCount);
     }
     preciselyCollectGarbage();
     EXPECT_EQ(2, MixinA::s_traceCount);
 }
 
 class GCParkingThreadTester {
 public:
     static void test()
     {
-        std::unique_ptr<WebThread> sleepingThread = wrapUnique(Platform::current()->createThread("SleepingThread"));
+        OwnPtr<WebThread> sleepingThread = adoptPtr(Platform::current()->createThread("SleepingThread"));
         sleepingThread->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(sleeperMainFunc));
 
         // Wait for the sleeper to run.
         while (!s_sleeperRunning) {
             testing::yieldCurrentThread();
         }
 
         {
             // Expect the first attempt to park the sleeping thread to fail
             TestGCScope scope(BlinkGC::NoHeapPointersOnStack);
@@ skipping 644 matching lines @@
     workerThreadCondition().signal();
 }
 
 class DeadBitTester {
 public:
     static void test()
     {
         IntWrapper::s_destructorCalls = 0;
 
         MutexLocker locker(mainThreadMutex());
-        std::unique_ptr<WebThread> workerThread = wrapUnique(Platform::current()->createThread("Test Worker Thread"));
+        OwnPtr<WebThread> workerThread = adoptPtr(Platform::current()->createThread("Test Worker Thread"));
         workerThread->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(workerThreadMain));
 
         // Wait for the worker thread to have done its initialization,
         // IE. the worker allocates an object and then throw aways any
         // pointers to it.
         parkMainThread();
 
         // Now do a GC. This will not find the worker threads object since it
         // is not referred from any of the threads. Even a conservative
         // GC will not find it.
@@ skipping 82 matching lines @@
     DeadBitTester::test();
 }
 
 class ThreadedStrongificationTester {
 public:
     static void test()
     {
         IntWrapper::s_destructorCalls = 0;
 
         MutexLocker locker(mainThreadMutex());
-        std::unique_ptr<WebThread> workerThread = wrapUnique(Platform::current()->createThread("Test Worker Thread"));
+        OwnPtr<WebThread> workerThread = adoptPtr(Platform::current()->createThread("Test Worker Thread"));
         workerThread->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(workerThreadMain));
 
         // Wait for the worker thread initialization. The worker
         // allocates a weak collection where both collection and
         // contents are kept alive via persistent pointers.
         parkMainThread();
 
         // Perform two garbage collections where the worker thread does
         // not wake up in between. This will cause us to remove marks
         // and mark unmarked objects dead. The collection on the worker
@@ skipping 182 matching lines @@
 
 int DestructorLockingObject::s_destructorCalls = 0;
 
 class RecursiveLockingTester {
 public:
     static void test()
     {
         DestructorLockingObject::s_destructorCalls = 0;
 
         MutexLocker locker(mainThreadMutex());
-        std::unique_ptr<WebThread> workerThread = wrapUnique(Platform::current()->createThread("Test Worker Thread"));
+        OwnPtr<WebThread> workerThread = adoptPtr(Platform::current()->createThread("Test Worker Thread"));
         workerThread->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(workerThreadMain));
 
         // Park the main thread until the worker thread has initialized.
         parkMainThread();
 
         {
             SafePointAwareMutexLocker recursiveLocker(recursiveMutex());
 
             // Let the worker try to acquire the above mutex. It won't get it
             // until the main thread has done its GC.
@@ skipping 684 matching lines @@
 public:
     explicit WeakPersistentHolder(IntWrapper* object) : m_object(object) { }
     IntWrapper* object() const { return m_object; }
 private:
     WeakPersistent<IntWrapper> m_object;
 };
 
 TEST(HeapTest, WeakPersistent)
 {
     Persistent<IntWrapper> object = new IntWrapper(20);
-    std::unique_ptr<WeakPersistentHolder> holder = wrapUnique(new WeakPersistentHolder(object));
+    OwnPtr<WeakPersistentHolder> holder = adoptPtr(new WeakPersistentHolder(object));
     preciselyCollectGarbage();
     EXPECT_TRUE(holder->object());
     object = nullptr;
     preciselyCollectGarbage();
     EXPECT_FALSE(holder->object());
 }
 
 namespace {
 
 void workerThreadMainForCrossThreadWeakPersistentTest(DestructorLockingObject** object)
@@ skipping 20 matching lines @@
 TEST(HeapTest, CrossThreadWeakPersistent)
 {
     // Create an object in the worker thread, have a CrossThreadWeakPersistent pointing to it on the main thread,
     // clear the reference in the worker thread, run a GC in the worker thread, and see if the
     // CrossThreadWeakPersistent is cleared.
 
     DestructorLockingObject::s_destructorCalls = 0;
 
     // Step 1: Initiate a worker thread, and wait for |object| to get allocated on the worker thread.
     MutexLocker mainThreadMutexLocker(mainThreadMutex());
-    std::unique_ptr<WebThread> workerThread = wrapUnique(Platform::current()->createThread("Test Worker Thread"));
+    OwnPtr<WebThread> workerThread = adoptPtr(Platform::current()->createThread("Test Worker Thread"));
     DestructorLockingObject* object = nullptr;
     workerThread->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(workerThreadMainForCrossThreadWeakPersistentTest, AllowCrossThreadAccess(&object)));
     parkMainThread();
 
     // Step 3: Set up a CrossThreadWeakPersistent.
     ASSERT_TRUE(object);
     CrossThreadWeakPersistent<DestructorLockingObject> crossThreadWeakPersistent(object);
     object = nullptr;
     {
         SafePointAwareMutexLocker recursiveMutexLocker(recursiveMutex());
@@ skipping 250 matching lines @@
     static_assert(WTF::IsGarbageCollectedType<HeapLinkedHashSet<Member<IntWrapper>>>::value, "HeapLinkedHashSet");
     static_assert(WTF::IsGarbageCollectedType<HeapListHashSet<Member<IntWrapper>>>::value, "HeapListHashSet");
     static_assert(WTF::IsGarbageCollectedType<HeapHashCountedSet<Member<IntWrapper>>>::value, "HeapHashCountedSet");
     static_assert(WTF::IsGarbageCollectedType<HeapHashMap<int, Member<IntWrapper>>>::value, "HeapHashMap");
     static_assert(WTF::IsGarbageCollectedType<HeapVector<Member<IntWrapper>>>::value, "HeapVector");
     static_assert(WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value, "HeapDeque");
     static_assert(WTF::IsGarbageCollectedType<HeapTerminatedArray<Member<IntWrapper>>>::value, "HeapTerminatedArray");
 }
 
 } // namespace blink