Remove most of the blink::Task wrapping of WTF::Function outside WebTaskRunner

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 10 matching lines @@
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * 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 "platform/Task.h"
 #include "platform/ThreadSafeFunctional.h"
 #include "platform/heap/Handle.h"
 #include "platform/heap/Heap.h"
 #include "platform/heap/HeapLinkedStack.h"
 #include "platform/heap/HeapTerminatedArrayBuilder.h"
 #include "platform/heap/SafePoint.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"
 
 namespace blink {
 
 static void preciselyCollectGarbage()
 {
     Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
@@ skipping 402 matching lines @@
 int IntWrapper::s_destructorCalls = 0;
 int OffHeapInt::s_destructorCalls = 0;
 
 class ThreadedTesterBase {
 protected:
     static void test(ThreadedTesterBase* tester)
     {
         Vector<OwnPtr<WebThread>, numberOfThreads> m_threads;
         for (int i = 0; i < numberOfThreads; i++) {
             m_threads.append(adoptPtr(Platform::current()->createThread("blink gc testing thread")));
-            m_threads.last()->taskRunner()->postTask(BLINK_FROM_HERE, new Task(threadSafeBind(threadFunc, AllowCrossThreadAccess(tester))));
+            m_threads.last()->taskRunner()->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 4221 matching lines @@
     }
     preciselyCollectGarbage();
     EXPECT_EQ(2, MixinA::s_traceCount);
 }
 
 class GCParkingThreadTester {
 public:
     static void test()
     {
         OwnPtr<WebThread> sleepingThread = adoptPtr(Platform::current()->createThread("SleepingThread"));
-        sleepingThread->taskRunner()->postTask(BLINK_FROM_HERE, new Task(threadSafeBind(sleeperMainFunc)));
+        sleepingThread->taskRunner()->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);
             EXPECT_FALSE(scope.allThreadsParked());
@@ skipping 649 matching lines @@
 }
 
 class DeadBitTester {
 public:
     static void test()
     {
         IntWrapper::s_destructorCalls = 0;
 
         MutexLocker locker(mainThreadMutex());
         OwnPtr<WebThread> workerThread = adoptPtr(Platform::current()->createThread("Test Worker Thread"));
-        workerThread->taskRunner()->postTask(BLINK_FROM_HERE, new Task(threadSafeBind(workerThreadMain)));
+        workerThread->taskRunner()->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.
         // Also at this point the worker is waiting for the main thread
@@ skipping 82 matching lines @@
 }
 
 class ThreadedStrongificationTester {
 public:
     static void test()
     {
         IntWrapper::s_destructorCalls = 0;
 
         MutexLocker locker(mainThreadMutex());
         OwnPtr<WebThread> workerThread = adoptPtr(Platform::current()->createThread("Test Worker Thread"));
-        workerThread->taskRunner()->postTask(BLINK_FROM_HERE, new Task(threadSafeBind(workerThreadMain)));
+        workerThread->taskRunner()->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
         // heap is found through the persistent and the backing should
@@ skipping 182 matching lines @@
 int DestructorLockingObject::s_destructorCalls = 0;
 
 class RecursiveLockingTester {
 public:
     static void test()
     {
         DestructorLockingObject::s_destructorCalls = 0;
 
         MutexLocker locker(mainThreadMutex());
         OwnPtr<WebThread> workerThread = adoptPtr(Platform::current()->createThread("Test Worker Thread"));
-        workerThread->taskRunner()->postTask(BLINK_FROM_HERE, new Task(threadSafeBind(workerThreadMain)));
+        workerThread->taskRunner()->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.
             wakeWorkerThread();
@@ skipping 53 matching lines @@
 {
     RecursiveLockingTester::test();
 }
 
 class CrossThreadPersistentOnMainThreadTester {
 public:
     static void test()
     {
         MutexLocker locker(mainThreadMutex());
         OwnPtr<WebThread> workerThread = adoptPtr(Platform::current()->createThread("Test Worker Thread"));
-        workerThread->taskRunner()->postTask(BLINK_FROM_HERE, new Task(threadSafeBind(workerThreadMain)));
+        workerThread->taskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(workerThreadMain));
 
         parkMainThread();
 
         // (Temporarily) detach main thread and wake the worker thread, so that it
         // can do its detach().
         ThreadState::detachMainThread();
         wakeWorkerThread();
 
         parkMainThread();
         ThreadState::attachMainThread();
@@ skipping 698 matching lines @@
     // 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());
     OwnPtr<WebThread> workerThread = adoptPtr(Platform::current()->createThread("Test Worker Thread"));
     DestructorLockingObject* object = nullptr;
-    workerThread->taskRunner()->postTask(BLINK_FROM_HERE, new Task(threadSafeBind(workerThreadMainForCrossThreadWeakPersistentTest, AllowCrossThreadAccessWrapper<DestructorLockingObject**>(&object))));
+    workerThread->taskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(workerThreadMainForCrossThreadWeakPersistentTest, AllowCrossThreadAccessWrapper<DestructorLockingObject**>(&object)));
     parkMainThread();
 
     // Step 3: Set up a CrossThreadWeakPersistent.
     ASSERT_TRUE(object);
     CrossThreadWeakPersistent<DestructorLockingObject> crossThreadWeakPersistent(object);
     object = nullptr;
     {
         SafePointAwareMutexLocker recursiveMutexLocker(recursiveMutex());
         EXPECT_EQ(0, DestructorLockingObject::s_destructorCalls);
     }
@@ skipping 40 matching lines @@
     EXPECT_EQ(1u, vector2.size());
 // TODO(Oilpan): when Vector.h's contiguous container support no longer disables
 // Vector<>s with inline capacity, remove.
 #if !defined(ANNOTATE_CONTIGUOUS_CONTAINER)
     EXPECT_EQ(16u, vector1.capacity());
     EXPECT_EQ(16u, vector2.capacity());
 #endif
 }
 
 } // namespace blink