(WIP) Worker: Merge ParentFrameTaskRunners into TaskRunnerHelper

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"
@@ skipping 45 matching lines @@
 
   static void clearSharedBackingThread() {
     DCHECK(isMainThread());
     WorkletThreadHolder<ThreadedWorkletThreadForTest>::clearInstance();
   }
 
   // Emulates API use on ThreadedWorkletGlobalScope.
   void countFeature(UseCounter::Feature feature) {
     EXPECT_TRUE(isCurrentThread());
     globalScope()->countFeature(feature);
-    getParentFrameTaskRunners()
-        ->get(TaskType::UnspecedTimer)
+    FrameTaskRunnerHelper::get(TaskType::UnspecedTimer, globalScope())
         ->postTask(BLINK_FROM_HERE, crossThreadBind(&testing::exitRunLoop));
   }
 
   // Emulates deprecated API use on ThreadedWorkletGlobalScope.
   void countDeprecation(UseCounter::Feature feature) {
     EXPECT_TRUE(isCurrentThread());
     EXPECT_EQ(0u, consoleMessageStorage()->size());
     globalScope()->countDeprecation(feature);
 
     // countDeprecation() should add a warning message.
     EXPECT_EQ(1u, consoleMessageStorage()->size());
     String consoleMessage = consoleMessageStorage()->at(0)->message();
     EXPECT_TRUE(consoleMessage.contains("deprecated"));
 
-    getParentFrameTaskRunners()
-        ->get(TaskType::UnspecedTimer)
+    FrameTaskRunnerHelper::get(TaskType::UnspecedTimer, globalScope())
         ->postTask(BLINK_FROM_HERE, crossThreadBind(&testing::exitRunLoop));
   }
 };
 
 class ThreadedWorkletMessagingProxyForTest
     : public ThreadedWorkletMessagingProxy {
  public:
   ThreadedWorkletMessagingProxyForTest(ExecutionContext* executionContext)
       : ThreadedWorkletMessagingProxy(executionContext) {
     m_mockWorkerLoaderProxyProvider =
         WTF::makeUnique<MockWorkerLoaderProxyProvider>();
     m_workerThread = WTF::makeUnique<ThreadedWorkletThreadForTest>(
         m_mockWorkerLoaderProxyProvider.get(), workletObjectProxy());
     ThreadedWorkletThreadForTest::ensureSharedBackingThread();
   }
 
   ~ThreadedWorkletMessagingProxyForTest() override {
     m_workerThread->workerLoaderProxy()->detachProvider(
         m_mockWorkerLoaderProxyProvider.get());
     m_workerThread->terminateAndWait();
     ThreadedWorkletThreadForTest::clearSharedBackingThread();
   };
 
-  void start() {
+  void start(Document& document) {
     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()),
-        getParentFrameTaskRunners());
+        FrameTaskRunnersHolder::create(document.frame()));
     workerInspectorProxy()->workerThreadCreated(
         toDocument(getExecutionContext()), m_workerThread.get(), scriptURL);
   }
 
  protected:
   std::unique_ptr<WorkerThread> createWorkerThread(double originTime) final {
     NOTREACHED();
     return nullptr;
   }
 
@@ skipping 23 matching lines @@
   }
 
   Document& document() { return m_page->document(); }
 
  private:
   std::unique_ptr<DummyPageHolder> m_page;
   std::unique_ptr<ThreadedWorkletMessagingProxyForTest> m_messagingProxy;
 };
 
 TEST_F(ThreadedWorkletTest, UseCounter) {
-  messagingProxy()->start();
+  messagingProxy()->start(document());
 
   // This feature is randomly selected.
   const UseCounter::Feature feature1 = UseCounter::Feature::RequestFileSystem;
 
   // API use on the DedicatedWorkerGlobalScope should be recorded in UseCounter
   // on the Document.
   EXPECT_FALSE(UseCounter::isCounted(document(), feature1));
   workerThread()->postTask(
       BLINK_FROM_HERE,
       crossThreadBind(&ThreadedWorkletThreadForTest::countFeature,
                       crossThreadUnretained(workerThread()), feature1));
   testing::enterRunLoop();
   EXPECT_TRUE(UseCounter::isCounted(document(), feature1));
 
   // This feature is randomly selected from Deprecation::deprecationMessage().
   const UseCounter::Feature feature2 = UseCounter::Feature::PrefixedStorageInfo;
 
   // Deprecated API use on the ThreadedWorkletGlobalScope should be recorded in
   // UseCounter on the Document.
   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