(WIP) Worker: Merge ParentFrameTaskRunners into TaskRunnerHelper

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

 /*
  * 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
@@ skipping 12 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */
 
 #ifndef WorkerThread_h
 #define WorkerThread_h
 
 #include <memory>
 
 #include "core/CoreExport.h"
+#include "core/dom/TaskRunnerHelper.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
-#include "core/workers/ParentFrameTaskRunners.h"
 #include "core/workers/WorkerLoaderProxy.h"
 #include "core/workers/WorkerThreadLifecycleObserver.h"
 #include "platform/LifecycleNotifier.h"
 #include "platform/WaitableEvent.h"
 #include "platform/WebTaskRunner.h"
 #include "public/platform/WebThread.h"
 #include "v8/include/v8.h"
 #include "wtf/Forward.h"
 #include "wtf/Functional.h"
 #include "wtf/PassRefPtr.h"
@@ skipping 55 matching lines @@
     NotTerminated,
     GracefullyTerminated,
     SyncForciblyTerminated,
     AsyncForciblyTerminated,
     LastEnum,
   };
 
   virtual ~WorkerThread();
 
   // Called on the main thread.
-  void start(std::unique_ptr<WorkerThreadStartupData>, ParentFrameTaskRunners*);
+  void start(std::unique_ptr<WorkerThreadStartupData>, FrameTaskRunnersHolder*);
   void terminate();
 
   // Called on the main thread. Internally calls terminateInternal() and wait
   // (by *blocking* the calling thread) until the worker(s) is/are shut down.
   void terminateAndWait();
   static void terminateAndWaitForAllWorkers();
 
   // WebThread::TaskObserver.
   void willProcessTask() override;
   void didProcessTask() override;
@@ skipping 43 matching lines @@
   static HashSet<WorkerThread*>& workerThreads();
 
   int getWorkerThreadId() const { return m_workerThreadId; }
 
   PlatformThreadId platformThreadId();
 
   bool isForciblyTerminated();
 
   void waitForShutdownForTesting() { m_shutdownEvent->wait(); }
 
-  ParentFrameTaskRunners* getParentFrameTaskRunners() const {
-    return m_parentFrameTaskRunners.get();
-  }
-
  protected:
   WorkerThread(PassRefPtr<WorkerLoaderProxy>, WorkerReportingProxy&);
 
   // Factory method for creating a new worker context for the thread.
   // Called on the worker thread.
   virtual WorkerOrWorkletGlobalScope* createWorkerGlobalScope(
       std::unique_ptr<WorkerThreadStartupData>) = 0;
 
   // Returns true when this WorkerThread owns the associated
   // WorkerBackingThread exclusively. If this function returns true, the
@@ skipping 53 matching lines @@
   // Forcibly terminates the worker execution. This must be called with
   // |m_threadStateMutex| acquired.
   void forciblyTerminateExecution(const MutexLocker&, ExitCode);
 
   // Returns true if termination or shutdown sequence has started. This is
   // thread safe.
   // Note that this returns false when the sequence has already started but it
   // hasn't been notified to the calling thread.
   bool isInShutdown();
 
-  void initializeOnWorkerThread(std::unique_ptr<WorkerThreadStartupData>);
+  void initializeOnWorkerThread(std::unique_ptr<WorkerThreadStartupData>,
+                                FrameTaskRunnersHolder*);
   void prepareForShutdownOnWorkerThread();
   void performShutdownOnWorkerThread();
   void performTaskOnWorkerThread(std::unique_ptr<CrossThreadClosure>);
   void performDebuggerTaskOnWorkerThread(std::unique_ptr<CrossThreadClosure>);
   void performDebuggerTaskDontWaitOnWorkerThread();
 
   // These must be called with |m_threadStateMutex| acquired.
   void setThreadState(const MutexLocker&, ThreadState);
   void setExitCode(const MutexLocker&, ExitCode);
   bool isThreadStateMutexLocked(const MutexLocker&);
@@ skipping 22 matching lines @@
 
   ThreadState m_threadState = ThreadState::NotStarted;
   ExitCode m_exitCode = ExitCode::NotTerminated;
 
   long long m_forcibleTerminationDelayInMs;
 
   std::unique_ptr<InspectorTaskRunner> m_inspectorTaskRunner;
 
   RefPtr<WorkerLoaderProxy> m_workerLoaderProxy;
   WorkerReportingProxy& m_workerReportingProxy;
-  CrossThreadPersistent<ParentFrameTaskRunners> m_parentFrameTaskRunners;
+  Persistent<FrameTaskRunnersHolder> m_frameTaskRunners;
 
   // This lock protects |m_globalScope|, |m_requestedToTerminate|,
   // |m_threadState|, |m_runningDebuggerTask| and |m_exitCode|.
   Mutex m_threadStateMutex;
 
   CrossThreadPersistent<ConsoleMessageStorage> m_consoleMessageStorage;
   CrossThreadPersistent<WorkerOrWorkletGlobalScope> m_globalScope;
   CrossThreadPersistent<WorkerInspectorController> m_workerInspectorController;
 
   // Signaled when the thread completes termination on the worker thread.
   std::unique_ptr<WaitableEvent> m_shutdownEvent;
 
   // Used to cancel a scheduled forcible termination task. See
   // mayForciblyTerminateExecution() for details.
   TaskHandle m_forcibleTerminationTaskHandle;
 
   // Created on the main thread heap, but will be accessed cross-thread
   // when worker thread posts tasks.
   CrossThreadPersistent<WorkerThreadLifecycleContext>
       m_workerThreadLifecycleContext;
 };
 
 }  // namespace blink
 
 #endif  // WorkerThread_h