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

base/task_scheduler/scheduler_worker_pool_impl_unittest.cc

 // Copyright 2016 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/task_scheduler/scheduler_worker_pool_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <unordered_set>
@@ skipping 309 matching lines @@
   // Wait until all workers are idle to be sure that no task accesses
   // its TestTaskFactory after it is destroyed.
   worker_pool_->WaitForAllWorkersIdleForTesting();
 }
 
 // Verify that a Task can't be posted after shutdown.
 TEST_P(TaskSchedulerWorkerPoolImplTest, PostTaskAfterShutdown) {
   auto task_runner =
       CreateTaskRunnerWithExecutionMode(worker_pool_.get(), GetParam());
   task_tracker_.Shutdown();
-  EXPECT_FALSE(task_runner->PostTask(FROM_HERE, Bind(&ShouldNotRun)));
+  EXPECT_FALSE(task_runner->PostTask(FROM_HERE, BindOnce(&ShouldNotRun)));
 }
 
 // Verify that a Task runs shortly after its delay expires.
 TEST_P(TaskSchedulerWorkerPoolImplTest, PostDelayedTask) {
   TimeTicks start_time = TimeTicks::Now();
 
   // Post a task with a short delay.
   WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
                          WaitableEvent::InitialState::NOT_SIGNALED);
   EXPECT_TRUE(CreateTaskRunnerWithExecutionMode(worker_pool_.get(), GetParam())
-                  ->PostDelayedTask(FROM_HERE, Bind(&WaitableEvent::Signal,
-                                                    Unretained(&task_ran)),
-                                    TestTimeouts::tiny_timeout()));
+                  ->PostDelayedTask(
+                      FROM_HERE,
+                      BindOnce(&WaitableEvent::Signal, Unretained(&task_ran)),
+                      TestTimeouts::tiny_timeout()));
 
   // Wait until the task runs.
   task_ran.Wait();
 
   // Expect the task to run after its delay expires, but not more than 250 ms
   // after that.
   const TimeDelta actual_delay = TimeTicks::Now() - start_time;
   EXPECT_GE(actual_delay, TestTimeouts::tiny_timeout());
   EXPECT_LT(actual_delay,
             TimeDelta::FromMilliseconds(250) + TestTimeouts::tiny_timeout());
 }
 
 // Verify that the RunsTasksOnCurrentThread() method of a SEQUENCED TaskRunner
 // returns false when called from a task that isn't part of the sequence. Note:
 // Tests that use TestTaskFactory already verify that RunsTasksOnCurrentThread()
 // returns true when appropriate so this method complements it to get full
 // coverage of that method.
 TEST_P(TaskSchedulerWorkerPoolImplTest, SequencedRunsTasksOnCurrentThread) {
   auto task_runner =
       CreateTaskRunnerWithExecutionMode(worker_pool_.get(), GetParam());
   auto sequenced_task_runner =
       worker_pool_->CreateSequencedTaskRunnerWithTraits(TaskTraits());
 
   WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
                          WaitableEvent::InitialState::NOT_SIGNALED);
   task_runner->PostTask(
       FROM_HERE,
-      Bind(
+      BindOnce(
           [](scoped_refptr<TaskRunner> sequenced_task_runner,
              WaitableEvent* task_ran) {
             EXPECT_FALSE(sequenced_task_runner->RunsTasksOnCurrentThread());
             task_ran->Signal();
           },
           sequenced_task_runner, Unretained(&task_ran)));
   task_ran.Wait();
 }
 
 INSTANTIATE_TEST_CASE_P(Parallel,
@@ skipping 190 matching lines @@
 
 TEST_F(TaskSchedulerWorkerPoolHistogramTest, NumTasksBetweenWaits) {
   WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
                       WaitableEvent::InitialState::NOT_SIGNALED);
   CreateAndStartWorkerPool(TimeDelta::Max(), kNumWorkersInWorkerPool);
   auto task_runner = worker_pool_->CreateSequencedTaskRunnerWithTraits(
       TaskTraits().WithBaseSyncPrimitives());
 
   // Post a task.
   task_runner->PostTask(FROM_HERE,
-                        Bind(&WaitableEvent::Wait, Unretained(&event)));
+                        BindOnce(&WaitableEvent::Wait, Unretained(&event)));
 
   // Post 2 more tasks while the first task hasn't completed its execution. It
   // is guaranteed that these tasks will run immediately after the first task,
   // without allowing the worker to sleep.
-  task_runner->PostTask(FROM_HERE, Bind(&DoNothing));
-  task_runner->PostTask(FROM_HERE, Bind(&DoNothing));
+  task_runner->PostTask(FROM_HERE, BindOnce(&DoNothing));
+  task_runner->PostTask(FROM_HERE, BindOnce(&DoNothing));
 
   // Allow tasks to run and wait until the SchedulerWorker is idle.
   event.Signal();
   worker_pool_->WaitForAllWorkersIdleForTesting();
 
   // Wake up the SchedulerWorker that just became idle by posting a task and
   // wait until it becomes idle again. The SchedulerWorker should record the
   // TaskScheduler.NumTasksBetweenWaits.* histogram on wake up.
-  task_runner->PostTask(FROM_HERE, Bind(&DoNothing));
+  task_runner->PostTask(FROM_HERE, BindOnce(&DoNothing));
   worker_pool_->WaitForAllWorkersIdleForTesting();
 
   // Verify that counts were recorded to the histogram as expected.
   const auto* histogram = worker_pool_->num_tasks_between_waits_histogram();
   EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(0));
   EXPECT_EQ(1, histogram->SnapshotSamples()->GetCount(3));
   EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(10));
 }
 
 namespace {
@@ skipping 12 matching lines @@
   CreateAndStartWorkerPool(kReclaimTimeForDetachTests, kNumWorkersInWorkerPool);
   auto task_runner = worker_pool_->CreateTaskRunnerWithTraits(
       TaskTraits().WithBaseSyncPrimitives());
 
   // Post tasks to saturate the pool.
   std::vector<std::unique_ptr<WaitableEvent>> task_started_events;
   for (size_t i = 0; i < kNumWorkersInWorkerPool; ++i) {
     task_started_events.push_back(
         MakeUnique<WaitableEvent>(WaitableEvent::ResetPolicy::MANUAL,
                                   WaitableEvent::InitialState::NOT_SIGNALED));
-    task_runner->PostTask(
-        FROM_HERE,
-        Bind(&SignalAndWaitEvent, Unretained(task_started_events.back().get()),
-             Unretained(&tasks_can_exit_event)));
+    task_runner->PostTask(FROM_HERE,
+                          BindOnce(&SignalAndWaitEvent,
+                                   Unretained(task_started_events.back().get()),
+                                   Unretained(&tasks_can_exit_event)));
   }
   for (const auto& task_started_event : task_started_events)
     task_started_event->Wait();
 
   // Allow tasks to complete their execution and wait to allow workers to
   // detach.
   tasks_can_exit_event.Signal();
   worker_pool_->WaitForAllWorkersIdleForTesting();
   PlatformThread::Sleep(kReclaimTimeForDetachTests + kExtraTimeToWaitForDetach);
 
   // Wake up SchedulerWorkers by posting tasks. They should record the
   // TaskScheduler.NumTasksBetweenWaits.* histogram on wake up.
   tasks_can_exit_event.Reset();
   task_started_events.clear();
   for (size_t i = 0; i < kNumWorkersInWorkerPool; ++i) {
     task_started_events.push_back(
         MakeUnique<WaitableEvent>(WaitableEvent::ResetPolicy::MANUAL,
                                   WaitableEvent::InitialState::NOT_SIGNALED));
-    task_runner->PostTask(
-        FROM_HERE,
-        Bind(&SignalAndWaitEvent, Unretained(task_started_events.back().get()),
-             Unretained(&tasks_can_exit_event)));
+    task_runner->PostTask(FROM_HERE,
+                          BindOnce(&SignalAndWaitEvent,
+                                   Unretained(task_started_events.back().get()),
+                                   Unretained(&tasks_can_exit_event)));
   }
   for (const auto& task_started_event : task_started_events)
     task_started_event->Wait();
 
   const auto* histogram = worker_pool_->num_tasks_between_waits_histogram();
 
   // Verify that counts were recorded to the histogram as expected.
   // - The "0" bucket has a count of at least 1 because the SchedulerWorker on
   //   top of the idle stack isn't allowed to detach when its sleep timeout
   //   expires. Instead, it waits on its WaitableEvent again without running a
@@ skipping 17 matching lines @@
 
   auto histogrammed_thread_task_runner =
       worker_pool_->CreateSequencedTaskRunnerWithTraits(
           TaskTraits().WithBaseSyncPrimitives());
 
   // Post 3 tasks and hold the thread for idle thread stack ordering.
   // This test assumes |histogrammed_thread_task_runner| gets assigned the same
   // thread for each of its tasks.
   PlatformThreadRef thread_ref;
   histogrammed_thread_task_runner->PostTask(
-      FROM_HERE, Bind(
+      FROM_HERE, BindOnce(
                      [](PlatformThreadRef* thread_ref) {
                        ASSERT_TRUE(thread_ref);
                        *thread_ref = PlatformThread::CurrentRef();
                      },
                      Unretained(&thread_ref)));
   histogrammed_thread_task_runner->PostTask(
-      FROM_HERE, Bind(
+      FROM_HERE, BindOnce(
                      [](PlatformThreadRef* thread_ref) {
                        ASSERT_FALSE(thread_ref->is_null());
                        EXPECT_EQ(*thread_ref, PlatformThread::CurrentRef());
                      },
                      Unretained(&thread_ref)));
 
   WaitableEvent detach_thread_running(
       WaitableEvent::ResetPolicy::MANUAL,
       WaitableEvent::InitialState::NOT_SIGNALED);
   WaitableEvent detach_thread_continue(
       WaitableEvent::ResetPolicy::MANUAL,
       WaitableEvent::InitialState::NOT_SIGNALED);
   histogrammed_thread_task_runner->PostTask(
       FROM_HERE,
-      Bind(
+      BindOnce(
           [](PlatformThreadRef* thread_ref,
              WaitableEvent* detach_thread_running,
              WaitableEvent* detach_thread_continue) {
             ASSERT_FALSE(thread_ref->is_null());
             EXPECT_EQ(*thread_ref, PlatformThread::CurrentRef());
             detach_thread_running->Signal();
             detach_thread_continue->Wait();
           },
           Unretained(&thread_ref), Unretained(&detach_thread_running),
           Unretained(&detach_thread_continue)));
@@ skipping 10 matching lines @@
   WaitableEvent top_idle_thread_running(
       WaitableEvent::ResetPolicy::MANUAL,
       WaitableEvent::InitialState::NOT_SIGNALED);
   WaitableEvent top_idle_thread_continue(
       WaitableEvent::ResetPolicy::MANUAL,
       WaitableEvent::InitialState::NOT_SIGNALED);
   auto task_runner_for_top_idle =
       worker_pool_->CreateSequencedTaskRunnerWithTraits(
           TaskTraits().WithBaseSyncPrimitives());
   task_runner_for_top_idle->PostTask(
-      FROM_HERE, Bind(
+      FROM_HERE, BindOnce(
                      [](PlatformThreadRef thread_ref,
                         WaitableEvent* top_idle_thread_running,
                         WaitableEvent* top_idle_thread_continue) {
                        ASSERT_FALSE(thread_ref.is_null());
                        EXPECT_NE(thread_ref, PlatformThread::CurrentRef())
                            << "Worker reused. Thread will not detach and the "
                               "histogram value will be wrong.";
                        top_idle_thread_running->Signal();
                        top_idle_thread_continue->Wait();
                      },
@@ skipping 58 matching lines @@
       &delayed_task_manager);
   worker_pool->Start(SchedulerWorkerPoolParams(StandbyThreadPolicy::ONE, 8U,
                                                TimeDelta::Max()));
   ASSERT_TRUE(worker_pool);
   EXPECT_EQ(1U, worker_pool->NumberOfAliveWorkersForTesting());
   worker_pool->JoinForTesting();
 }
 
 }  // namespace internal
 }  // namespace base