Worker: Introduce per-global-scope task scheduler

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 19 matching lines @@
 #include <memory>
 
 #include "core/CoreExport.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 "platform/scheduler/child/worker_global_scope_scheduler.h"
 #include "platform/wtf/Forward.h"
 #include "platform/wtf/Functional.h"
 #include "platform/wtf/PassRefPtr.h"
 #include "public/platform/WebThread.h"
 #include "v8/include/v8.h"
 
 namespace blink {
 
 class ConsoleMessageStorage;
 class InspectorTaskRunner;
@@ skipping 35 matching lines @@
 //
 // WorkerThread start and termination must be initiated on the main thread and
 // an actual task is executed on the worker thread.
 //
 // When termination starts, (debugger) tasks on WorkerThread are handled as
 // follows:
 //  - A running task may finish unless a forcible termination task interrupts.
 //    If the running task is for debugger, it's guaranteed to finish without
 //    any interruptions.
 //  - Queued tasks never run.
-//  - postTask() and appendDebuggerTask() reject posting new tasks.
 class CORE_EXPORT WorkerThread : public WebThread::TaskObserver {
  public:
   // Represents how this thread is terminated. Used for UMA. Append only.
   enum class ExitCode {
     kNotTerminated,
     kGracefullyTerminated,
     kSyncForciblyTerminated,
     kAsyncForciblyTerminated,
     kLastEnum,
   };
@@ skipping 24 matching lines @@
 
   WorkerLoaderProxy* GetWorkerLoaderProxy() const {
     RELEASE_ASSERT(worker_loader_proxy_);
     return worker_loader_proxy_.Get();
   }
 
   WorkerReportingProxy& GetWorkerReportingProxy() const {
     return worker_reporting_proxy_;
   }
 
-  void PostTask(const WebTraceLocation&, std::unique_ptr<WTF::Closure>);
-  void PostTask(const WebTraceLocation&,
-                std::unique_ptr<WTF::CrossThreadClosure>);
   void AppendDebuggerTask(std::unique_ptr<CrossThreadClosure>);
 
   // Runs only debugger tasks while paused in debugger.
   void StartRunningDebuggerTasksOnPauseOnWorkerThread();
   void StopRunningDebuggerTasksOnPauseOnWorkerThread();
 
   // Can be called only on the worker thread, WorkerOrWorkletGlobalScope
   // and WorkerInspectorController are not thread safe.
   WorkerOrWorkletGlobalScope* GlobalScope();
   WorkerInspectorController* GetWorkerInspectorController();
@@ skipping 16 matching lines @@
   PlatformThreadId GetPlatformThreadId();
 
   bool IsForciblyTerminated();
 
   void WaitForShutdownForTesting() { shutdown_event_->Wait(); }
 
   ParentFrameTaskRunners* GetParentFrameTaskRunners() const {
     return parent_frame_task_runners_.Get();
   }
 
+  scheduler::WorkerGlobalScopeScheduler* GetGlobalScopeScheduler() const {
+    return global_scope_scheduler_.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 47 matching lines @@
   // thread. This task is expected to run when the shutdown sequence does not
   // start in a certain time period because of an inifite loop in the JS
   // execution context etc. When the shutdown sequence is started before this
   // task runs, the task is simply cancelled.
   void MayForciblyTerminateExecution();
 
   // 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 InitializeSchedulerOnWorkerThread(WaitableEvent*);
   void InitializeOnWorkerThread(std::unique_ptr<WorkerThreadStartupData>);
   void PrepareForShutdownOnWorkerThread();
   void PerformShutdownOnWorkerThread();
   template <WTF::FunctionThreadAffinity threadAffinity>
   void PerformTaskOnWorkerThread(
       std::unique_ptr<Function<void(), threadAffinity>> task);
   void PerformDebuggerTaskOnWorkerThread(std::unique_ptr<CrossThreadClosure>);
   void PerformDebuggerTaskDontWaitOnWorkerThread();
 
   // These must be called with |m_threadStateMutex| acquired.
@@ skipping 25 matching lines @@
 
   ThreadState thread_state_ = ThreadState::kNotStarted;
   ExitCode exit_code_ = ExitCode::kNotTerminated;
 
   long long forcible_termination_delay_in_ms_;
 
   std::unique_ptr<InspectorTaskRunner> inspector_task_runner_;
 
   RefPtr<WorkerLoaderProxy> worker_loader_proxy_;
   WorkerReportingProxy& worker_reporting_proxy_;
+
   CrossThreadPersistent<ParentFrameTaskRunners> parent_frame_task_runners_;
 
+  // Tasks managed by this scheduler are canceled when the global scope is
+  // closed.
+  std::unique_ptr<scheduler::WorkerGlobalScopeScheduler>
+      global_scope_scheduler_;
+
   // This lock protects |m_globalScope|, |m_requestedToTerminate|,
   // |m_threadState|, |m_runningDebuggerTask| and |m_exitCode|.
   Mutex thread_state_mutex_;
 
   CrossThreadPersistent<ConsoleMessageStorage> console_message_storage_;
   CrossThreadPersistent<WorkerOrWorkletGlobalScope> global_scope_;
   CrossThreadPersistent<WorkerInspectorController> worker_inspector_controller_;
 
   // Signaled when the thread completes termination on the worker thread.
   std::unique_ptr<WaitableEvent> shutdown_event_;
 
   // Used to cancel a scheduled forcible termination task. See
   // mayForciblyTerminateExecution() for details.
   TaskHandle forcible_termination_task_handle_;
 
   // Created on the main thread heap, but will be accessed cross-thread
   // when worker thread posts tasks.
   CrossThreadPersistent<WorkerThreadLifecycleContext>
       worker_thread_lifecycle_context_;
 };
 
 }  // namespace blink
 
 #endif  // WorkerThread_h