Migrate WebThreadSupportingGC from using CrossThreadBind

... in favor of CrossThreadBindOnce.

Reasoning: this method schedules a task that runs once.
Hence, coneptually CrossThreadBindOnce is the bind helper to be used.

BUG=963574
R=haraken@chromium.org, hiroshige@chromium.org

Change-Id: I0c1eede1ecbffeea3a14bacbd81fff40ce702712
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1619826
Commit-Queue: Antonio Gomes <tonikitoo@igalia.com>
Commit-Queue: Kentaro Hara <haraken@chromium.org>
Auto-Submit: Antonio Gomes <tonikitoo@igalia.com>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#661357}

third_party/blink/renderer/bindings/core/v8/dom_wrapper_world_test.cc

@@ -119,9 +119,9 @@ TEST(DOMWrapperWorldTest, Basic) {
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
       Thread::Current()->GetTaskRunner();
   thread->BackingThread().PostTask(
-      FROM_HERE,
-      CrossThreadBind(&WorkerThreadFunc, CrossThreadUnretained(thread.get()),
-                      std::move(main_thread_task_runner)));
+      FROM_HERE, CrossThreadBindOnce(&WorkerThreadFunc,
+                                     CrossThreadUnretained(thread.get()),
+                                     std::move(main_thread_task_runner)));
   test::EnterRunLoop();
 
   // Worlds on the worker thread should not be visible from the main thread.

third_party/blink/renderer/bindings/core/v8/serialization/serialized_script_value_threaded_test.cc

@@ -51,7 +51,7 @@ TEST(SerializedScriptValueThreadedTest,
   // Intentionally keep a reference on this thread while this occurs.
   worker_thread.GetWorkerBackingThread().BackingThread().PostTask(
       FROM_HERE,
-      CrossThreadBind(
+      CrossThreadBindOnce(
           [](WorkerThread* worker_thread,
              scoped_refptr<SerializedScriptValue> serialized) {
             WorkerOrWorkletScriptController* script =
@@ -71,8 +71,8 @@ TEST(SerializedScriptValueThreadedTest,
   // references held by the task are dropped.
   base::WaitableEvent done;
   worker_thread.GetWorkerBackingThread().BackingThread().PostTask(
-      FROM_HERE, CrossThreadBind(&base::WaitableEvent::Signal,
-                                 CrossThreadUnretained(&done)));
+      FROM_HERE, CrossThreadBindOnce(&base::WaitableEvent::Signal,
+                                     CrossThreadUnretained(&done)));
   done.Wait();
 
   // Now destroy the value on the main thread.

third_party/blink/renderer/core/css/cssom/cross_thread_style_value_test.cc

@@ -30,10 +30,10 @@ class CrossThreadStyleValueTest : public testing::Test {
 
   void ShutDownThread() {
     base::WaitableEvent waitable_event;
-    thread_->PostTask(FROM_HERE,
-                      CrossThreadBind(&CrossThreadStyleValueTest::ShutDown,
-                                      CrossThreadUnretained(this),
-                                      CrossThreadUnretained(&waitable_event)));
+    thread_->PostTask(
+        FROM_HERE, CrossThreadBindOnce(&CrossThreadStyleValueTest::ShutDown,
+                                       CrossThreadUnretained(this),
+                                       CrossThreadUnretained(&waitable_event)));
     waitable_event.Wait();
   }
 
@@ -83,10 +83,10 @@ TEST_F(CrossThreadStyleValueTest, PassUnsupportedValueCrossThread) {
   base::WaitableEvent waitable_event;
   thread_->PostTask(
       FROM_HERE,
-      CrossThreadBind(&CrossThreadStyleValueTest::CheckUnsupportedValue,
-                      CrossThreadUnretained(this),
-                      CrossThreadUnretained(&waitable_event),
-                      WTF::Passed(std::move(value))));
+      CrossThreadBindOnce(&CrossThreadStyleValueTest::CheckUnsupportedValue,
+                          CrossThreadUnretained(this),
+                          CrossThreadUnretained(&waitable_event),
+                          WTF::Passed(std::move(value))));
   waitable_event.Wait();
 
   ShutDownThread();
@@ -113,10 +113,11 @@ TEST_F(CrossThreadStyleValueTest, PassKeywordValueCrossThread) {
       ThreadCreationParams(WebThreadType::kTestThread));
   base::WaitableEvent waitable_event;
   thread_->PostTask(
-      FROM_HERE, CrossThreadBind(&CrossThreadStyleValueTest::CheckKeywordValue,
-                                 CrossThreadUnretained(this),
-                                 CrossThreadUnretained(&waitable_event),
-                                 WTF::Passed(std::move(value))));
+      FROM_HERE,
+      CrossThreadBindOnce(&CrossThreadStyleValueTest::CheckKeywordValue,
+                          CrossThreadUnretained(this),
+                          CrossThreadUnretained(&waitable_event),
+                          WTF::Passed(std::move(value))));
   waitable_event.Wait();
 
   ShutDownThread();
@@ -143,11 +144,11 @@ TEST_F(CrossThreadStyleValueTest, PassUnitValueCrossThread) {
   thread_ = std::make_unique<WebThreadSupportingGC>(
       ThreadCreationParams(WebThreadType::kTestThread));
   base::WaitableEvent waitable_event;
-  thread_->PostTask(FROM_HERE,
-                    CrossThreadBind(&CrossThreadStyleValueTest::CheckUnitValue,
-                                    CrossThreadUnretained(this),
-                                    CrossThreadUnretained(&waitable_event),
-                                    WTF::Passed(std::move(value))));
+  thread_->PostTask(
+      FROM_HERE, CrossThreadBindOnce(&CrossThreadStyleValueTest::CheckUnitValue,
+                                     CrossThreadUnretained(this),
+                                     CrossThreadUnretained(&waitable_event),
+                                     WTF::Passed(std::move(value))));
   waitable_event.Wait();
 
   ShutDownThread();

third_party/blink/renderer/core/css/cssom/paint_worklet_style_property_map_test.cc

@@ -40,9 +40,10 @@ class PaintWorkletStylePropertyMapTest : public PageTestBase {
   void ShutDownThread() {
     base::WaitableEvent waitable_event;
     thread_->PostTask(
-        FROM_HERE, CrossThreadBind(&PaintWorkletStylePropertyMapTest::ShutDown,
-                                   CrossThreadUnretained(this),
-                                   CrossThreadUnretained(&waitable_event)));
+        FROM_HERE,
+        CrossThreadBindOnce(&PaintWorkletStylePropertyMapTest::ShutDown,
+                            CrossThreadUnretained(this),
+                            CrossThreadUnretained(&waitable_event)));
     waitable_event.Wait();
   }
 
@@ -195,7 +196,7 @@ TEST_F(PaintWorkletStylePropertyMapTest, PassValuesCrossThread) {
       ThreadCreationParams(WebThreadType::kTestThread));
   base::WaitableEvent waitable_event;
   thread_->PostTask(
-      FROM_HERE, CrossThreadBind(
+      FROM_HERE, CrossThreadBindOnce(
                      &PaintWorkletStylePropertyMapTest::CheckStyleMap,
                      CrossThreadUnretained(this),
                      CrossThreadUnretained(&waitable_event), std::move(input)));

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

@@ -164,9 +164,9 @@ void WorkerThread::Start(
   base::WaitableEvent waitable_event;
   GetWorkerBackingThread().BackingThread().PostTask(
       FROM_HERE,
-      CrossThreadBind(&WorkerThread::InitializeSchedulerOnWorkerThread,
-                      CrossThreadUnretained(this),
-                      CrossThreadUnretained(&waitable_event)));
+      CrossThreadBindOnce(&WorkerThread::InitializeSchedulerOnWorkerThread,
+                          CrossThreadUnretained(this),
+                          CrossThreadUnretained(&waitable_event)));
   waitable_event.Wait();
 
   inspector_task_runner_ =
@@ -174,7 +174,7 @@ void WorkerThread::Start(
 
   GetWorkerBackingThread().BackingThread().PostTask(
       FROM_HERE,
-      CrossThreadBind(
+      CrossThreadBindOnce(
           &WorkerThread::InitializeOnWorkerThread, CrossThreadUnretained(this),
           WTF::Passed(std::move(global_scope_creation_params)),
           thread_startup_data, WTF::Passed(std::move(devtools_params))));
@@ -239,8 +239,8 @@ void WorkerThread::Resume() {
     ResumeOnWorkerThread();
   } else {
     GetWorkerBackingThread().BackingThread().PostTask(
-        FROM_HERE, CrossThreadBind(&WorkerThread::ResumeOnWorkerThread,
-                                   CrossThreadUnretained(this)));
+        FROM_HERE, CrossThreadBindOnce(&WorkerThread::ResumeOnWorkerThread,
+                                       CrossThreadUnretained(this)));
   }
 }
 
@@ -262,11 +262,12 @@ void WorkerThread::Terminate() {
 
   GetWorkerBackingThread().BackingThread().PostTask(
       FROM_HERE,
-      CrossThreadBind(&WorkerThread::PrepareForShutdownOnWorkerThread,
-                      CrossThreadUnretained(this)));
+      CrossThreadBindOnce(&WorkerThread::PrepareForShutdownOnWorkerThread,
+                          CrossThreadUnretained(this)));
   GetWorkerBackingThread().BackingThread().PostTask(
-      FROM_HERE, CrossThreadBind(&WorkerThread::PerformShutdownOnWorkerThread,
-                                 CrossThreadUnretained(this)));
+      FROM_HERE,
+      CrossThreadBindOnce(&WorkerThread::PerformShutdownOnWorkerThread,
+                          CrossThreadUnretained(this)));
 }
 
 void WorkerThread::TerminateForTesting() {
@@ -748,7 +749,7 @@ void WorkerThread::PauseOrFreeze(mojom::FrameLifecycleState state) {
                                 interrupt_data);
     }
     GetWorkerBackingThread().BackingThread().PostTask(
-        FROM_HERE, CrossThreadBind(
+        FROM_HERE, CrossThreadBindOnce(
                        &WorkerThread::PauseOrFreezeInsidePostTaskOnWorkerThread,
                        CrossThreadUnretained(interrupt_data)));
   }

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

@@ -503,10 +503,11 @@ TEST_F(WorkerThreadTest, DISABLED_TerminateWorkerWhileChildIsLoading) {
 
   base::WaitableEvent waitable_event;
   worker_thread_->GetWorkerBackingThread().BackingThread().PostTask(
-      FROM_HERE, CrossThreadBind(&VerifyParentAndChildAreTerminated,
-                                 CrossThreadUnretained(worker_thread_.get()),
-                                 CrossThreadUnretained(&nested_worker_helper),
-                                 CrossThreadUnretained(&waitable_event)));
+      FROM_HERE,
+      CrossThreadBindOnce(&VerifyParentAndChildAreTerminated,
+                          CrossThreadUnretained(worker_thread_.get()),
+                          CrossThreadUnretained(&nested_worker_helper),
+                          CrossThreadUnretained(&waitable_event)));
   waitable_event.Wait();
 }
 

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

@@ -144,8 +144,9 @@ class WorkerThreadForTest : public WorkerThread {
   void WaitForInit() {
     base::WaitableEvent completion_event;
     GetWorkerBackingThread().BackingThread().PostTask(
-        FROM_HERE, CrossThreadBind(&base::WaitableEvent::Signal,
-                                   CrossThreadUnretained(&completion_event)));
+        FROM_HERE,
+        CrossThreadBindOnce(&base::WaitableEvent::Signal,
+                            CrossThreadUnretained(&completion_event)));
     completion_event.Wait();
   }
 

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

@@ -59,8 +59,8 @@ class WorkletThreadHolder {
     thread_ = std::move(backing_thread);
     thread_->BackingThread().PostTask(
         FROM_HERE,
-        CrossThreadBind(&WorkletThreadHolder::InitializeOnWorkletThread,
-                        CrossThreadUnretained(this)));
+        CrossThreadBindOnce(&WorkletThreadHolder::InitializeOnWorkletThread,
+                            CrossThreadUnretained(this)));
   }
 
   void InitializeOnWorkletThread() {
@@ -74,9 +74,9 @@ class WorkletThreadHolder {
     base::WaitableEvent waitable_event;
     thread_->BackingThread().PostTask(
         FROM_HERE,
-        CrossThreadBind(&WorkletThreadHolder::ShutdownOnWorkletThread,
-                        CrossThreadUnretained(this),
-                        CrossThreadUnretained(&waitable_event)));
+        CrossThreadBindOnce(&WorkletThreadHolder::ShutdownOnWorkletThread,
+                            CrossThreadUnretained(this),
+                            CrossThreadUnretained(&waitable_event)));
     waitable_event.Wait();
   }
 

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

@@ -73,10 +73,10 @@ class AudioWorkletThreadTest : public PageTestBase {
     base::WaitableEvent wait_event;
     thread->GetWorkerBackingThread().BackingThread().PostTask(
         FROM_HERE,
-        CrossThreadBind(&AudioWorkletThreadTest::ExecuteScriptInWorklet,
-                        CrossThreadUnretained(this),
-                        CrossThreadUnretained(thread),
-                        CrossThreadUnretained(&wait_event)));
+        CrossThreadBindOnce(&AudioWorkletThreadTest::ExecuteScriptInWorklet,
+                            CrossThreadUnretained(this),
+                            CrossThreadUnretained(thread),
+                            CrossThreadUnretained(&wait_event)));
     wait_event.Wait();
   }
 

third_party/blink/renderer/modules/webdatabase/database_thread.cc

@@ -62,8 +62,8 @@ void DatabaseThread::Start() {
   thread_ = std::make_unique<WebThreadSupportingGC>(
       ThreadCreationParams(WebThreadType::kDatabaseThread));
   thread_->PostTask(FROM_HERE,
-                    CrossThreadBind(&DatabaseThread::SetupDatabaseThread,
-                                    WrapCrossThreadPersistent(this)));
+                    CrossThreadBindOnce(&DatabaseThread::SetupDatabaseThread,
+                                        WrapCrossThreadPersistent(this)));
 }
 
 void DatabaseThread::SetupDatabaseThread() {
@@ -81,9 +81,9 @@ void DatabaseThread::Terminate() {
     termination_requested_ = true;
     cleanup_sync_ = &sync;
     STORAGE_DVLOG(1) << "DatabaseThread " << this << " was asked to terminate";
-    thread_->PostTask(FROM_HERE,
-                      CrossThreadBind(&DatabaseThread::CleanupDatabaseThread,
-                                      WrapCrossThreadPersistent(this)));
+    thread_->PostTask(
+        FROM_HERE, CrossThreadBindOnce(&DatabaseThread::CleanupDatabaseThread,
+                                       WrapCrossThreadPersistent(this)));
   }
   sync.Wait();
   // The Thread destructor blocks until all the tasks of the database
@@ -173,7 +173,7 @@ void DatabaseThread::ScheduleTask(std::unique_ptr<DatabaseTask> task) {
 #endif
   // Thread takes ownership of the task.
   thread_->PostTask(FROM_HERE,
-                    CrossThreadBind(&DatabaseTask::Run, std::move(task)));
+                    CrossThreadBindOnce(&DatabaseTask::Run, std::move(task)));
 }
 
 }  // namespace blink

third_party/blink/renderer/modules/worklet/animation_and_paint_worklet_thread.cc

@@ -79,8 +79,8 @@ void AnimationAndPaintWorkletThread::CollectAllGarbageForTesting() {
   if (!holder)
     return;
   holder->GetThread()->BackingThread().PostTask(
-      FROM_HERE, CrossThreadBind(&CollectAllGarbageOnThreadForTesting,
-                                 CrossThreadUnretained(&done_event)));
+      FROM_HERE, CrossThreadBindOnce(&CollectAllGarbageOnThreadForTesting,
+                                     CrossThreadUnretained(&done_event)));
   done_event.Wait();
 }
 

third_party/blink/renderer/modules/worklet/animation_and_paint_worklet_thread_test.cc

@@ -58,7 +58,7 @@ class AnimationAndPaintWorkletThreadTest : public PageTestBase {
         std::make_unique<base::WaitableEvent>();
     thread->GetWorkerBackingThread().BackingThread().PostTask(
         FROM_HERE,
-        CrossThreadBind(
+        CrossThreadBindOnce(
             &AnimationAndPaintWorkletThreadTest::ExecuteScriptInWorklet,
             CrossThreadUnretained(this), CrossThreadUnretained(thread),
             CrossThreadUnretained(wait_event.get())));

third_party/blink/renderer/platform/web_thread_supporting_gc.h

@@ -44,12 +44,13 @@ class PLATFORM_EXPORT WebThreadSupportingGC final {
     thread_->GetTaskRunner()->PostDelayedTask(location, std::move(task), delay);
   }
 
-  void PostTask(const base::Location& location, CrossThreadClosure task) {
+  void PostTask(const base::Location& location,
+                WTF::CrossThreadOnceClosure task) {
     PostCrossThreadTask(*thread_->GetTaskRunner(), location, std::move(task));
   }
 
   void PostDelayedTask(const base::Location& location,
-                       CrossThreadClosure task,
+                       WTF::CrossThreadOnceClosure task,
                        TimeDelta delay) {
     PostDelayedCrossThreadTask(*thread_->GetTaskRunner(), location,
                                std::move(task), delay);