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

third_party/WebKit/Source/core/workers/WorkerThreadTestHelper.h

 // Copyright 2016 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 "bindings/core/v8/SourceLocation.h"
 #include "bindings/core/v8/V8CacheOptions.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "core/dom/ExecutionContextTask.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/inspector/ConsoleMessage.h"
@@ skipping 101 matching lines @@
   explicit MockWorkerThreadLifecycleObserver(
       WorkerThreadLifecycleContext* context)
       : WorkerThreadLifecycleObserver(context) {}
 
   MOCK_METHOD1(contextDestroyed, void(WorkerThreadLifecycleContext*));
 };
 
 class WorkerThreadForTest : public WorkerThread {
  public:
   WorkerThreadForTest(WorkerLoaderProxyProvider* mockWorkerLoaderProxyProvider,
-                      WorkerReportingProxy& mockWorkerReportingProxy,
-                      ParentFrameTaskRunners* parentFrameTaskRunners)
+                      WorkerReportingProxy& mockWorkerReportingProxy)
       : WorkerThread(WorkerLoaderProxy::create(mockWorkerLoaderProxyProvider),
-                     mockWorkerReportingProxy,
-                     parentFrameTaskRunners),
+                     mockWorkerReportingProxy),
         m_workerBackingThread(
             WorkerBackingThread::createForTest("Test thread")) {}
 
   ~WorkerThreadForTest() override {}
 
   WorkerBackingThread& workerBackingThread() override {
     return *m_workerBackingThread;
   }
   void clearWorkerBackingThread() override { m_workerBackingThread = nullptr; }
 
   WorkerOrWorkletGlobalScope* createWorkerGlobalScope(
       std::unique_ptr<WorkerThreadStartupData>) override;
 
   void startWithSourceCode(SecurityOrigin* securityOrigin,
-                           const String& source) {
+                           const String& source,
+                           ParentFrameTaskRunners* parentFrameTaskRunners) {
     std::unique_ptr<Vector<CSPHeaderAndType>> headers =
         WTF::makeUnique<Vector<CSPHeaderAndType>>();
     CSPHeaderAndType headerAndType("contentSecurityPolicy",
                                    ContentSecurityPolicyHeaderTypeReport);
     headers->push_back(headerAndType);
 
     WorkerClients* clients = nullptr;
 
     start(WorkerThreadStartupData::create(
-        KURL(ParsedURLString, "http://fake.url/"), "fake user agent", source,
-        nullptr, DontPauseWorkerGlobalScopeOnStart, headers.get(), "",
-        securityOrigin, clients, WebAddressSpaceLocal, nullptr, nullptr,
-        WorkerV8Settings::Default()));
+              KURL(ParsedURLString, "http://fake.url/"), "fake user agent",
+              source, nullptr, DontPauseWorkerGlobalScopeOnStart, headers.get(),
+              "", securityOrigin, clients, WebAddressSpaceLocal, nullptr,
+              nullptr, WorkerV8Settings::Default()),
+          parentFrameTaskRunners);
   }
 
   void waitForInit() {
     std::unique_ptr<WaitableEvent> completionEvent =
         WTF::makeUnique<WaitableEvent>();
     workerBackingThread().backingThread().postTask(
         BLINK_FROM_HERE,
         crossThreadBind(&WaitableEvent::signal,
                         crossThreadUnretained(completionEvent.get())));
     completionEvent->wait();
@@ skipping 30 matching lines @@
 
 inline WorkerOrWorkletGlobalScope* WorkerThreadForTest::createWorkerGlobalScope(
     std::unique_ptr<WorkerThreadStartupData> startupData) {
   return new FakeWorkerGlobalScope(
       startupData->m_scriptURL, startupData->m_userAgent, this,
       std::move(startupData->m_starterOriginPrivilegeData),
       std::move(startupData->m_workerClients));
 }
 
 }  // namespace blink