Worker: Pass ParentFrameTaskRunners via WorkerThread::start() instead of the ctor

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 "core/workers/WorkerThreadTestHelper.h"
 #include "platform/WaitableEvent.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 27 matching lines @@
 
 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,
-                                ParentFrameTaskRunners::create(nullptr)));
+    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");
+    m_workerThread->startWithSourceCode(
+        m_securityOrigin.get(), "//fake source code",
+        ParentFrameTaskRunners::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) {}");
+    m_workerThread->startWithSourceCode(
+        m_securityOrigin.get(), "while(true) {}",
+        ParentFrameTaskRunners::create(nullptr));
   }
 
   void setForcibleTerminationDelayInMs(long long forcibleTerminationDelayInMs) {
     m_workerThread->m_forcibleTerminationDelayInMs =
         forcibleTerminationDelayInMs;
   }
 
   bool isForcibleTerminationTaskScheduled() {
     return m_workerThread->m_forcibleTerminationTaskHandle.isActive();
   }
@@ skipping 195 matching lines @@
   // Specify PauseWorkerGlobalScopeOnStart so that the worker thread can pause
   // 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));
+  m_workerThread->start(std::move(startupData),
+                        ParentFrameTaskRunners::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