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

base/message_loop/message_pump_perftest.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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 47 matching lines @@
       maximum = std::max(maximum, laptime);
     } while (now - start < base::TimeDelta::FromSeconds(kTargetTimeSec));
 
     scheduling_times_[index] = now - start;
     if (ThreadTicks::IsSupported())
       scheduling_thread_times_[index] =
           base::ThreadTicks::Now() - thread_start;
     min_batch_times_[index] = minimum;
     max_batch_times_[index] = maximum;
     target_message_loop()->task_runner()->PostTask(
-        FROM_HERE, base::Bind(&ScheduleWorkTest::Increment,
-                              base::Unretained(this), schedule_calls));
+        FROM_HERE, base::BindOnce(&ScheduleWorkTest::Increment,
+                                  base::Unretained(this), schedule_calls));
   }
 
   void ScheduleWork(MessageLoop::Type target_type, int num_scheduling_threads) {
 #if defined(OS_ANDROID)
     if (target_type == MessageLoop::TYPE_JAVA) {
       java_thread_.reset(new android::JavaHandlerThread("target"));
       java_thread_->Start();
     } else
 #endif
     {
@@ skipping 14 matching lines @@
     min_batch_times_.reset(new base::TimeDelta[num_scheduling_threads]);
     max_batch_times_.reset(new base::TimeDelta[num_scheduling_threads]);
 
     for (int i = 0; i < num_scheduling_threads; ++i) {
       scheduling_threads.push_back(MakeUnique<Thread>("posting thread"));
       scheduling_threads[i]->Start();
     }
 
     for (int i = 0; i < num_scheduling_threads; ++i) {
       scheduling_threads[i]->task_runner()->PostTask(
-          FROM_HERE,
-          base::Bind(&ScheduleWorkTest::Schedule, base::Unretained(this), i));
+          FROM_HERE, base::BindOnce(&ScheduleWorkTest::Schedule,
+                                    base::Unretained(this), i));
     }
 
     for (int i = 0; i < num_scheduling_threads; ++i) {
       scheduling_threads[i]->Stop();
     }
 #if defined(OS_ANDROID)
     if (target_type == MessageLoop::TYPE_JAVA) {
       java_thread_->Stop();
       java_thread_.reset();
     } else
@@ skipping 140 matching lines @@
   void Run(int batch_size, int tasks_per_reload) {
     base::TimeTicks start = base::TimeTicks::Now();
     base::TimeTicks now;
     MessageLoop loop(std::unique_ptr<MessagePump>(new FakeMessagePump));
     scoped_refptr<internal::IncomingTaskQueue> queue(
         new internal::IncomingTaskQueue(&loop));
     uint32_t num_posted = 0;
     do {
       for (int i = 0; i < batch_size; ++i) {
         for (int j = 0; j < tasks_per_reload; ++j) {
-          queue->AddToIncomingQueue(
-              FROM_HERE, base::Bind(&DoNothing), base::TimeDelta(), false);
+          queue->AddToIncomingQueue(FROM_HERE, base::BindOnce(&DoNothing),
+                                    base::TimeDelta(), false);
           num_posted++;
         }
         TaskQueue loop_local_queue;
         queue->ReloadWorkQueue(&loop_local_queue);
         while (!loop_local_queue.empty()) {
           PendingTask t = std::move(loop_local_queue.front());
           loop_local_queue.pop();
           loop.RunTask(&t);
         }
       }
@@ skipping 17 matching lines @@
 
 TEST_F(PostTaskTest, TenTasksPerReload) {
   Run(10000, 10);
 }
 
 TEST_F(PostTaskTest, OneHundredTasksPerReload) {
   Run(1000, 100);
 }
 
 }  // namespace base