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

base/threading/sequenced_worker_pool_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/sequenced_worker_pool.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 303 matching lines @@
   // PrepareToStartAdditionalThreadIfNecessary in the .cc file for more
   // details.
   //
   // It will post tasks to the queue with id -1. It also assumes this is the
   // first thing called in a test since it will clear the complete_sequence_.
   void EnsureAllWorkersCreated() {
     // Create a bunch of threads, all waiting. This will cause that may
     // workers to be created.
     ThreadBlocker blocker;
     for (size_t i = 0; i < kNumWorkerThreads; i++) {
-      pool()->PostWorkerTask(FROM_HERE,
-                             base::Bind(&TestTracker::BlockTask,
-                                        tracker(), -1, &blocker));
+      pool()->PostWorkerTask(
+          FROM_HERE,
+          base::BindOnce(&TestTracker::BlockTask, tracker(), -1, &blocker));
     }
     tracker()->WaitUntilTasksBlocked(kNumWorkerThreads);
 
     // Now wake them up and wait until they're done.
     blocker.Unblock(kNumWorkerThreads);
     tracker()->WaitUntilTasksComplete(kNumWorkerThreads);
 
     // Clean up the task IDs we added.
     tracker()->ClearCompleteSequence();
   }
@@ skipping 39 matching lines @@
 };
 
 void ShouldNotRun(const scoped_refptr<DeletionHelper>& helper) {
   ADD_FAILURE() << "Should never run";
 }
 
 // Tests that shutdown does not wait for delayed tasks.
 TEST_P(SequencedWorkerPoolTest, DelayedTaskDuringShutdown) {
   // Post something to verify the pool is started up.
   EXPECT_TRUE(pool()->PostTask(
-      FROM_HERE, base::Bind(&TestTracker::FastTask, tracker(), 1)));
+      FROM_HERE, base::BindOnce(&TestTracker::FastTask, tracker(), 1)));
 
   scoped_refptr<base::RefCountedData<bool> > deleted_flag(
       new base::RefCountedData<bool>(false));
 
   base::Time posted_at(base::Time::Now());
   // Post something that shouldn't run.
   EXPECT_TRUE(pool()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&ShouldNotRun,
-                 make_scoped_refptr(new DeletionHelper(deleted_flag))),
+      base::BindOnce(&ShouldNotRun,
+                     make_scoped_refptr(new DeletionHelper(deleted_flag))),
       TestTimeouts::action_timeout()));
 
   std::vector<int> completion_sequence = tracker()->WaitUntilTasksComplete(1);
   ASSERT_EQ(1u, completion_sequence.size());
   ASSERT_EQ(1, completion_sequence[0]);
 
   // Shutdown the pool.
   pool()->Shutdown();
   if (RedirectedToTaskScheduler())
     TaskScheduler::GetInstance()->Shutdown();
@@ skipping 39 matching lines @@
 
   SequencedWorkerPool::SequenceToken token3again =
       pool()->GetNamedSequenceToken(name3);
   EXPECT_TRUE(token3.Equals(token3again));
 }
 
 // Tests that posting a bunch of tasks (many more than the number of worker
 // threads) runs them all.
 TEST_P(SequencedWorkerPoolTest, LotsOfTasks) {
   pool()->PostWorkerTask(FROM_HERE,
-                         base::Bind(&TestTracker::SlowTask, tracker(), 0));
+                         base::BindOnce(&TestTracker::SlowTask, tracker(), 0));
 
   const size_t kNumTasks = 20;
   for (size_t i = 1; i < kNumTasks; i++) {
-    pool()->PostWorkerTask(FROM_HERE,
-                           base::Bind(&TestTracker::FastTask, tracker(), i));
+    pool()->PostWorkerTask(
+        FROM_HERE, base::BindOnce(&TestTracker::FastTask, tracker(), i));
   }
 
   std::vector<int> result = tracker()->WaitUntilTasksComplete(kNumTasks);
   EXPECT_EQ(kNumTasks, result.size());
 }
 
 // Tests that posting a bunch of tasks (many more than the number of
 // worker threads) to two pools simultaneously runs them all twice.
 // This test is meant to shake out any concurrency issues between
 // pools (like histograms).
@@ skipping 19 matching lines @@
 }
 
 // Test that tasks with the same sequence token are executed in order but don't
 // affect other tasks.
 TEST_P(SequencedWorkerPoolTest, Sequence) {
   // Fill all the worker threads except one.
   const size_t kNumBackgroundTasks = kNumWorkerThreads - 1;
   ThreadBlocker background_blocker;
   for (size_t i = 0; i < kNumBackgroundTasks; i++) {
     pool()->PostWorkerTask(FROM_HERE,
-                           base::Bind(&TestTracker::BlockTask,
-                                      tracker(), i, &background_blocker));
+                           base::BindOnce(&TestTracker::BlockTask, tracker(), i,
+                                          &background_blocker));
   }
   tracker()->WaitUntilTasksBlocked(kNumBackgroundTasks);
 
   // Create two tasks with the same sequence token, one that will block on the
   // event, and one which will just complete quickly when it's run. Since there
   // is one worker thread free, the first task will start and then block, and
   // the second task should be waiting.
   ThreadBlocker blocker;
   SequencedWorkerPool::SequenceToken token1 = pool()->GetSequenceToken();
   pool()->PostSequencedWorkerTask(
       token1, FROM_HERE,
-      base::Bind(&TestTracker::BlockTask, tracker(), 100, &blocker));
+      base::BindOnce(&TestTracker::BlockTask, tracker(), 100, &blocker));
   pool()->PostSequencedWorkerTask(
       token1, FROM_HERE,
-      base::Bind(&TestTracker::FastTask, tracker(), 101));
+      base::BindOnce(&TestTracker::FastTask, tracker(), 101));
   EXPECT_EQ(0u, tracker()->WaitUntilTasksComplete(0).size());
 
   // Create another two tasks as above with a different token. These will be
   // blocked since there are no slots to run.
   SequencedWorkerPool::SequenceToken token2 = pool()->GetSequenceToken();
   pool()->PostSequencedWorkerTask(
       token2, FROM_HERE,
-      base::Bind(&TestTracker::FastTask, tracker(), 200));
+      base::BindOnce(&TestTracker::FastTask, tracker(), 200));
   pool()->PostSequencedWorkerTask(
       token2, FROM_HERE,
-      base::Bind(&TestTracker::FastTask, tracker(), 201));
+      base::BindOnce(&TestTracker::FastTask, tracker(), 201));
   EXPECT_EQ(0u, tracker()->WaitUntilTasksComplete(0).size());
 
   // Let one background task complete. This should then let both tasks of
   // token2 run to completion in order. The second task of token1 should still
   // be blocked.
   background_blocker.Unblock(1);
   std::vector<int> result = tracker()->WaitUntilTasksComplete(3);
   ASSERT_EQ(3u, result.size());
   EXPECT_EQ(200, result[1]);
   EXPECT_EQ(201, result[2]);
@@ skipping 12 matching lines @@
   EXPECT_EQ(101, result[result.size() - 1]);
 }
 
 // Tests that any tasks posted after Shutdown are ignored.
 // Disabled for flakiness.  See http://crbug.com/166451.
 TEST_P(SequencedWorkerPoolTest, DISABLED_IgnoresAfterShutdown) {
   // Start tasks to take all the threads and block them.
   EnsureAllWorkersCreated();
   ThreadBlocker blocker;
   for (size_t i = 0; i < kNumWorkerThreads; i++) {
-    pool()->PostWorkerTask(FROM_HERE,
-                           base::Bind(&TestTracker::BlockTask,
-                                      tracker(), i, &blocker));
+    pool()->PostWorkerTask(FROM_HERE, base::BindOnce(&TestTracker::BlockTask,
+                                                     tracker(), i, &blocker));
   }
   tracker()->WaitUntilTasksBlocked(kNumWorkerThreads);
 
   SetWillWaitForShutdownCallback(
       base::Bind(&EnsureTasksToCompleteCountAndUnblock,
                  scoped_refptr<TestTracker>(tracker()), 0,
                  &blocker, kNumWorkerThreads));
 
   // Shutdown the worker pool. This should discard all non-blocking tasks.
   const int kMaxNewBlockingTasksAfterShutdown = 100;
   pool()->Shutdown(kMaxNewBlockingTasksAfterShutdown);
 
   int old_has_work_call_count = has_work_call_count();
 
   std::vector<int> result =
       tracker()->WaitUntilTasksComplete(kNumWorkerThreads);
 
   // The kNumWorkerThread items should have completed, in no particular order.
   ASSERT_EQ(kNumWorkerThreads, result.size());
   for (size_t i = 0; i < kNumWorkerThreads; i++)
     EXPECT_TRUE(ContainsValue(result, static_cast<int>(i)));
 
   // No further tasks, regardless of shutdown mode, should be allowed.
   EXPECT_FALSE(pool()->PostWorkerTaskWithShutdownBehavior(
-      FROM_HERE,
-      base::Bind(&TestTracker::FastTask, tracker(), 100),
+      FROM_HERE, base::BindOnce(&TestTracker::FastTask, tracker(), 100),
       SequencedWorkerPool::CONTINUE_ON_SHUTDOWN));
   EXPECT_FALSE(pool()->PostWorkerTaskWithShutdownBehavior(
-      FROM_HERE,
-      base::Bind(&TestTracker::FastTask, tracker(), 101),
+      FROM_HERE, base::BindOnce(&TestTracker::FastTask, tracker(), 101),
       SequencedWorkerPool::SKIP_ON_SHUTDOWN));
   EXPECT_FALSE(pool()->PostWorkerTaskWithShutdownBehavior(
-      FROM_HERE,
-      base::Bind(&TestTracker::FastTask, tracker(), 102),
+      FROM_HERE, base::BindOnce(&TestTracker::FastTask, tracker(), 102),
       SequencedWorkerPool::BLOCK_SHUTDOWN));
 
   ASSERT_EQ(old_has_work_call_count, has_work_call_count());
 }
 
 TEST_P(SequencedWorkerPoolTest, AllowsAfterShutdown) {
   // Test that <n> new blocking tasks are allowed provided they're posted
   // by a running tasks.
   EnsureAllWorkersCreated();
   ThreadBlocker blocker;
 
   // Start tasks to take all the threads and block them.
   const int kNumBlockTasks = static_cast<int>(kNumWorkerThreads);
   for (int i = 0; i < kNumBlockTasks; ++i) {
     EXPECT_TRUE(pool()->PostWorkerTask(
         FROM_HERE,
-        base::Bind(&TestTracker::BlockTask, tracker(), i, &blocker)));
+        base::BindOnce(&TestTracker::BlockTask, tracker(), i, &blocker)));
   }
   tracker()->WaitUntilTasksBlocked(kNumWorkerThreads);
 
   // Queue up shutdown blocking tasks behind those which will attempt to post
   // additional tasks when run, PostAdditionalTasks attempts to post 3
   // new FastTasks, one for each shutdown_behavior.
   const int kNumQueuedTasks = static_cast<int>(kNumWorkerThreads);
   for (int i = 0; i < kNumQueuedTasks; ++i) {
     EXPECT_TRUE(pool()->PostWorkerTaskWithShutdownBehavior(
-        FROM_HERE, base::Bind(&TestTracker::PostAdditionalTasks, tracker(), i,
-                              base::RetainedRef(pool()), false),
+        FROM_HERE,
+        base::BindOnce(&TestTracker::PostAdditionalTasks, tracker(), i,
+                       base::RetainedRef(pool()), false),
         SequencedWorkerPool::BLOCK_SHUTDOWN));
   }
 
   // Half the additional blocking tasks will be allowed to run.
   constexpr int kNumNewBlockingTasksToAllow = kNumWorkerThreads / 2;
 
   if (RedirectedToTaskScheduler()) {
     // When redirection to TaskScheduler is enabled,
     // SequencedWorkerPool::Shutdown() sets the number of additional
     // BLOCK_SHUTDOWN tasks that can be posted and returns without waiting for
@@ skipping 31 matching lines @@
 TEST_P(SequencedWorkerPoolTest,
        AllowsBlockingTasksDuringShutdownOutsideOfRunningTask) {
   EnsureAllWorkersCreated();
   ThreadBlocker blocker;
 
   // Start tasks to take all the threads and block them.
   const int kNumBlockTasks = static_cast<int>(kNumWorkerThreads);
   for (int i = 0; i < kNumBlockTasks; ++i) {
     EXPECT_TRUE(pool()->PostWorkerTask(
         FROM_HERE,
-        base::Bind(&TestTracker::BlockTask, tracker(), i, &blocker)));
+        base::BindOnce(&TestTracker::BlockTask, tracker(), i, &blocker)));
   }
   tracker()->WaitUntilTasksBlocked(kNumWorkerThreads);
 
   constexpr int kNumNewBlockingTasksToAllow = 1;
 
   if (RedirectedToTaskScheduler()) {
     // When redirection to TaskScheduler is enabled,
     // SequencedWorkerPool::Shutdown() sets the number of additional
     // BLOCK_SHUTDOWN tasks that can be posted and returns without waiting for
     // pending BLOCK_SHUTDOWN tasks to complete their execution.
@@ skipping 33 matching lines @@
   // CONTINUE_ON_SHUTDOWN tasks and runs BLOCK_SHUTDOWN tasks. However, since it
   // doesn't provide a way to run a callback from inside its Shutdown() method,
   // it would be hard to make this test work with redirection enabled.
   if (RedirectedToTaskScheduler())
     return;
 
   // Start tasks to take all the threads and block them.
   EnsureAllWorkersCreated();
   ThreadBlocker blocker;
   for (size_t i = 0; i < kNumWorkerThreads; i++) {
-    pool()->PostWorkerTask(FROM_HERE,
-                           base::Bind(&TestTracker::BlockTask,
-                                      tracker(), i, &blocker));
+    pool()->PostWorkerTask(FROM_HERE, base::BindOnce(&TestTracker::BlockTask,
+                                                     tracker(), i, &blocker));
   }
   tracker()->WaitUntilTasksBlocked(kNumWorkerThreads);
 
   // Create some tasks with different shutdown modes.
   pool()->PostWorkerTaskWithShutdownBehavior(
-      FROM_HERE,
-      base::Bind(&TestTracker::FastTask, tracker(), 100),
+      FROM_HERE, base::BindOnce(&TestTracker::FastTask, tracker(), 100),
       SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
   pool()->PostWorkerTaskWithShutdownBehavior(
-      FROM_HERE,
-      base::Bind(&TestTracker::FastTask, tracker(), 101),
+      FROM_HERE, base::BindOnce(&TestTracker::FastTask, tracker(), 101),
       SequencedWorkerPool::SKIP_ON_SHUTDOWN);
   pool()->PostWorkerTaskWithShutdownBehavior(
-      FROM_HERE,
-      base::Bind(&TestTracker::FastTask, tracker(), 102),
+      FROM_HERE, base::BindOnce(&TestTracker::FastTask, tracker(), 102),
       SequencedWorkerPool::BLOCK_SHUTDOWN);
 
   // Shutdown the worker pool. This should discard all non-blocking tasks.
   SetWillWaitForShutdownCallback(
       base::Bind(&EnsureTasksToCompleteCountAndUnblock,
                  scoped_refptr<TestTracker>(tracker()), 0,
                  &blocker, kNumWorkerThreads));
   pool()->Shutdown();
 
   std::vector<int> result =
@@ skipping 12 matching lines @@
   scoped_refptr<TaskRunner> runner(pool()->GetTaskRunnerWithShutdownBehavior(
       SequencedWorkerPool::CONTINUE_ON_SHUTDOWN));
   scoped_refptr<SequencedTaskRunner> sequenced_runner(
       pool()->GetSequencedTaskRunnerWithShutdownBehavior(
           pool()->GetSequenceToken(),
           SequencedWorkerPool::CONTINUE_ON_SHUTDOWN));
   EnsureAllWorkersCreated();
   ThreadBlocker blocker;
   pool()->PostWorkerTaskWithShutdownBehavior(
       FROM_HERE,
-      base::Bind(&TestTracker::BlockTask,
-                 tracker(), 0, &blocker),
+      base::BindOnce(&TestTracker::BlockTask, tracker(), 0, &blocker),
       SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
-  runner->PostTask(
-      FROM_HERE,
-      base::Bind(&TestTracker::BlockTask,
-                 tracker(), 1, &blocker));
-  sequenced_runner->PostTask(
-      FROM_HERE,
-      base::Bind(&TestTracker::BlockTask,
-                 tracker(), 2, &blocker));
+  runner->PostTask(FROM_HERE, base::BindOnce(&TestTracker::BlockTask, tracker(),
+                                             1, &blocker));
+  sequenced_runner->PostTask(FROM_HERE, base::BindOnce(&TestTracker::BlockTask,
+                                                       tracker(), 2, &blocker));
 
   tracker()->WaitUntilTasksBlocked(3);
 
   // This should not block. If this test hangs, it means it failed.
   pool()->Shutdown();
   if (RedirectedToTaskScheduler())
     TaskScheduler::GetInstance()->Shutdown();
 
   // The task should not have completed yet.
   EXPECT_EQ(0u, tracker()->WaitUntilTasksComplete(0).size());
 
   // Posting more tasks should fail.
   EXPECT_FALSE(pool()->PostWorkerTaskWithShutdownBehavior(
-      FROM_HERE, base::Bind(&TestTracker::FastTask, tracker(), 0),
+      FROM_HERE, base::BindOnce(&TestTracker::FastTask, tracker(), 0),
       SequencedWorkerPool::CONTINUE_ON_SHUTDOWN));
   EXPECT_FALSE(runner->PostTask(
-      FROM_HERE, base::Bind(&TestTracker::FastTask, tracker(), 0)));
+      FROM_HERE, base::BindOnce(&TestTracker::FastTask, tracker(), 0)));
   EXPECT_FALSE(sequenced_runner->PostTask(
-      FROM_HERE, base::Bind(&TestTracker::FastTask, tracker(), 0)));
+      FROM_HERE, base::BindOnce(&TestTracker::FastTask, tracker(), 0)));
 
   // Continue the background thread and make sure the tasks can complete.
   blocker.Unblock(3);
   std::vector<int> result = tracker()->WaitUntilTasksComplete(3);
   EXPECT_EQ(3u, result.size());
 }
 
 // Tests that SKIP_ON_SHUTDOWN tasks that have been started block Shutdown
 // until they stop, but tasks not yet started do not.
 TEST_P(SequencedWorkerPoolTest, SkipOnShutdown) {
   // As tested by
   // TaskSchedulerTaskTrackerTest.WillPostAndRunLongTaskBeforeShutdown and
   // TaskSchedulerTaskTrackerTest.WillPostBeforeShutdownRunDuringShutdown, the
   // TaskScheduler correctly handles SKIP_ON_SHUTDOWN tasks. However, since it
   // doesn't provide a way to run a callback from inside its Shutdown() method,
   // it would be hard to make this test work with redirection enabled.
   if (RedirectedToTaskScheduler())
     return;
 
   // Start tasks to take all the threads and block them.
   EnsureAllWorkersCreated();
   ThreadBlocker blocker;
 
   // Now block all the threads with SKIP_ON_SHUTDOWN. Shutdown() should not
   // return until these tasks have completed.
   for (size_t i = 0; i < kNumWorkerThreads; i++) {
     pool()->PostWorkerTaskWithShutdownBehavior(
         FROM_HERE,
-        base::Bind(&TestTracker::BlockTask, tracker(), i, &blocker),
+        base::BindOnce(&TestTracker::BlockTask, tracker(), i, &blocker),
         SequencedWorkerPool::SKIP_ON_SHUTDOWN);
   }
   tracker()->WaitUntilTasksBlocked(kNumWorkerThreads);
 
   // Now post an additional task as SKIP_ON_SHUTDOWN, which should not be
   // executed once Shutdown() has been called.
   pool()->PostWorkerTaskWithShutdownBehavior(
       FROM_HERE,
-      base::Bind(&TestTracker::BlockTask,
-                 tracker(), 0, &blocker),
+      base::BindOnce(&TestTracker::BlockTask, tracker(), 0, &blocker),
       SequencedWorkerPool::SKIP_ON_SHUTDOWN);
 
   // This callback will only be invoked if SKIP_ON_SHUTDOWN tasks that have
   // been started block shutdown.
   SetWillWaitForShutdownCallback(
       base::Bind(&EnsureTasksToCompleteCountAndUnblock,
                  scoped_refptr<TestTracker>(tracker()), 0,
                  &blocker, kNumWorkerThreads));
 
   // No tasks should have completed yet.
@@ skipping 67 matching lines @@
   EXPECT_FALSE(unsequenced_task_runner->RunsTasksOnCurrentThread());
   EXPECT_FALSE(unused_pool_owner.pool()->RunsTasksOnCurrentThread());
 
   // From a task posted to |sequenced_task_runner_1|:
   // - sequenced_task_runner_1->RunsTasksOnCurrentThread() returns true.
   // - sequenced_task_runner_2->RunsTasksOnCurrentThread() returns false.
   // - pool()->RunsTasksOnCurrentThread() returns true.
   // - unused_pool_owner.pool()->RunsTasksOnCurrentThread() returns false.
   sequenced_task_runner_1->PostTask(
       FROM_HERE,
-      base::Bind(&VerifyRunsTasksOnCurrentThread, RedirectedToTaskScheduler(),
-                 sequenced_task_runner_1, sequenced_task_runner_2,
-                 base::RetainedRef(pool()),
-                 base::RetainedRef(unused_pool_owner.pool())));
+      base::BindOnce(&VerifyRunsTasksOnCurrentThread,
+                     RedirectedToTaskScheduler(), sequenced_task_runner_1,
+                     sequenced_task_runner_2, base::RetainedRef(pool()),
+                     base::RetainedRef(unused_pool_owner.pool())));
   // From a task posted to |unsequenced_task_runner|:
   // - unsequenced_task_runner->RunsTasksOnCurrentThread() returns true.
   // - sequenced_task_runner_1->RunsTasksOnCurrentThread() returns false.
   // - pool()->RunsTasksOnCurrentThread() returns true.
   // - unused_pool_owner.pool()->RunsTasksOnCurrentThread() returns false.
   unsequenced_task_runner->PostTask(
       FROM_HERE,
-      base::Bind(&VerifyRunsTasksOnCurrentThread, RedirectedToTaskScheduler(),
-                 unsequenced_task_runner, sequenced_task_runner_1,
-                 base::RetainedRef(pool()),
-                 base::RetainedRef(unused_pool_owner.pool())));
+      base::BindOnce(&VerifyRunsTasksOnCurrentThread,
+                     RedirectedToTaskScheduler(), unsequenced_task_runner,
+                     sequenced_task_runner_1, base::RetainedRef(pool()),
+                     base::RetainedRef(unused_pool_owner.pool())));
 }
 
 // Checks that tasks are destroyed in the right context during shutdown. If a
 // task is destroyed while SequencedWorkerPool's global lock is held,
 // SequencedWorkerPool might deadlock.
 TEST_P(SequencedWorkerPoolTest, AvoidsDeadlockOnShutdown) {
   // Note: TaskScheduler destroys tasks when it is deleted rather than on
   // shutdown. In production, it should never be destroyed.
 
   for (int i = 0; i < 4; ++i) {
@@ skipping 35 matching lines @@
 }
 
 // Verify that FlushForTesting works as intended.
 TEST_P(SequencedWorkerPoolTest, FlushForTesting) {
   // Should be fine to call on a new instance.
   pool()->FlushForTesting();
 
   // Queue up a bunch of work, including  a long delayed task and
   // a task that produces additional tasks as an artifact.
   pool()->PostDelayedWorkerTask(
-      FROM_HERE,
-      base::Bind(&TestTracker::FastTask, tracker(), 0),
+      FROM_HERE, base::BindOnce(&TestTracker::FastTask, tracker(), 0),
       TimeDelta::FromMinutes(5));
   pool()->PostWorkerTask(FROM_HERE,
-                         base::Bind(&TestTracker::SlowTask, tracker(), 0));
+                         base::BindOnce(&TestTracker::SlowTask, tracker(), 0));
   const size_t kNumFastTasks = 20;
   for (size_t i = 0; i < kNumFastTasks; i++) {
-    pool()->PostWorkerTask(FROM_HERE,
-                           base::Bind(&TestTracker::FastTask, tracker(), 0));
+    pool()->PostWorkerTask(
+        FROM_HERE, base::BindOnce(&TestTracker::FastTask, tracker(), 0));
   }
   pool()->PostWorkerTask(
-      FROM_HERE, base::Bind(&TestTracker::PostAdditionalTasks, tracker(), 0,
-                            base::RetainedRef(pool()), true));
+      FROM_HERE, base::BindOnce(&TestTracker::PostAdditionalTasks, tracker(), 0,
+                                base::RetainedRef(pool()), true));
 
   // We expect all except the delayed task to have been run. We verify all
   // closures have been deleted by looking at the refcount of the
   // tracker.
   EXPECT_FALSE(tracker()->HasOneRef());
   pool()->FlushForTesting();
   EXPECT_EQ(1 + kNumFastTasks + 1 + 3, tracker()->GetTasksCompletedCount());
   // TaskScheduler deletes unexecuted delayed tasks as part of ~TaskScheduler()
   // instead of TaskScheduler::FlushForTesting().
   EXPECT_EQ(!RedirectedToTaskScheduler(), tracker()->HasOneRef());
@@ skipping 49 matching lines @@
       SequencedWorkerPool::GetSequenceTokenForCurrentThread();
   scoped_refptr<SequencedWorkerPool> local_pool =
       SequencedWorkerPool::GetWorkerPoolForCurrentThread();
   EXPECT_FALSE(local_token.IsValid()) << local_token.ToString();
   EXPECT_FALSE(local_pool);
 
   SequencedWorkerPool::SequenceToken token1 = pool()->GetSequenceToken();
   SequencedWorkerPool::SequenceToken token2 = pool()->GetSequenceToken();
   pool()->PostSequencedWorkerTask(
       token1, FROM_HERE,
-      base::Bind(&CheckWorkerPoolAndSequenceToken, pool(), token1));
+      base::BindOnce(&CheckWorkerPoolAndSequenceToken, pool(), token1));
   pool()->PostSequencedWorkerTask(
       token2, FROM_HERE,
-      base::Bind(&CheckWorkerPoolAndSequenceToken, pool(), token2));
+      base::BindOnce(&CheckWorkerPoolAndSequenceToken, pool(), token2));
 
-  pool()->PostWorkerTask(FROM_HERE,
-                         base::Bind(&CheckWorkerPoolAndSequenceToken, pool(),
-                                    SequencedWorkerPool::SequenceToken()));
+  pool()->PostWorkerTask(
+      FROM_HERE, base::BindOnce(&CheckWorkerPoolAndSequenceToken, pool(),
+                                SequencedWorkerPool::SequenceToken()));
 
   pool()->FlushForTesting();
 }
 
 TEST_P(SequencedWorkerPoolTest, ShutsDownCleanWithContinueOnShutdown) {
   scoped_refptr<SequencedTaskRunner> task_runner =
       pool()->GetSequencedTaskRunnerWithShutdownBehavior(
           pool()->GetSequenceToken(),
           base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
 
@@ skipping 129 matching lines @@
     SequencedWorkerPoolSequencedTaskRunner, SequencedTaskRunnerTest,
     SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPoolSequencedTaskRunner,
     SequencedTaskRunnerDelayedTest,
     SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
 
 }  // namespace
 
 }  // namespace base