(WIP) Worker: Merge ParentFrameTaskRunners into TaskRunnerHelper

third_party/WebKit/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 "core/workers/WorkerThread.h"
 
+#include <memory>
+#include "core/dom/TaskRunnerHelper.h"
 #include "core/workers/WorkerThreadTestHelper.h"
 #include "platform/WaitableEvent.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/PtrUtil.h"
-#include <memory>
 
 using testing::_;
 using testing::AnyNumber;
 using testing::AtMost;
 
 namespace blink {
 
 using ExitCode = WorkerThread::ExitCode;
 
 namespace {
 
 // Used as a debugger task. Waits for a signal from the main thread.
 void waitForSignalTask(WorkerThread* workerThread,
                        WaitableEvent* waitableEvent) {
   EXPECT_TRUE(workerThread->isCurrentThread());
 
   // Notify the main thread that the debugger task is waiting for the signal.
-  workerThread->getParentFrameTaskRunners()
-      ->get(TaskType::UnspecedTimer)
+  FrameTaskRunnerHelper::get(TaskType::UnspecedTimer,
+                             workerThread->globalScope())
       ->postTask(BLINK_FROM_HERE, crossThreadBind(&testing::exitRunLoop));
   waitableEvent->wait();
 }
 
 }  // namespace
 
 class WorkerThreadTest : public ::testing::Test {
  public:
   WorkerThreadTest() {}
 
   void SetUp() override {
     m_loaderProxyProvider = WTF::makeUnique<MockWorkerLoaderProxyProvider>();
     m_reportingProxy = WTF::makeUnique<MockWorkerReportingProxy>();
     m_securityOrigin =
         SecurityOrigin::create(KURL(ParsedURLString, "http://fake.url/"));
     m_workerThread = WTF::wrapUnique(new WorkerThreadForTest(
         m_loaderProxyProvider.get(), *m_reportingProxy));
     m_lifecycleObserver = new MockWorkerThreadLifecycleObserver(
         m_workerThread->getWorkerThreadLifecycleContext());
   }
 
   void TearDown() override {
     m_workerThread->workerLoaderProxy()->detachProvider(
         m_loaderProxyProvider.get());
   }
 
   void start() {
     m_workerThread->startWithSourceCode(
         m_securityOrigin.get(), "//fake source code",
-        ParentFrameTaskRunners::create(nullptr));
+        FrameTaskRunnersHolder::create(nullptr));
   }
 
   void startWithSourceCodeNotToFinish() {
     // Use a JavaScript source code that makes an infinite loop so that we
     // can catch some kind of issues as a timeout.
     m_workerThread->startWithSourceCode(
         m_securityOrigin.get(), "while(true) {}",
-        ParentFrameTaskRunners::create(nullptr));
+        FrameTaskRunnersHolder::create(nullptr));
   }
 
   void setForcibleTerminationDelayInMs(long long forcibleTerminationDelayInMs) {
     m_workerThread->m_forcibleTerminationDelayInMs =
         forcibleTerminationDelayInMs;
   }
 
   bool isForcibleTerminationTaskScheduled() {
     return m_workerThread->m_forcibleTerminationTaskHandle.isActive();
   }
@@ skipping 196 matching lines @@
   // on initialziation to run debugger tasks.
   std::unique_ptr<WorkerThreadStartupData> startupData =
       WorkerThreadStartupData::create(
           KURL(ParsedURLString, "http://fake.url/"), "fake user agent",
           "//fake source code", nullptr, /* cachedMetaData */
           PauseWorkerGlobalScopeOnStart, headers.get(), "",
           m_securityOrigin.get(), nullptr, /* workerClients */
           WebAddressSpaceLocal, nullptr /* originTrialToken */,
           nullptr /* WorkerSettings */, WorkerV8Settings::Default());
   m_workerThread->start(std::move(startupData),
-                        ParentFrameTaskRunners::create(nullptr));
+                        FrameTaskRunnersHolder::create(nullptr));
 
   // Used to wait for worker thread termination in a debugger task on the
   // worker thread.
   WaitableEvent waitableEvent;
   m_workerThread->appendDebuggerTask(crossThreadBind(
       &waitForSignalTask, crossThreadUnretained(m_workerThread.get()),
       crossThreadUnretained(&waitableEvent)));
 
   // Wait for the debugger task.
   testing::enterRunLoop();
@@ skipping 59 matching lines @@
 
   // Resume the debugger task. Shutdown starts after that.
   waitableEvent.signal();
   m_workerThread->waitForShutdownForTesting();
   EXPECT_EQ(ExitCode::GracefullyTerminated, getExitCode());
 }
 
 // TODO(nhiroki): Add tests for terminateAndWaitForAllWorkers.
 
 }  // namespace blink