Rewrite base::Bind into base::BindOnce on trivial cases in base

base/threading/thread_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/threading/thread.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
@@ skipping 137 matching lines @@
   options.stack_size = 2 * 3072 * sizeof(uintptr_t);
 #else
   options.stack_size = 3072 * sizeof(uintptr_t);
 #endif
   EXPECT_TRUE(a.StartWithOptions(options));
   EXPECT_TRUE(a.message_loop());
   EXPECT_TRUE(a.IsRunning());
 
   base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                             base::WaitableEvent::InitialState::NOT_SIGNALED);
-  a.task_runner()->PostTask(FROM_HERE, base::Bind(&base::WaitableEvent::Signal,
-                                                  base::Unretained(&event)));
+  a.task_runner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(&base::WaitableEvent::Signal, base::Unretained(&event)));
   event.Wait();
 }
 
 // Intentional test-only race for otherwise untestable code, won't fix.
 // https://crbug.com/634383
 #if !defined(THREAD_SANITIZER)
 TEST_F(ThreadTest, StartWithOptions_NonJoinable) {
   Thread* a = new Thread("StartNonJoinable");
   // Non-joinable threads have to be leaked for now (see
   // Thread::Options::joinable for details).
@@ skipping 11 matching lines @@
   // satisfied and the real |is_running_| bit has to be checked. It could still
   // be false if the message loop hasn't started for real in practice. This is
   // only a requirement for this test because the non-joinable property forces
   // it to use StopSoon() and not wait for a complete Stop().
   EXPECT_TRUE(a->WaitUntilThreadStarted());
 
   // Make the thread block until |block_event| is signaled.
   base::WaitableEvent block_event(
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
-  a->task_runner()->PostTask(
-      FROM_HERE,
-      base::Bind(&base::WaitableEvent::Wait, base::Unretained(&block_event)));
+  a->task_runner()->PostTask(FROM_HERE,
+                             base::BindOnce(&base::WaitableEvent::Wait,
+                                            base::Unretained(&block_event)));
 
   a->StopSoon();
   EXPECT_TRUE(a->IsRunning());
 
   // Unblock the task and give a bit of extra time to unwind QuitWhenIdle().
   block_event.Signal();
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(20));
 
   // The thread should now have stopped on its own.
   EXPECT_FALSE(a->IsRunning());
 }
 #endif
 
 TEST_F(ThreadTest, TwoTasksOnJoinableThread) {
   bool was_invoked = false;
   {
     Thread a("TwoTasksOnJoinableThread");
     EXPECT_TRUE(a.Start());
     EXPECT_TRUE(a.message_loop());
 
     // Test that all events are dispatched before the Thread object is
     // destroyed.  We do this by dispatching a sleep event before the
     // event that will toggle our sentinel value.
     a.task_runner()->PostTask(
-        FROM_HERE, base::Bind(static_cast<void (*)(base::TimeDelta)>(
-                                  &base::PlatformThread::Sleep),
-                              base::TimeDelta::FromMilliseconds(20)));
+        FROM_HERE, base::BindOnce(static_cast<void (*)(base::TimeDelta)>(
+                                      &base::PlatformThread::Sleep),
+                                  base::TimeDelta::FromMilliseconds(20)));
     a.task_runner()->PostTask(FROM_HERE,
-                              base::Bind(&ToggleValue, &was_invoked));
+                              base::BindOnce(&ToggleValue, &was_invoked));
   }
   EXPECT_TRUE(was_invoked);
 }
 
 TEST_F(ThreadTest, DestroyWhileRunningIsSafe) {
   Thread a("DestroyWhileRunningIsSafe");
   EXPECT_TRUE(a.Start());
   EXPECT_TRUE(a.WaitUntilThreadStarted());
 }
 
@@ skipping 45 matching lines @@
 // TODO(gab): Enable this test in conjunction with re-enabling the sequence
 // check in Thread::Stop() as part of http://crbug.com/629139.
 TEST_F(ThreadTest, DISABLED_StopOnNonOwningThreadIsDeath) {
   Thread a("StopOnNonOwningThreadDeath");
   EXPECT_TRUE(a.StartAndWaitForTesting());
 
   Thread b("NonOwningThread");
   b.Start();
   EXPECT_DCHECK_DEATH({
     // Stopping |a| on |b| isn't allowed.
-    b.task_runner()->PostTask(FROM_HERE,
-                              base::Bind(&Thread::Stop, base::Unretained(&a)));
+    b.task_runner()->PostTask(
+        FROM_HERE, base::BindOnce(&Thread::Stop, base::Unretained(&a)));
     // Block here so the DCHECK on |b| always happens in this scope.
     base::PlatformThread::Sleep(base::TimeDelta::Max());
   });
 }
 
 TEST_F(ThreadTest, TransferOwnershipAndStop) {
   std::unique_ptr<Thread> a =
       base::MakeUnique<Thread>("TransferOwnershipAndStop");
   EXPECT_TRUE(a->StartAndWaitForTesting());
   EXPECT_TRUE(a->IsRunning());
 
   Thread b("TakingOwnershipThread");
   b.Start();
 
   base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
                             base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   // a->DetachFromSequence() should allow |b| to use |a|'s Thread API.
   a->DetachFromSequence();
   b.task_runner()->PostTask(
-      FROM_HERE, base::Bind(
+      FROM_HERE, base::BindOnce(
                      [](std::unique_ptr<Thread> thread_to_stop,
                         base::WaitableEvent* event_to_signal) -> void {
                        thread_to_stop->Stop();
                        event_to_signal->Signal();
                      },
                      base::Passed(&a), base::Unretained(&event)));
 
   event.Wait();
 }
 
@@ skipping 33 matching lines @@
   Thread::Options options;
   options.joinable = false;
   EXPECT_TRUE(a->StartWithOptions(options));
   EXPECT_TRUE(a->message_loop());
   EXPECT_TRUE(a->IsRunning());
 
   // Signaled when last task on |a| is processed.
   base::WaitableEvent last_task_event(
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
-  a->task_runner()->PostTask(FROM_HERE,
-                            base::Bind(&base::WaitableEvent::Signal,
-                                       base::Unretained(&last_task_event)));
+  a->task_runner()->PostTask(
+      FROM_HERE, base::BindOnce(&base::WaitableEvent::Signal,
+                                base::Unretained(&last_task_event)));
 
   // StopSoon() is non-blocking, Yield() to |a|, wait for last task to be
   // processed and a little more for QuitWhenIdle() to unwind before considering
   // the thread "stopped".
   a->StopSoon();
   base::PlatformThread::YieldCurrentThread();
   last_task_event.Wait();
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(20));
 
   // This test assumes that the above was sufficient to let the thread fully
@@ skipping 15 matching lines @@
   Thread a("ThreadId0");
   Thread b("ThreadId1");
   a.Start();
   b.Start();
 
   // Post a task that calls GetThreadId() on the created thread.
   base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                             base::WaitableEvent::InitialState::NOT_SIGNALED);
   base::PlatformThreadId id_from_new_thread;
   a.task_runner()->PostTask(
-      FROM_HERE, base::Bind(ReturnThreadId, &a, &id_from_new_thread, &event));
+      FROM_HERE,
+      base::BindOnce(ReturnThreadId, &a, &id_from_new_thread, &event));
 
   // Call GetThreadId() on the current thread before calling event.Wait() so
   // that this test can find a race issue with TSAN.
   base::PlatformThreadId id_from_current_thread = a.GetThreadId();
 
   // Check if GetThreadId() returns consistent value in both threads.
   event.Wait();
   EXPECT_EQ(id_from_current_thread, id_from_new_thread);
 
   // A started thread should have a valid ID.
@@ skipping 38 matching lines @@
   {
     // Start a thread which writes its event into |captured_events|.
     CaptureToEventList t(&captured_events);
     EXPECT_TRUE(t.Start());
     EXPECT_TRUE(t.message_loop());
     EXPECT_TRUE(t.IsRunning());
 
     // Register an observer that writes into |captured_events| once the
     // thread's message loop is destroyed.
     t.task_runner()->PostTask(
-        FROM_HERE, base::Bind(&RegisterDestructionObserver,
-                              base::Unretained(&loop_destruction_observer)));
+        FROM_HERE,
+        base::BindOnce(&RegisterDestructionObserver,
+                       base::Unretained(&loop_destruction_observer)));
 
     // Upon leaving this scope, the thread is deleted.
   }
 
   // Check the order of events during shutdown.
   ASSERT_EQ(static_cast<size_t>(THREAD_NUM_EVENTS), captured_events.size());
   EXPECT_EQ(THREAD_EVENT_INIT, captured_events[0]);
   EXPECT_EQ(THREAD_EVENT_CLEANUP, captured_events[1]);
   EXPECT_EQ(THREAD_EVENT_MESSAGE_LOOP_DESTROYED, captured_events[2]);
 }
@@ skipping 23 matching lines @@
   a.FlushForTesting();
 
   constexpr base::TimeDelta kSleepPerTestTask =
       base::TimeDelta::FromMilliseconds(50);
   constexpr size_t kNumSleepTasks = 5;
 
   const base::TimeTicks ticks_before_post = base::TimeTicks::Now();
 
   for (size_t i = 0; i < kNumSleepTasks; ++i) {
     a.task_runner()->PostTask(
-        FROM_HERE, base::Bind(&base::PlatformThread::Sleep, kSleepPerTestTask));
+        FROM_HERE,
+        base::BindOnce(&base::PlatformThread::Sleep, kSleepPerTestTask));
   }
 
   // All tasks should have executed, as reflected by the elapsed time.
   a.FlushForTesting();
   EXPECT_GE(base::TimeTicks::Now() - ticks_before_post,
             kNumSleepTasks * kSleepPerTestTask);
 
   a.Stop();
 
   // Flushing a stopped thread should be a no-op.
@@ skipping 33 matching lines @@
   EXPECT_FALSE(a.IsRunning());
   a.VerifyUsingExternalMessageLoop(false);
 
   a.InstallMessageLoop();
   EXPECT_TRUE(a.message_loop());
   EXPECT_TRUE(a.IsRunning());
   a.VerifyUsingExternalMessageLoop(true);
 
   bool ran = false;
   a.task_runner()->PostTask(
-      FROM_HERE, base::Bind([](bool* toggled) { *toggled = true; }, &ran));
+      FROM_HERE, base::BindOnce([](bool* toggled) { *toggled = true; }, &ran));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(ran);
 
   a.Stop();
   EXPECT_FALSE(a.message_loop());
   EXPECT_FALSE(a.IsRunning());
   a.VerifyUsingExternalMessageLoop(true);
 
   // Confirm that running any remaining tasks posted from Stop() goes smoothly
   // (e.g. https://codereview.chromium.org/2135413003/#ps300001 crashed if
   // StopSoon() posted Thread::ThreadQuitHelper() while |run_loop_| was null).
   base::RunLoop().RunUntilIdle();
 }