Worker: Remove unnecessary functions from worklet thread management

For evolution of worklet thread management there're some dead or duplicate
functions in worklet codebase. This CL removes them for cleanup.

Bug: n/a
Change-Id: I744146854e7f1cbcbb1a48cc60bac6cae34cad35
Reviewed-on: https://chromium-review.googlesource.com/c/1257475Reviewed-by: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Hiroki Nakagawa <nhiroki@chromium.org>
Cr-Commit-Position: refs/heads/master@{#596194}

third_party/blink/renderer/core/workers/threaded_worklet_test.cc

@@ -72,7 +72,7 @@ class ThreadedWorkletThreadForTest : public WorkerThread {
 
   static void EnsureSharedBackingThread() {
     DCHECK(IsMainThread());
-    WorkletThreadHolder<ThreadedWorkletThreadForTest>::CreateForTest(
+    WorkletThreadHolder<ThreadedWorkletThreadForTest>::EnsureInstance(
         WebThreadCreationParams(WebThreadType::kTestThread)
             .SetThreadNameForTest("ThreadedWorkletThreadForTest"));
   }

third_party/blink/renderer/core/workers/worker_backing_thread.cc

@@ -61,12 +61,7 @@ void SetRAILModeOnWorkerThreadIsolates(v8::RAILMode rail_mode) {
 }
 
 WorkerBackingThread::WorkerBackingThread(const WebThreadCreationParams& params)
-    : backing_thread_(WebThreadSupportingGC::Create(params)),
-      is_owning_thread_(true) {}
-
-WorkerBackingThread::WorkerBackingThread(WebThread* thread)
-    : backing_thread_(WebThreadSupportingGC::CreateForThread(thread)),
-      is_owning_thread_(false) {}
+    : backing_thread_(WebThreadSupportingGC::Create(params)) {}
 
 WorkerBackingThread::~WorkerBackingThread() = default;
 
@@ -91,8 +86,7 @@ void WorkerBackingThread::InitializeOnBackingThread(
         isolate_, std::make_unique<V8IdleTaskRunner>(
                       BackingThread().PlatformThread().Scheduler()));
   }
-  if (is_owning_thread_)
-    Platform::Current()->DidStartWorkerThread();
+  Platform::Current()->DidStartWorkerThread();
 
   V8PerIsolateData::From(isolate_)->SetThreadDebugger(
       std::make_unique<WorkerThreadDebugger>(isolate_));
@@ -111,8 +105,7 @@ void WorkerBackingThread::InitializeOnBackingThread(
 
 void WorkerBackingThread::ShutdownOnBackingThread() {
   DCHECK(backing_thread_->IsCurrentThread());
-  if (is_owning_thread_)
-    Platform::Current()->WillStopWorkerThread();
+  Platform::Current()->WillStopWorkerThread();
 
   V8PerIsolateData::WillBeDestroyed(isolate_);
   V8GCController::ClearDOMWrappers(isolate_);

third_party/blink/renderer/core/workers/worker_backing_thread.h

@@ -16,7 +16,6 @@
 
 namespace blink {
 
-class WebThread;
 class WebThreadSupportingGC;
 struct WebThreadCreationParams;
 struct WorkerBackingThreadStartupData;
@@ -31,9 +30,6 @@ class CORE_EXPORT WorkerBackingThread final {
       const WebThreadCreationParams& params) {
     return base::WrapUnique(new WorkerBackingThread(params));
   }
-  static std::unique_ptr<WorkerBackingThread> Create(WebThread* thread) {
-    return base::WrapUnique(new WorkerBackingThread(thread));
-  }
 
   ~WorkerBackingThread();
 
@@ -58,11 +54,9 @@ class CORE_EXPORT WorkerBackingThread final {
 
  private:
   explicit WorkerBackingThread(const WebThreadCreationParams&);
-  explicit WorkerBackingThread(WebThread*);
 
   std::unique_ptr<WebThreadSupportingGC> backing_thread_;
   v8::Isolate* isolate_ = nullptr;
-  bool is_owning_thread_;
 };
 
 }  // namespace blink

third_party/blink/renderer/core/workers/worklet_thread_holder.h

@@ -33,29 +33,6 @@ class WorkletThreadHolder {
     thread_holder_instance_->Initialize(WorkerBackingThread::Create(params));
   }
 
-  static void EnsureInstance(WebThread* thread) {
-    DCHECK(IsMainThread());
-    MutexLocker locker(HolderInstanceMutex());
-    if (thread_holder_instance_)
-      return;
-    thread_holder_instance_ = new WorkletThreadHolder<DerivedWorkletThread>;
-    thread_holder_instance_->Initialize(WorkerBackingThread::Create(thread));
-  }
-
-  static void CreateForTest(const WebThreadCreationParams& params) {
-    MutexLocker locker(HolderInstanceMutex());
-    DCHECK(!thread_holder_instance_);
-    thread_holder_instance_ = new WorkletThreadHolder<DerivedWorkletThread>;
-    thread_holder_instance_->Initialize(WorkerBackingThread::Create(params));
-  }
-
-  static void CreateForTest(WebThread* thread) {
-    MutexLocker locker(HolderInstanceMutex());
-    DCHECK(!thread_holder_instance_);
-    thread_holder_instance_ = new WorkletThreadHolder<DerivedWorkletThread>;
-    thread_holder_instance_->Initialize(WorkerBackingThread::Create(thread));
-  }
-
   static void ClearInstance() {
     DCHECK(IsMainThread());
     MutexLocker locker(HolderInstanceMutex());
@@ -87,10 +64,8 @@ class WorkletThreadHolder {
 
   void InitializeOnWorkletThread() {
     MutexLocker locker(HolderInstanceMutex());
-    DCHECK(!initialized_);
     thread_->InitializeOnBackingThread(
         WorkerBackingThreadStartupData::CreateDefault());
-    initialized_ = true;
   }
 
   void ShutdownAndWait() {
@@ -110,7 +85,6 @@ class WorkletThreadHolder {
   }
 
   std::unique_ptr<WorkerBackingThread> thread_;
-  bool initialized_ = false;
 
   static WorkletThreadHolder<DerivedWorkletThread>* thread_holder_instance_;
 };

third_party/blink/renderer/modules/animationworklet/animation_worklet_global_scope_test.cc

@@ -57,7 +57,7 @@ class AnimationWorkletGlobalScopeTest : public PageTestBase {
   AnimationWorkletGlobalScopeTest() = default;
 
   void SetUp() override {
-    AnimationWorkletThread::CreateSharedBackingThreadForTest();
+    AnimationWorkletThread::EnsureSharedBackingThread();
     PageTestBase::SetUp(IntSize());
     Document* document = &GetDocument();
     document->SetURL(KURL("https://example.com/"));

third_party/blink/renderer/modules/animationworklet/animation_worklet_thread.cc

@@ -31,12 +31,6 @@ AnimationWorkletThread::AnimationWorkletThread(
 
 AnimationWorkletThread::~AnimationWorkletThread() = default;
 
-WebThread* AnimationWorkletThread::GetSharedBackingThread() {
-  auto* instance = WorkletThreadHolder<AnimationWorkletThread>::GetInstance();
-  DCHECK(instance);
-  return &(instance->GetThread()->BackingThread().PlatformThread());
-}
-
 WorkerBackingThread& AnimationWorkletThread::GetWorkerBackingThread() {
   return *WorkletThreadHolder<AnimationWorkletThread>::GetInstance()
               ->GetThread();
@@ -68,11 +62,6 @@ void AnimationWorkletThread::ClearSharedBackingThread() {
   WorkletThreadHolder<AnimationWorkletThread>::ClearInstance();
 }
 
-void AnimationWorkletThread::CreateSharedBackingThreadForTest() {
-  WorkletThreadHolder<AnimationWorkletThread>::CreateForTest(
-      WebThreadCreationParams(WebThreadType::kAnimationWorkletThread));
-}
-
 WorkerOrWorkletGlobalScope* AnimationWorkletThread::CreateWorkerGlobalScope(
     std::unique_ptr<GlobalScopeCreationParams> creation_params) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("animation-worklet"),

third_party/blink/renderer/modules/animationworklet/animation_worklet_thread.h

@@ -32,13 +32,6 @@ class MODULES_EXPORT AnimationWorkletThread final : public WorkerThread {
   static void EnsureSharedBackingThread();
   static void ClearSharedBackingThread();
 
-  static void CreateSharedBackingThreadForTest();
-
-  // This only can be called after EnsureSharedBackingThread() is performed.
-  // Currently AnimationWorkletThread owns only one thread and it is shared
-  // by all the customers.
-  static WebThread* GetSharedBackingThread();
-
  private:
   explicit AnimationWorkletThread(WorkerReportingProxy&);
 

third_party/blink/renderer/modules/animationworklet/animation_worklet_thread_test.cc

@@ -48,7 +48,7 @@ class TestAnimationWorkletProxyClient : public AnimationWorkletProxyClient {
 class AnimationWorkletThreadTest : public PageTestBase {
  public:
   void SetUp() override {
-    AnimationWorkletThread::CreateSharedBackingThreadForTest();
+    AnimationWorkletThread::EnsureSharedBackingThread();
     PageTestBase::SetUp(IntSize());
     Document* document = &GetDocument();
     document->SetURL(KURL("https://example.com/"));

third_party/blink/renderer/modules/webaudio/audio_worklet_global_scope_test.cc

@@ -55,7 +55,7 @@ static const size_t kRenderQuantumFrames = 128;
 class AudioWorkletGlobalScopeTest : public PageTestBase {
  public:
   void SetUp() override {
-    AudioWorkletThread::CreateSharedBackingThreadForTest();
+    AudioWorkletThread::EnsureSharedBackingThread();
     PageTestBase::SetUp(IntSize());
     Document* document = &GetDocument();
     document->SetURL(KURL("https://example.com/"));

third_party/blink/renderer/modules/webaudio/audio_worklet_thread.cc

@@ -82,18 +82,6 @@ void AudioWorkletThread::ClearSharedBackingThread() {
   WorkletThreadHolder<AudioWorkletThread>::ClearInstance();
 }
 
-WebThread* AudioWorkletThread::GetSharedBackingThread() {
-  DCHECK(IsMainThread());
-  WorkletThreadHolder<AudioWorkletThread>* instance =
-      WorkletThreadHolder<AudioWorkletThread>::GetInstance();
-  return &(instance->GetThread()->BackingThread().PlatformThread());
-}
-
-void AudioWorkletThread::CreateSharedBackingThreadForTest() {
-  WorkletThreadHolder<AudioWorkletThread>::CreateForTest(
-      WebThreadCreationParams(blink::WebThreadType::kWebAudioThread));
-}
-
 WorkerOrWorkletGlobalScope* AudioWorkletThread::CreateWorkerGlobalScope(
     std::unique_ptr<GlobalScopeCreationParams> creation_params) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("audio-worklet"),

third_party/blink/renderer/modules/webaudio/audio_worklet_thread.h

@@ -34,13 +34,6 @@ class MODULES_EXPORT AudioWorkletThread final : public WorkerThread {
   static void EnsureSharedBackingThread();
   static void ClearSharedBackingThread();
 
-  static void CreateSharedBackingThreadForTest();
-
-  // This only can be called after EnsureSharedBackingThread() is performed.
-  // Currently AudioWorkletThread owns only one thread and it is shared by all
-  // the customers.
-  static WebThread* GetSharedBackingThread();
-
  private:
   explicit AudioWorkletThread(WorkerReportingProxy&);
 

third_party/blink/renderer/modules/webaudio/audio_worklet_thread_test.cc

@@ -39,7 +39,7 @@ namespace blink {
 class AudioWorkletThreadTest : public PageTestBase {
  public:
   void SetUp() override {
-    AudioWorkletThread::CreateSharedBackingThreadForTest();
+    AudioWorkletThread::EnsureSharedBackingThread();
     PageTestBase::SetUp(IntSize());
     Document* document = &GetDocument();
     document->SetURL(KURL("https://example.com/"));