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

third_party/WebKit/Source/core/workers/ThreadedWorkletTest.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/inspector/ConsoleMessageStorage.h"
 #include "core/testing/DummyPageHolder.h"
 #include "core/workers/ThreadedWorkletGlobalScope.h"
 #include "core/workers/ThreadedWorkletMessagingProxy.h"
 #include "core/workers/ThreadedWorkletObjectProxy.h"
 #include "core/workers/WorkerInspectorProxy.h"
 #include "core/workers/WorkerThread.h"
 #include "core/workers/WorkerThreadStartupData.h"
 #include "core/workers/WorkerThreadTestHelper.h"
 #include "core/workers/WorkletThreadHolder.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
 class ThreadedWorkletThreadForTest : public WorkerThread {
  public:
   ThreadedWorkletThreadForTest(
       WorkerLoaderProxyProvider* workerLoaderProxyProvider,
-      WorkerReportingProxy& workerReportingProxy,
-      ParentFrameTaskRunners* parentFrameTaskRunners)
+      WorkerReportingProxy& workerReportingProxy)
       : WorkerThread(WorkerLoaderProxy::create(workerLoaderProxyProvider),
-                     workerReportingProxy,
-                     parentFrameTaskRunners) {}
+                     workerReportingProxy) {}
   ~ThreadedWorkletThreadForTest() override{};
 
   WorkerBackingThread& workerBackingThread() override {
     auto workletThreadHolder =
         WorkletThreadHolder<ThreadedWorkletThreadForTest>::getInstance();
     DCHECK(workletThreadHolder);
     return *workletThreadHolder->thread();
   }
 
   void clearWorkerBackingThread() override {}
@@ skipping 47 matching lines @@
 };
 
 class ThreadedWorkletMessagingProxyForTest
     : public ThreadedWorkletMessagingProxy {
  public:
   ThreadedWorkletMessagingProxyForTest(ExecutionContext* executionContext)
       : ThreadedWorkletMessagingProxy(executionContext) {
     m_mockWorkerLoaderProxyProvider =
         WTF::makeUnique<MockWorkerLoaderProxyProvider>();
     m_workerThread = WTF::makeUnique<ThreadedWorkletThreadForTest>(
-        m_mockWorkerLoaderProxyProvider.get(), workletObjectProxy(),
-        getParentFrameTaskRunners());
+        m_mockWorkerLoaderProxyProvider.get(), workletObjectProxy());
     ThreadedWorkletThreadForTest::ensureSharedBackingThread();
   }
 
   ~ThreadedWorkletMessagingProxyForTest() override {
     m_workerThread->workerLoaderProxy()->detachProvider(
         m_mockWorkerLoaderProxyProvider.get());
     m_workerThread->terminateAndWait();
     ThreadedWorkletThreadForTest::clearSharedBackingThread();
   };
 
   void start() {
     KURL scriptURL(ParsedURLString, "http://fake.url/");
     std::unique_ptr<Vector<char>> cachedMetaData = nullptr;
     Vector<CSPHeaderAndType> contentSecurityPolicyHeaders;
     String referrerPolicy = "";
     m_securityOrigin = SecurityOrigin::create(scriptURL);
     WorkerClients* workerClients = nullptr;
     Vector<String> originTrialTokens;
     std::unique_ptr<WorkerSettings> workerSettings = nullptr;
-    m_workerThread->start(WorkerThreadStartupData::create(
-        scriptURL, "fake user agent", "// fake source code",
-        std::move(cachedMetaData), DontPauseWorkerGlobalScopeOnStart,
-        &contentSecurityPolicyHeaders, referrerPolicy, m_securityOrigin.get(),
-        workerClients, WebAddressSpaceLocal, &originTrialTokens,
-        std::move(workerSettings), WorkerV8Settings::Default()));
+    m_workerThread->start(
+        WorkerThreadStartupData::create(
+            scriptURL, "fake user agent", "// fake source code",
+            std::move(cachedMetaData), DontPauseWorkerGlobalScopeOnStart,
+            &contentSecurityPolicyHeaders, referrerPolicy,
+            m_securityOrigin.get(), workerClients, WebAddressSpaceLocal,
+            &originTrialTokens, std::move(workerSettings),
+            WorkerV8Settings::Default()),
+        getParentFrameTaskRunners());
     workerInspectorProxy()->workerThreadCreated(
         toDocument(getExecutionContext()), m_workerThread.get(), scriptURL);
   }
 
  protected:
   std::unique_ptr<WorkerThread> createWorkerThread(double originTime) final {
     NOTREACHED();
     return nullptr;
   }
 
@@ skipping 53 matching lines @@
   EXPECT_FALSE(UseCounter::isCounted(document(), feature2));
   workerThread()->postTask(
       BLINK_FROM_HERE,
       crossThreadBind(&ThreadedWorkletThreadForTest::countDeprecation,
                       crossThreadUnretained(workerThread()), feature2));
   testing::enterRunLoop();
   EXPECT_TRUE(UseCounter::isCounted(document(), feature2));
 }
 
 }  // namespace blink