(WIP) Worker: Merge ParentFrameTaskRunners into TaskRunnerHelper

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

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */
 
 #include "core/workers/WorkerThread.h"
 
+#include <limits.h>
+#include <memory>
 #include "bindings/core/v8/Microtask.h"
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/WorkerOrWorkletScriptController.h"
+#include "core/dom/TaskRunnerHelper.h"
 #include "core/inspector/ConsoleMessageStorage.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorTaskRunner.h"
 #include "core/inspector/WorkerInspectorController.h"
 #include "core/inspector/WorkerThreadDebugger.h"
 #include "core/origin_trials/OriginTrialContext.h"
 #include "core/workers/ThreadedWorkletGlobalScope.h"
 #include "core/workers/WorkerBackingThread.h"
 #include "core/workers/WorkerClients.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerReportingProxy.h"
 #include "core/workers/WorkerThreadStartupData.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/Histogram.h"
 #include "platform/WaitableEvent.h"
 #include "platform/WebThreadSupportingGC.h"
 #include "platform/heap/SafePoint.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/weborigin/KURL.h"
 #include "wtf/Functional.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/Threading.h"
 #include "wtf/text/WTFString.h"
-#include <limits.h>
-#include <memory>
 
 namespace blink {
 
 using ExitCode = WorkerThread::ExitCode;
 
 // TODO(nhiroki): Adjust the delay based on UMA.
 const long long kForcibleTerminationDelayInMs = 2000;  // 2 secs
 
 static Mutex& threadSetMutex() {
   DEFINE_THREAD_SAFE_STATIC_LOCAL(Mutex, mutex, new Mutex);
@@ skipping 30 matching lines @@
 
   DCHECK_NE(ExitCode::NotTerminated, m_exitCode);
   DEFINE_THREAD_SAFE_STATIC_LOCAL(
       EnumerationHistogram, exitCodeHistogram,
       new EnumerationHistogram("WorkerThread.ExitCode",
                                static_cast<int>(ExitCode::LastEnum)));
   exitCodeHistogram.count(static_cast<int>(m_exitCode));
 }
 
 void WorkerThread::start(std::unique_ptr<WorkerThreadStartupData> startupData,
-                         ParentFrameTaskRunners* parentFrameTaskRunners) {
+                         FrameTaskRunnersHolder* frameTaskRunners) {
   DCHECK(isMainThread());
 
   if (m_requestedToStart)
     return;
 
   m_requestedToStart = true;
-  m_parentFrameTaskRunners = parentFrameTaskRunners;
+  m_frameTaskRunners = frameTaskRunners;
   workerBackingThread().backingThread().postTask(
-      BLINK_FROM_HERE, crossThreadBind(&WorkerThread::initializeOnWorkerThread,
-                                       crossThreadUnretained(this),
-                                       WTF::passed(std::move(startupData))));
+      BLINK_FROM_HERE,
+      crossThreadBind(&WorkerThread::initializeOnWorkerThread,
+                      crossThreadUnretained(this),
+                      WTF::passed(std::move(startupData)),
+                      wrapCrossThreadPersistent(frameTaskRunners)));
 }
 
 void WorkerThread::terminate() {
   DCHECK(isMainThread());
   terminateInternal(TerminationMode::Graceful);
 }
 
 void WorkerThread::terminateAndWait() {
   DCHECK(isMainThread());
 
@@ skipping 204 matching lines @@
     m_requestedToTerminate = true;
 
     if (shouldScheduleToTerminateExecution(lock)) {
       switch (mode) {
         case TerminationMode::Forcible:
           forciblyTerminateExecution(lock, ExitCode::SyncForciblyTerminated);
           break;
         case TerminationMode::Graceful:
           DCHECK(!m_forcibleTerminationTaskHandle.isActive());
           m_forcibleTerminationTaskHandle =
-              m_parentFrameTaskRunners->get(TaskType::UnspecedTimer)
+              m_frameTaskRunners->get(TaskType::UnspecedTimer)
                   ->postDelayedCancellableTask(
                       BLINK_FROM_HERE,
                       WTF::bind(&WorkerThread::mayForciblyTerminateExecution,
                                 WTF::unretained(this)),
                       m_forcibleTerminationDelayInMs);
           break;
       }
     }
   }
 
@@ skipping 68 matching lines @@
   // |m_requestedToTerminate| on the main thread or |m_threadState| on the
   // worker thread is safe as the flag is set only on the thread.
   if (isMainThread() && m_requestedToTerminate)
     return true;
   if (isCurrentThread() && m_threadState == ThreadState::ReadyToShutdown)
     return true;
   return false;
 }
 
 void WorkerThread::initializeOnWorkerThread(
-    std::unique_ptr<WorkerThreadStartupData> startupData) {
+    std::unique_ptr<WorkerThreadStartupData> startupData,
+    FrameTaskRunnersHolder* frameTaskRunners) {
   DCHECK(isCurrentThread());
   DCHECK_EQ(ThreadState::NotStarted, m_threadState);
 
   KURL scriptURL = startupData->m_scriptURL;
   String sourceCode = startupData->m_sourceCode;
   WorkerThreadStartMode startMode = startupData->m_startMode;
   std::unique_ptr<Vector<char>> cachedMetaData =
       std::move(startupData->m_cachedMetaData);
   V8CacheOptions v8CacheOptions =
       startupData->m_workerV8Settings.m_v8CacheOptions;
@@ skipping 10 matching lines @@
 
     // Optimize for memory usage instead of latency for the worker isolate.
     isolate()->IsolateInBackgroundNotification();
 
     if (heapLimitIncreasedForDebugging) {
       isolate()->IncreaseHeapLimitForDebugging();
     }
 
     m_consoleMessageStorage = new ConsoleMessageStorage();
     m_globalScope = createWorkerGlobalScope(std::move(startupData));
+    FrameTaskRunnerHelper::setTaskRunners(globalScope(), frameTaskRunners);
     m_workerReportingProxy.didCreateWorkerGlobalScope(globalScope());
     m_workerInspectorController = WorkerInspectorController::create(this);
 
     // TODO(nhiroki): Handle a case where the script controller fails to
     // initialize the context.
     if (globalScope()->scriptController()->initializeContextIfNeeded()) {
       m_workerReportingProxy.didInitializeWorkerContext();
       v8::HandleScope handleScope(isolate());
       Platform::current()->workerContextCreated(
           globalScope()->scriptController()->context());
@@ skipping 168 matching lines @@
   MutexLocker lock(m_threadStateMutex);
   return m_requestedToTerminate;
 }
 
 ExitCode WorkerThread::getExitCodeForTesting() {
   MutexLocker lock(m_threadStateMutex);
   return m_exitCode;
 }
 
 }  // namespace blink