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

third_party/WebKit/Source/core/workers/DedicatedWorkerTest.cpp

 // 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 "core/events/MessageEvent.h"
 #include "core/inspector/ConsoleMessageStorage.h"
 #include "core/testing/DummyPageHolder.h"
 #include "core/workers/DedicatedWorkerGlobalScope.h"
 #include "core/workers/DedicatedWorkerThread.h"
 #include "core/workers/InProcessWorkerMessagingProxy.h"
@@ skipping 20 matching lines @@
 const double kDefaultIntervalInSec = 0.01;
 const double kNextIntervalInSec = 0.01;
 const double kMaxIntervalInSec = 0.02;
 
 }  // namespace
 
 class DedicatedWorkerThreadForTest final : public DedicatedWorkerThread {
  public:
   DedicatedWorkerThreadForTest(
       WorkerLoaderProxyProvider* workerLoaderProxyProvider,
-      InProcessWorkerObjectProxy& workerObjectProxy,
-      ParentFrameTaskRunners* parentFrameTaskRunners)
+      InProcessWorkerObjectProxy& workerObjectProxy)
       : DedicatedWorkerThread(
             WorkerLoaderProxy::create(workerLoaderProxyProvider),
             workerObjectProxy,
-            parentFrameTaskRunners,
             monotonicallyIncreasingTime()) {
     m_workerBackingThread = WorkerBackingThread::createForTest("Test thread");
   }
 
   WorkerOrWorkletGlobalScope* createWorkerGlobalScope(
       std::unique_ptr<WorkerThreadStartupData> startupData) override {
     return new DedicatedWorkerGlobalScope(
         startupData->m_scriptURL, startupData->m_userAgent, this, m_timeOrigin,
         std::move(startupData->m_starterOriginPrivilegeData),
         std::move(startupData->m_workerClients));
@@ skipping 32 matching lines @@
       : InProcessWorkerMessagingProxy(executionContext,
                                       nullptr /* workerObject */,
                                       nullptr /* workerClients */) {
     workerObjectProxy().m_defaultIntervalInSec = kDefaultIntervalInSec;
     workerObjectProxy().m_nextIntervalInSec = kNextIntervalInSec;
     workerObjectProxy().m_maxIntervalInSec = kMaxIntervalInSec;
 
     m_mockWorkerLoaderProxyProvider =
         WTF::makeUnique<MockWorkerLoaderProxyProvider>();
     m_workerThread = WTF::wrapUnique(new DedicatedWorkerThreadForTest(
-        m_mockWorkerLoaderProxyProvider.get(), workerObjectProxy(),
-        getParentFrameTaskRunners()));
+        m_mockWorkerLoaderProxyProvider.get(), workerObjectProxy()));
     m_mockWorkerThreadLifecycleObserver = new MockWorkerThreadLifecycleObserver(
         m_workerThread->getWorkerThreadLifecycleContext());
     EXPECT_CALL(*m_mockWorkerThreadLifecycleObserver,
                 contextDestroyed(::testing::_))
         .Times(1);
   }
 
   ~InProcessWorkerMessagingProxyForTest() override {
     EXPECT_FALSE(m_blocking);
     m_workerThread->workerLoaderProxy()->detachProvider(
         m_mockWorkerLoaderProxyProvider.get());
   }
 
   void startWithSourceCode(const String& source) {
     KURL scriptURL(ParsedURLString, "http://fake.url/");
     m_securityOrigin = SecurityOrigin::create(scriptURL);
     std::unique_ptr<Vector<CSPHeaderAndType>> headers =
         WTF::makeUnique<Vector<CSPHeaderAndType>>();
     CSPHeaderAndType headerAndType("contentSecurityPolicy",
                                    ContentSecurityPolicyHeaderTypeReport);
     headers->push_back(headerAndType);
-    workerThread()->start(WorkerThreadStartupData::create(
-        scriptURL, "fake user agent", source, nullptr /* cachedMetaData */,
-        DontPauseWorkerGlobalScopeOnStart, headers.get(),
-        "" /* referrerPolicy */, m_securityOrigin.get(),
-        nullptr /* workerClients */, WebAddressSpaceLocal,
-        nullptr /* originTrialTokens */, nullptr /* workerSettings */,
-        WorkerV8Settings::Default()));
+    workerThread()->start(
+        WorkerThreadStartupData::create(
+            scriptURL, "fake user agent", source, nullptr /* cachedMetaData */,
+            DontPauseWorkerGlobalScopeOnStart, headers.get(),
+            "" /* referrerPolicy */, m_securityOrigin.get(),
+            nullptr /* workerClients */, WebAddressSpaceLocal,
+            nullptr /* originTrialTokens */, nullptr /* workerSettings */,
+            WorkerV8Settings::Default()),
+        getParentFrameTaskRunners());
 
     workerInspectorProxy()->workerThreadCreated(
         toDocument(getExecutionContext()), m_workerThread.get(), scriptURL);
     workerThreadCreated();
   }
 
   enum class Notification {
     MessageConfirmed,
     PendingActivityReported,
     ThreadTerminated,
@@ skipping 261 matching lines @@
   EXPECT_FALSE(UseCounter::isCounted(document(), feature2));
   workerThread()->postTask(
       BLINK_FROM_HERE,
       crossThreadBind(&DedicatedWorkerThreadForTest::countDeprecation,
                       crossThreadUnretained(workerThread()), feature2));
   testing::enterRunLoop();
   EXPECT_TRUE(UseCounter::isCounted(document(), feature2));
 }
 
 }  // namespace blink