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

base/task/cancelable_task_tracker_unittest.cc

 // Copyright 2014 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/cancelable_task_tracker.h"
 
 #include <cstddef>
 #include <deque>
 
 #include "base/bind.h"
@@ skipping 176 matching lines @@
 TEST_F(CancelableTaskTrackerTest, NewTrackedTaskIdDifferentThread) {
   CancelableTaskTracker::IsCanceledCallback is_canceled;
   CancelableTaskTracker::TaskId task_id =
       task_tracker_.NewTrackedTaskId(&is_canceled);
 
   EXPECT_FALSE(is_canceled.Run());
 
   Thread other_thread("other thread");
   ASSERT_TRUE(other_thread.Start());
   other_thread.task_runner()->PostTask(
-      FROM_HERE, Bind(&ExpectIsCanceled, is_canceled, false));
+      FROM_HERE, BindOnce(&ExpectIsCanceled, is_canceled, false));
   other_thread.Stop();
 
   task_tracker_.TryCancel(task_id);
 
   ASSERT_TRUE(other_thread.Start());
   other_thread.task_runner()->PostTask(
-      FROM_HERE, Bind(&ExpectIsCanceled, is_canceled, true));
+      FROM_HERE, BindOnce(&ExpectIsCanceled, is_canceled, true));
   other_thread.Stop();
 }
 
 // With the task tracker, post a task, a task with a reply, get a new
 // task id, and then cancel all of them.  None of the tasks nor the
 // reply should run and the "is canceled" callback should return
 // true.
 TEST_F(CancelableTaskTrackerTest, CancelAll) {
   scoped_refptr<TestSimpleTaskRunner> test_task_runner(
       new TestSimpleTaskRunner());
@@ skipping 142 matching lines @@
       scoped_refptr<TestSimpleTaskRunner>(new TestSimpleTaskRunner()).get(),
       FROM_HERE,
       Bind(&DoNothing)));
 }
 
 TEST_F(CancelableTaskTrackerDeathTest, PostFromDifferentThread) {
   Thread bad_thread("bad thread");
   ASSERT_TRUE(bad_thread.Start());
 
   bad_thread.task_runner()->PostTask(
-      FROM_HERE, Bind(&MaybeRunDeadlyTaskTrackerMemberFunction,
-                      Unretained(&task_tracker_), Bind(&PostDoNothingTask)));
+      FROM_HERE,
+      BindOnce(&MaybeRunDeadlyTaskTrackerMemberFunction,
+               Unretained(&task_tracker_), Bind(&PostDoNothingTask)));
 }
 
 void TryCancel(CancelableTaskTracker::TaskId task_id,
                CancelableTaskTracker* task_tracker) {
   task_tracker->TryCancel(task_id);
 }
 
 TEST_F(CancelableTaskTrackerDeathTest, CancelOnDifferentThread) {
   scoped_refptr<TestSimpleTaskRunner> test_task_runner(
       new TestSimpleTaskRunner());
 
   Thread bad_thread("bad thread");
   ASSERT_TRUE(bad_thread.Start());
 
   CancelableTaskTracker::TaskId task_id = task_tracker_.PostTask(
       test_task_runner.get(), FROM_HERE, Bind(&DoNothing));
   EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
 
   bad_thread.task_runner()->PostTask(
-      FROM_HERE, Bind(&MaybeRunDeadlyTaskTrackerMemberFunction,
-                      Unretained(&task_tracker_), Bind(&TryCancel, task_id)));
+      FROM_HERE,
+      BindOnce(&MaybeRunDeadlyTaskTrackerMemberFunction,
+               Unretained(&task_tracker_), Bind(&TryCancel, task_id)));
 
   test_task_runner->RunUntilIdle();
 }
 
 TEST_F(CancelableTaskTrackerDeathTest, CancelAllOnDifferentThread) {
   scoped_refptr<TestSimpleTaskRunner> test_task_runner(
       new TestSimpleTaskRunner());
 
   Thread bad_thread("bad thread");
   ASSERT_TRUE(bad_thread.Start());
 
   CancelableTaskTracker::TaskId task_id = task_tracker_.PostTask(
       test_task_runner.get(), FROM_HERE, Bind(&DoNothing));
   EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
 
   bad_thread.task_runner()->PostTask(
-      FROM_HERE,
-      Bind(&MaybeRunDeadlyTaskTrackerMemberFunction, Unretained(&task_tracker_),
-           Bind(&CancelableTaskTracker::TryCancelAll)));
+      FROM_HERE, BindOnce(&MaybeRunDeadlyTaskTrackerMemberFunction,
+                          Unretained(&task_tracker_),
+                          Bind(&CancelableTaskTracker::TryCancelAll)));
 
   test_task_runner->RunUntilIdle();
 }
 
 }  // namespace base