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

base/trace_event/memory_dump_manager_unittest.cc

 // Copyright 2015 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/trace_event/memory_dump_manager.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 91 matching lines @@
     quit_closure.Run();
 }
 
 // Posts |task| to |task_runner| and blocks until it is executed.
 void PostTaskAndWait(const tracked_objects::Location& from_here,
                      SequencedTaskRunner* task_runner,
                      base::OnceClosure task) {
   base::WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
                             WaitableEvent::InitialState::NOT_SIGNALED);
   task_runner->PostTask(from_here, std::move(task));
-  task_runner->PostTask(
-      FROM_HERE, base::Bind(&WaitableEvent::Signal, base::Unretained(&event)));
+  task_runner->PostTask(FROM_HERE, base::BindOnce(&WaitableEvent::Signal,
+                                                  base::Unretained(&event)));
   // The SequencedTaskRunner guarantees that |event| will only be signaled after
   // |task| is executed.
   event.Wait();
 }
 
 // Testing MemoryDumpManagerDelegate which, by default, short-circuits dump
 // requests locally to the MemoryDumpManager instead of performing IPC dances.
 class MemoryDumpManagerDelegateForTesting : public MemoryDumpManagerDelegate {
  public:
   MemoryDumpManagerDelegateForTesting(bool is_coordinator)
@@ skipping 603 matching lines @@
   // When OnMemoryDump is called on either of the dump providers, it will
   // unregister the other one.
   for (const std::unique_ptr<MockMemoryDumpProvider>& mdp : mdps) {
     int other_idx = (mdps.front() == mdp);
     // TestIOThread's task runner must be obtained from the main thread but can
     // then be used from other threads.
     scoped_refptr<SingleThreadTaskRunner> other_runner =
         threads[other_idx]->task_runner();
     MockMemoryDumpProvider* other_mdp = mdps[other_idx].get();
     auto on_dump = [this, other_runner, other_mdp, &on_memory_dump_call_count](
-        const MemoryDumpArgs& args, ProcessMemoryDump* pmd) {
+                       const MemoryDumpArgs& args, ProcessMemoryDump* pmd) {
       PostTaskAndWait(FROM_HERE, other_runner.get(),
-                      base::Bind(&MemoryDumpManager::UnregisterDumpProvider,
-                                 base::Unretained(&*mdm_), other_mdp));
+                      base::BindOnce(&MemoryDumpManager::UnregisterDumpProvider,
+                                     base::Unretained(&*mdm_), other_mdp));
       on_memory_dump_call_count++;
       return true;
     };
 
     // OnMemoryDump is called once for the provider that dumps first, and zero
     // times for the other provider.
     EXPECT_CALL(*mdp, OnMemoryDump(_, _))
         .Times(AtMost(1))
         .WillOnce(Invoke(on_dump));
   }
@@ skipping 97 matching lines @@
 
   // When OnMemoryDump is called on either of the dump providers, it will
   // tear down the thread of the other one.
   for (const std::unique_ptr<MockMemoryDumpProvider>& mdp : mdps) {
     int other_idx = (mdps.front() == mdp);
     TestIOThread* other_thread = threads[other_idx].get();
     // TestIOThread isn't thread-safe and must be stopped on the |main_runner|.
     scoped_refptr<SequencedTaskRunner> main_runner =
         SequencedTaskRunnerHandle::Get();
     auto on_dump = [other_thread, main_runner, &on_memory_dump_call_count](
-        const MemoryDumpArgs& args, ProcessMemoryDump* pmd) {
+                       const MemoryDumpArgs& args, ProcessMemoryDump* pmd) {
       PostTaskAndWait(
           FROM_HERE, main_runner.get(),
-          base::Bind(&TestIOThread::Stop, base::Unretained(other_thread)));
+          base::BindOnce(&TestIOThread::Stop, base::Unretained(other_thread)));
       on_memory_dump_call_count++;
       return true;
     };
 
     // OnMemoryDump is called once for the provider that dumps first, and zero
     // times for the other provider.
     EXPECT_CALL(*mdp, OnMemoryDump(_, _))
         .Times(AtMost(1))
         .WillOnce(Invoke(on_dump));
   }
@@ skipping 331 matching lines @@
   mdp->enable_mock_destructor = true;
   RegisterDumpProvider(mdp.get(), nullptr, kDefaultOptions);
 
   base::PlatformThreadRef thread_ref;
   auto self_unregister_from_another_thread = [&mdp, &thread_ref](
       const MemoryDumpArgs&, ProcessMemoryDump*) -> bool {
     thread_ref = PlatformThread::CurrentRef();
     TestIOThread thread_for_unregistration(TestIOThread::kAutoStart);
     PostTaskAndWait(
         FROM_HERE, thread_for_unregistration.task_runner().get(),
-        base::Bind(
+        base::BindOnce(
             &MemoryDumpManager::UnregisterAndDeleteDumpProviderSoon,
             base::Unretained(MemoryDumpManager::GetInstance()),
             base::Passed(std::unique_ptr<MemoryDumpProvider>(std::move(mdp)))));
     thread_for_unregistration.Stop();
     return true;
   };
   EXPECT_CALL(*mdp, OnMemoryDump(_, _))
       .Times(1)
       .WillOnce(Invoke(self_unregister_from_another_thread));
   EXPECT_CALL(*mdp, Destructor())
@@ skipping 78 matching lines @@
   thread.Start();
   RegisterDumpProvider(&mdp1, thread.task_runner(), kDefaultOptions,
                        "BlacklistTestDumpProvider");
   // Unregistering on wrong thread should not crash.
   mdm_->UnregisterDumpProvider(&mdp1);
   thread.Stop();
 }
 
 }  // namespace trace_event
 }  // namespace base