Introduce WebTaskRunner Patch 3/5

Source/core/workers/WorkerThreadTest.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/workers/WorkerThread.h"
 
 #include "core/inspector/ConsoleMessage.h"
 #include "core/workers/WorkerReportingProxy.h"
 #include "core/workers/WorkerThreadStartupData.h"
@@ skipping 127 matching lines @@
 private:
     OwnPtr<WebThreadSupportingGC> m_thread;
     OwnPtr<WebWaitableEvent> m_scriptLoadedEvent;
 };
 
 void notifyScriptLoadedEventToWorkerThreadForTest(WorkerThread* thread)
 {
     static_cast<WorkerThreadForTest*>(thread)->scriptLoaded();
 }
 
-class WakeupTask : public WebThread::Task {
+class WakeupTask : public WebTaskRunner::Task {
 public:
     WakeupTask() { }
 
     ~WakeupTask() override { }
 
     void run() override { }
 };
 
-class PostDelayedWakeupTask : public WebThread::Task {
+class PostDelayedWakeupTask : public WebTaskRunner::Task {
 public:
     PostDelayedWakeupTask(WebScheduler* scheduler, long long delay) : m_scheduler(scheduler), m_delay(delay) { }
 
     ~PostDelayedWakeupTask() override { }
 
     void run() override
     {
-        m_scheduler->postTimerTask(FROM_HERE, new WakeupTask(), m_delay);
+        m_scheduler->timerTaskRunner()->postDelayedTask(FROM_HERE, new WakeupTask(), m_delay);
     }
 
     WebScheduler* m_scheduler; // Not owned.
     long long m_delay;
 };
 
-class SignalTask : public WebThread::Task {
+class SignalTask : public WebTaskRunner::Task {
 public:
     SignalTask(WebWaitableEvent* completionEvent) : m_completionEvent(completionEvent) { }
 
     ~SignalTask() override { }
 
     void run() override
     {
         m_completionEvent->signal();
     }
 
@@ skipping 101 matching lines @@
         .Times(AtMost(1));
     EXPECT_CALL(*m_mockWorkerReportingProxy, workerThreadTerminated())
         .Times(AtMost(1));
     EXPECT_CALL(*m_mockWorkerReportingProxy, willDestroyWorkerGlobalScope())
         .Times(AtMost(1));
     startWithSourceCode(source);
     m_workerThread->waitUntilScriptLoaded();
     m_workerThread->terminateAndWait();
 }
 
-class RepeatingTask : public WebThread::Task {
+class RepeatingTask : public WebTaskRunner::Task {
 public:
     RepeatingTask(WebScheduler* scheduler, WebWaitableEvent* completion)
         : RepeatingTask(scheduler, completion, 0) { }
 
     ~RepeatingTask() override { }
 
     void run() override
     {
         m_taskCount++;
         if (m_taskCount == 10)
             m_completion->signal();
 
-        m_scheduler->postTimerTask(
-            FROM_HERE, new RepeatingTask(m_scheduler, m_completion, m_taskCount), 0ul);
-        m_scheduler->postLoadingTask(FROM_HERE, new WakeupTask());
-
+        m_scheduler->timerTaskRunner()->postTask(
+            FROM_HERE, new RepeatingTask(m_scheduler, m_completion, m_taskCount));
+        m_scheduler->timerTaskRunner()->postTask(FROM_HERE, new WakeupTask());
     }
 
 private:
     RepeatingTask(WebScheduler* scheduler, WebWaitableEvent* completion, int taskCount)
         : m_scheduler(scheduler)
         , m_completion(completion)
         , m_taskCount(taskCount)
         { }
 
     WebScheduler* m_scheduler; // Not owned.
     WebWaitableEvent* m_completion;
     int m_taskCount;
 };
 
 TEST_F(WorkerThreadTest, GcDoesNotOccurWhenNotIdle)
 {
     OwnPtr<WebWaitableEvent> completion = adoptPtr(Platform::current()->createWaitableEvent());
 
     EXPECT_CALL(*m_workerThread, doIdleGc(_)).Times(0);
 
     expectWorkerLifetimeReportingCalls();
     start();
     waitForInit();
 
     WebScheduler* scheduler = m_workerThread->backingThread().platformThread().scheduler();
 
     // Post a repeating task that should prevent any GC from happening.
-    scheduler->postLoadingTask(FROM_HERE, new RepeatingTask(scheduler, completion.get()));
+    scheduler->loadingTaskRunner()->postTask(FROM_HERE, new RepeatingTask(scheduler, completion.get()));
 
     completion->wait();
 
     // Make sure doIdleGc has not been called by this stage.
     Mock::VerifyAndClearExpectations(m_workerThread.get());
 
     m_workerThread->terminateAndWait();
 }
 
 } // namespace blink