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

base/threading/thread_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 <memory>
 #include <vector>
 
 #include "base/base_switches.h"
@@ skipping 49 matching lines @@
   void TimeOnThread(base::ThreadTicks* ticks, base::WaitableEvent* done) {
     *ticks = base::ThreadTicks::Now();
     done->Signal();
   }
 
   base::ThreadTicks ThreadNow(const base::Thread& thread) {
     base::WaitableEvent done(WaitableEvent::ResetPolicy::AUTOMATIC,
                              WaitableEvent::InitialState::NOT_SIGNALED);
     base::ThreadTicks ticks;
     thread.task_runner()->PostTask(
-        FROM_HERE, base::Bind(&ThreadPerfTest::TimeOnThread,
-                              base::Unretained(this), &ticks, &done));
+        FROM_HERE, base::BindOnce(&ThreadPerfTest::TimeOnThread,
+                                  base::Unretained(this), &ticks, &done));
     done.Wait();
     return ticks;
   }
 
   void RunPingPongTest(const std::string& name, unsigned num_threads) {
     // Create threads and collect starting cpu-time for each thread.
     std::vector<base::ThreadTicks> thread_starts;
     while (threads_.size() < num_threads) {
       threads_.push_back(MakeUnique<base::Thread>("PingPonger"));
       threads_.back()->Start();
@@ skipping 49 matching lines @@
   base::Thread* NextThread(int count) {
     return threads_[count % threads_.size()].get();
   }
 
   void PingPong(int hops) override {
     if (!hops) {
       FinishMeasurement();
       return;
     }
     NextThread(hops)->task_runner()->PostTask(
-        FROM_HERE, base::Bind(&ThreadPerfTest::PingPong, base::Unretained(this),
-                              hops - 1));
+        FROM_HERE, base::BindOnce(&ThreadPerfTest::PingPong,
+                                  base::Unretained(this), hops - 1));
   }
 };
 
 // This tries to test the 'best-case' as well as the 'worst-case' task posting
 // performance. The best-case keeps one thread alive such that it never yeilds,
 // while the worse-case forces a context switch for every task. Four threads are
 // used to ensure the threads do yeild (with just two it might be possible for
 // both threads to stay awake if they can signal each other fast enough).
 TEST_F(TaskPerfTest, TaskPingPong) {
   RunPingPongTest("1_Task_Threads", 1);
@@ skipping 50 matching lines @@
     // Once we are done, all threads will signal as hops passes zero.
     // We only signal completion once, on the thread that reaches zero.
     if (!my_hops)
       FinishMeasurement();
   }
 
   void PingPong(int hops) override {
     remaining_hops_ = hops;
     for (size_t i = 0; i < threads_.size(); i++) {
       threads_[i]->task_runner()->PostTask(
-          FROM_HERE, base::Bind(&EventPerfTest::WaitAndSignalOnThread,
-                                base::Unretained(this), i));
+          FROM_HERE, base::BindOnce(&EventPerfTest::WaitAndSignalOnThread,
+                                    base::Unretained(this), i));
     }
 
     // Kick off the Signal ping-ponging.
     events_.front()->Signal();
   }
 
   int remaining_hops_;
   std::vector<std::unique_ptr<WaitableEventType>> events_;
 };
 
@@ skipping 89 matching lines @@
 typedef EventPerfTest<PthreadEvent> PthreadEventPerfTest;
 TEST_F(PthreadEventPerfTest, EventPingPong) {
   RunPingPongTest("4_PthreadCondVar_Threads", 4);
 }
 
 #endif
 
 }  // namespace
 
 }  // namespace base