Revert of Worker: Introduce per-global-scope task scheduler

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
@@ skipping 13 matching lines @@
  *
  */
 
 #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/InspectorTaskRunner.h"
 #include "core/inspector/WorkerInspectorController.h"
 #include "core/inspector/WorkerThreadDebugger.h"
 #include "core/origin_trials/OriginTrialContext.h"
 #include "core/probe/CoreProbes.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/scheduler/child/webthread_impl_for_worker_scheduler.h"
-#include "platform/scheduler/child/worker_global_scope_scheduler.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/wtf/Functional.h"
 #include "platform/wtf/Noncopyable.h"
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/Threading.h"
 #include "platform/wtf/text/WTFString.h"
 
 namespace blink {
 
 using ExitCode = WorkerThread::ExitCode;
@@ skipping 38 matching lines @@
   DEFINE_THREAD_SAFE_STATIC_LOCAL(
       EnumerationHistogram, exit_code_histogram,
       new EnumerationHistogram("WorkerThread.ExitCode",
                                static_cast<int>(ExitCode::kLastEnum)));
   exit_code_histogram.Count(static_cast<int>(exit_code_));
 }
 
 void WorkerThread::Start(std::unique_ptr<WorkerThreadStartupData> startup_data,
                          ParentFrameTaskRunners* parent_frame_task_runners) {
   DCHECK(IsMainThread());
+
   if (requested_to_start_)
     return;
 
   requested_to_start_ = true;
   parent_frame_task_runners_ = parent_frame_task_runners;
-
-  // Synchronously initialize the per-global-scope scheduler to prevent someone
-  // from posting a task to the thread before the scheduler is ready.
-  WaitableEvent waitable_event;
-  GetWorkerBackingThread().BackingThread().PostTask(
-      BLINK_FROM_HERE,
-      CrossThreadBind(&WorkerThread::InitializeSchedulerOnWorkerThread,
-                      CrossThreadUnretained(this),
-                      CrossThreadUnretained(&waitable_event)));
-  waitable_event.Wait();
-
   GetWorkerBackingThread().BackingThread().PostTask(
       BLINK_FROM_HERE, CrossThreadBind(&WorkerThread::InitializeOnWorkerThread,
                                        CrossThreadUnretained(this),
                                        WTF::Passed(std::move(startup_data))));
 }
 
 void WorkerThread::Terminate() {
   DCHECK(IsMainThread());
   TerminateInternal(TerminationMode::kGraceful);
 }
@@ skipping 57 matching lines @@
 }
 
 v8::Isolate* WorkerThread::GetIsolate() {
   return GetWorkerBackingThread().GetIsolate();
 }
 
 bool WorkerThread::IsCurrentThread() {
   return GetWorkerBackingThread().BackingThread().IsCurrentThread();
 }
 
+void WorkerThread::PostTask(const WebTraceLocation& location,
+                            std::unique_ptr<WTF::Closure> task) {
+  DCHECK(IsCurrentThread());
+  if (IsInShutdown())
+    return;
+  GetWorkerBackingThread().BackingThread().PostTask(
+      location,
+      WTF::Bind(
+          &WorkerThread::PerformTaskOnWorkerThread<WTF::kSameThreadAffinity>,
+          WTF::Unretained(this), WTF::Passed(std::move(task))));
+}
+
+void WorkerThread::PostTask(const WebTraceLocation& location,
+                            std::unique_ptr<WTF::CrossThreadClosure> task) {
+  if (IsInShutdown())
+    return;
+  GetWorkerBackingThread().BackingThread().PostTask(
+      location,
+      CrossThreadBind(
+          &WorkerThread::PerformTaskOnWorkerThread<WTF::kCrossThreadAffinity>,
+          CrossThreadUnretained(this), WTF::Passed(std::move(task))));
+}
+
 void WorkerThread::AppendDebuggerTask(
     std::unique_ptr<CrossThreadClosure> task) {
   DCHECK(IsMainThread());
-  if (requested_to_terminate_)
+  if (IsInShutdown())
     return;
   inspector_task_runner_->AppendTask(CrossThreadBind(
       &WorkerThread::PerformDebuggerTaskOnWorkerThread,
       CrossThreadUnretained(this), WTF::Passed(std::move(task))));
   {
     MutexLocker lock(thread_state_mutex_);
     if (GetIsolate() && thread_state_ != ThreadState::kReadyToShutdown)
       inspector_task_runner_->InterruptAndRunAllTasksDontWait(GetIsolate());
   }
-  TaskRunnerHelper::Get(TaskType::kUnthrottled, this)
-      ->PostTask(BLINK_FROM_HERE,
-                 CrossThreadBind(
-                     &WorkerThread::PerformDebuggerTaskDontWaitOnWorkerThread,
-                     CrossThreadUnretained(this)));
+  GetWorkerBackingThread().BackingThread().PostTask(
+      BLINK_FROM_HERE,
+      CrossThreadBind(&WorkerThread::PerformDebuggerTaskDontWaitOnWorkerThread,
+                      CrossThreadUnretained(this)));
 }
 
 void WorkerThread::StartRunningDebuggerTasksOnPauseOnWorkerThread() {
   DCHECK(IsCurrentThread());
   if (worker_inspector_controller_)
     worker_inspector_controller_->FlushProtocolNotifications();
   paused_in_debugger_ = true;
   ThreadDebugger::IdleStarted(GetIsolate());
   std::unique_ptr<CrossThreadClosure> task;
   do {
@@ skipping 180 matching lines @@
   DCHECK(IsThreadStateMutexLocked(lock));
 
   DCHECK(exit_code == ExitCode::kSyncForciblyTerminated ||
          exit_code == ExitCode::kAsyncForciblyTerminated);
   SetExitCode(lock, exit_code);
 
   GetIsolate()->TerminateExecution();
   forcible_termination_task_handle_.Cancel();
 }
 
-void WorkerThread::InitializeSchedulerOnWorkerThread(
-    WaitableEvent* waitable_event) {
-  DCHECK(IsCurrentThread());
-  DCHECK(!global_scope_scheduler_);
-  scheduler::WebThreadImplForWorkerScheduler& web_thread_for_worker =
-      static_cast<scheduler::WebThreadImplForWorkerScheduler&>(
-          GetWorkerBackingThread().BackingThread().PlatformThread());
-  global_scope_scheduler_ =
-      WTF::MakeUnique<scheduler::WorkerGlobalScopeScheduler>(
-          web_thread_for_worker.GetWorkerScheduler());
-  waitable_event->Signal();
+bool WorkerThread::IsInShutdown() {
+  // Check if we've started termination or shutdown sequence. Avoid acquiring
+  // a lock here to avoid introducing a risk of deadlock. Note that accessing
+  // |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() && requested_to_terminate_)
+    return true;
+  if (IsCurrentThread() && thread_state_ == ThreadState::kReadyToShutdown)
+    return true;
+  return false;
 }
 
 void WorkerThread::InitializeOnWorkerThread(
     std::unique_ptr<WorkerThreadStartupData> startup_data) {
   DCHECK(IsCurrentThread());
   DCHECK_EQ(ThreadState::kNotStarted, thread_state_);
 
   KURL script_url = startup_data->script_url_;
   String source_code = startup_data->source_code_;
   WorkerThreadStartMode start_mode = startup_data->start_mode_;
@@ skipping 76 matching lines @@
   inspector_task_runner_->Kill();
   GetWorkerReportingProxy().WillDestroyWorkerGlobalScope();
   probe::AllAsyncTasksCanceled(GlobalScope());
 
   GlobalScope()->NotifyContextDestroyed();
   if (worker_inspector_controller_) {
     worker_inspector_controller_->Dispose();
     worker_inspector_controller_.Clear();
   }
   GlobalScope()->Dispose();
-  global_scope_scheduler_->Dispose();
   console_message_storage_.Clear();
   GetWorkerBackingThread().BackingThread().RemoveTaskObserver(this);
 }
 
 void WorkerThread::PerformShutdownOnWorkerThread() {
   DCHECK(IsCurrentThread());
   DCHECK(CheckRequestedToTerminateOnWorkerThread());
   DCHECK_EQ(ThreadState::kReadyToShutdown, thread_state_);
 
   // The below assignment will destroy the context, which will in turn notify
   // messaging proxy. We cannot let any objects survive past thread exit,
   // because no other thread will run GC or otherwise destroy them. If Oilpan
   // is enabled, we detach of the context/global scope, with the final heap
   // cleanup below sweeping it out.
   global_scope_ = nullptr;
 
   if (IsOwningBackingThread())
     GetWorkerBackingThread().Shutdown();
   // We must not touch workerBackingThread() from now on.
 
   // Notify the proxy that the WorkerOrWorkletGlobalScope has been disposed
   // of. This can free this thread object, hence it must not be touched
   // afterwards.
   GetWorkerReportingProxy().DidTerminateWorkerThread();
 
   shutdown_event_->Signal();
 }
 
+template <WTF::FunctionThreadAffinity threadAffinity>
+void WorkerThread::PerformTaskOnWorkerThread(
+    std::unique_ptr<Function<void(), threadAffinity>> task) {
+  DCHECK(IsCurrentThread());
+  if (thread_state_ != ThreadState::kRunning)
+    return;
+
+  {
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(
+        CustomCountHistogram, scoped_us_counter,
+        new CustomCountHistogram("WorkerThread.Task.Time", 0, 10000000, 50));
+    ScopedUsHistogramTimer timer(scoped_us_counter);
+    (*task)();
+  }
+}
+
 void WorkerThread::PerformDebuggerTaskOnWorkerThread(
     std::unique_ptr<CrossThreadClosure> task) {
   DCHECK(IsCurrentThread());
   InspectorTaskRunner::IgnoreInterruptsScope scope(
       inspector_task_runner_.get());
   {
     MutexLocker lock(thread_state_mutex_);
     DCHECK_EQ(ThreadState::kRunning, thread_state_);
     running_debugger_task_ = true;
   }
@@ skipping 66 matching lines @@
   MutexLocker lock(thread_state_mutex_);
   return requested_to_terminate_;
 }
 
 ExitCode WorkerThread::GetExitCodeForTesting() {
   MutexLocker lock(thread_state_mutex_);
   return exit_code_;
 }
 
 }  // namespace blink