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

base/message_loop/message_loop_task_runner_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/message_loop/message_loop_task_runner.h"
 
 #include <memory>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
@@ skipping 20 matching lines @@
   void DeleteCurrentMessageLoop() { current_loop_.reset(); }
 
  protected:
   void SetUp() override {
     // Use SetUp() instead of the constructor to avoid posting a task to a
     // partially constructed object.
     task_thread_.Start();
 
     // Allow us to pause the |task_thread_|'s MessageLoop.
     task_thread_.task_runner()->PostTask(
-        FROM_HERE, Bind(&MessageLoopTaskRunnerTest::BlockTaskThreadHelper,
-                        Unretained(this)));
+        FROM_HERE, BindOnce(&MessageLoopTaskRunnerTest::BlockTaskThreadHelper,
+                            Unretained(this)));
   }
 
   void TearDown() override {
     // Make sure the |task_thread_| is not blocked, and stop the thread
     // fully before destruction because its tasks may still depend on the
     // |thread_sync_| event.
     thread_sync_.Signal();
     task_thread_.Stop();
     DeleteCurrentMessageLoop();
   }
@@ skipping 54 matching lines @@
   MessageLoop* reply_run_on = NULL;
   MessageLoop* reply_deleted_on = NULL;
   int reply_delete_order = -1;
 
   scoped_refptr<LoopRecorder> task_recorder =
       new LoopRecorder(&task_run_on, &task_deleted_on, &task_delete_order);
   scoped_refptr<LoopRecorder> reply_recorder =
       new LoopRecorder(&reply_run_on, &reply_deleted_on, &reply_delete_order);
 
   ASSERT_TRUE(task_thread_.task_runner()->PostTaskAndReply(
-      FROM_HERE, Bind(&RecordLoop, task_recorder),
-      Bind(&RecordLoopAndQuit, reply_recorder)));
+      FROM_HERE, BindOnce(&RecordLoop, task_recorder),
+      BindOnce(&RecordLoopAndQuit, reply_recorder)));
 
   // Die if base::Bind doesn't retain a reference to the recorders.
   task_recorder = NULL;
   reply_recorder = NULL;
   ASSERT_FALSE(task_deleted_on);
   ASSERT_FALSE(reply_deleted_on);
 
   UnblockTaskThread();
   RunLoop().Run();
 
@@ skipping 16 matching lines @@
       new LoopRecorder(&task_run_on, &task_deleted_on, &task_delete_order);
   scoped_refptr<LoopRecorder> reply_recorder =
       new LoopRecorder(&reply_run_on, &reply_deleted_on, &reply_delete_order);
 
   // Grab a task runner to a dead MessageLoop.
   scoped_refptr<SingleThreadTaskRunner> task_runner =
       task_thread_.task_runner();
   UnblockTaskThread();
   task_thread_.Stop();
 
-  ASSERT_FALSE(
-      task_runner->PostTaskAndReply(FROM_HERE, Bind(&RecordLoop, task_recorder),
-                                    Bind(&RecordLoopAndQuit, reply_recorder)));
+  ASSERT_FALSE(task_runner->PostTaskAndReply(
+      FROM_HERE, BindOnce(&RecordLoop, task_recorder),
+      BindOnce(&RecordLoopAndQuit, reply_recorder)));
 
   // The relay should have properly deleted its resources leaving us as the only
   // reference.
   EXPECT_EQ(task_delete_order, reply_delete_order);
   ASSERT_TRUE(task_recorder->HasOneRef());
   ASSERT_TRUE(reply_recorder->HasOneRef());
 
   // Nothing should have run though.
   EXPECT_FALSE(task_run_on);
   EXPECT_FALSE(reply_run_on);
 }
 
 TEST_F(MessageLoopTaskRunnerTest, PostTaskAndReply_SameLoop) {
   MessageLoop* task_run_on = NULL;
   MessageLoop* task_deleted_on = NULL;
   int task_delete_order = -1;
   MessageLoop* reply_run_on = NULL;
   MessageLoop* reply_deleted_on = NULL;
   int reply_delete_order = -1;
 
   scoped_refptr<LoopRecorder> task_recorder =
       new LoopRecorder(&task_run_on, &task_deleted_on, &task_delete_order);
   scoped_refptr<LoopRecorder> reply_recorder =
       new LoopRecorder(&reply_run_on, &reply_deleted_on, &reply_delete_order);
 
   // Enqueue the relay.
   ASSERT_TRUE(current_loop_->task_runner()->PostTaskAndReply(
-      FROM_HERE, Bind(&RecordLoop, task_recorder),
-      Bind(&RecordLoopAndQuit, reply_recorder)));
+      FROM_HERE, BindOnce(&RecordLoop, task_recorder),
+      BindOnce(&RecordLoopAndQuit, reply_recorder)));
 
   // Die if base::Bind doesn't retain a reference to the recorders.
   task_recorder = NULL;
   reply_recorder = NULL;
   ASSERT_FALSE(task_deleted_on);
   ASSERT_FALSE(reply_deleted_on);
 
   RunLoop().Run();
 
   EXPECT_EQ(current_loop_.get(), task_run_on);
@@ skipping 14 matching lines @@
   MessageLoop* reply_deleted_on = NULL;
   int reply_delete_order = -1;
 
   scoped_refptr<LoopRecorder> task_recorder =
       new LoopRecorder(&task_run_on, &task_deleted_on, &task_delete_order);
   scoped_refptr<LoopRecorder> reply_recorder =
       new LoopRecorder(&reply_run_on, &reply_deleted_on, &reply_delete_order);
 
   // Enqueue the relay.
   task_thread_.task_runner()->PostTaskAndReply(
-      FROM_HERE, Bind(&RecordLoop, task_recorder),
-      Bind(&RecordLoopAndQuit, reply_recorder));
+      FROM_HERE, BindOnce(&RecordLoop, task_recorder),
+      BindOnce(&RecordLoopAndQuit, reply_recorder));
 
   // Die if base::Bind doesn't retain a reference to the recorders.
   task_recorder = NULL;
   reply_recorder = NULL;
   ASSERT_FALSE(task_deleted_on);
   ASSERT_FALSE(reply_deleted_on);
 
   UnblockTaskThread();
 
   // Mercilessly whack the current loop before |reply| gets to run.
@@ skipping 91 matching lines @@
 
 TEST_F(MessageLoopTaskRunnerThreadingTest, Delete) {
   DeletedOnFile* deleted_on_file = new DeletedOnFile(this);
   EXPECT_TRUE(
       file_thread_->task_runner()->DeleteSoon(FROM_HERE, deleted_on_file));
   RunLoop().Run();
 }
 
 TEST_F(MessageLoopTaskRunnerThreadingTest, PostTask) {
   EXPECT_TRUE(file_thread_->task_runner()->PostTask(
-      FROM_HERE, Bind(&MessageLoopTaskRunnerThreadingTest::BasicFunction,
-                      Unretained(this))));
+      FROM_HERE, BindOnce(&MessageLoopTaskRunnerThreadingTest::BasicFunction,
+                          Unretained(this))));
   RunLoop().Run();
 }
 
 TEST_F(MessageLoopTaskRunnerThreadingTest, PostTaskAfterThreadExits) {
   std::unique_ptr<Thread> test_thread(
       new Thread("MessageLoopTaskRunnerThreadingTest_Dummy"));
   test_thread->Start();
   scoped_refptr<SingleThreadTaskRunner> task_runner =
       test_thread->task_runner();
   test_thread->Stop();
 
   bool ret = task_runner->PostTask(
-      FROM_HERE, Bind(&MessageLoopTaskRunnerThreadingTest::AssertNotRun));
+      FROM_HERE, BindOnce(&MessageLoopTaskRunnerThreadingTest::AssertNotRun));
   EXPECT_FALSE(ret);
 }
 
 TEST_F(MessageLoopTaskRunnerThreadingTest, PostTaskAfterThreadIsDeleted) {
   scoped_refptr<SingleThreadTaskRunner> task_runner;
   {
     std::unique_ptr<Thread> test_thread(
         new Thread("MessageLoopTaskRunnerThreadingTest_Dummy"));
     test_thread->Start();
     task_runner = test_thread->task_runner();
   }
   bool ret = task_runner->PostTask(
-      FROM_HERE, Bind(&MessageLoopTaskRunnerThreadingTest::AssertNotRun));
+      FROM_HERE, BindOnce(&MessageLoopTaskRunnerThreadingTest::AssertNotRun));
   EXPECT_FALSE(ret);
 }
 
 }  // namespace base