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

base/test/launcher/test_launcher.cc

 // Copyright 2013 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/test/launcher/test_launcher.h"
 
 #include <memory>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 454 matching lines @@
   std::string output_file_contents;
   CHECK(ReadFileToString(output_file, &output_file_contents));
 
   if (!DeleteFile(output_file, false)) {
     // This needs to be non-fatal at least for Windows.
     LOG(WARNING) << "Failed to delete " << output_file.AsUTF8Unsafe();
   }
 
   // Run target callback on the thread it was originating from, not on
   // a worker pool thread.
-  task_runner->PostTask(
-      FROM_HERE,
-      Bind(&RunCallback, completed_callback, exit_code,
-           TimeTicks::Now() - start_time, was_timeout, output_file_contents));
+  task_runner->PostTask(FROM_HERE,
+                        BindOnce(&RunCallback, completed_callback, exit_code,
+                                 TimeTicks::Now() - start_time, was_timeout,
+                                 output_file_contents));
 }
 
 }  // namespace
 
 const char kGTestBreakOnFailure[] = "gtest_break_on_failure";
 const char kGTestFilterFlag[] = "gtest_filter";
 const char kGTestFlagfileFlag[] = "gtest_flagfile";
 const char kGTestHelpFlag[]   = "gtest_help";
 const char kGTestListTestsFlag[] = "gtest_list_tests";
 const char kGTestRepeatFlag[] = "gtest_repeat";
@@ skipping 48 matching lines @@
   CHECK_EQ(0, sigaction(SIGTERM, &action, NULL));
 
   auto controller = base::FileDescriptorWatcher::WatchReadable(
       g_shutdown_pipe[0], base::Bind(&OnShutdownPipeReadable));
 #endif  // defined(OS_POSIX)
 
   // Start the watchdog timer.
   watchdog_timer_.Reset();
 
   ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, Bind(&TestLauncher::RunTestIteration, Unretained(this)));
+      FROM_HERE, BindOnce(&TestLauncher::RunTestIteration, Unretained(this)));
 
   RunLoop().Run();
 
   if (requested_cycles != 1)
     results_tracker_.PrintSummaryOfAllIterations();
 
   MaybeSaveSummaryAsJSON(std::vector<std::string>());
 
   return run_result_;
 }
@@ skipping 11 matching lines @@
   CommandLine new_command_line(
       PrepareCommandLineForGTest(command_line, wrapper));
 
   // When running in parallel mode we need to redirect stdio to avoid mixed-up
   // output. We also always redirect on the bots to get the test output into
   // JSON summary.
   bool redirect_stdio = (parallel_jobs_ > 1) || BotModeEnabled();
 
   GetTaskRunner()->PostTask(
       FROM_HERE,
-      Bind(&DoLaunchChildTestProcess, new_command_line, timeout, options,
-           redirect_stdio, RetainedRef(ThreadTaskRunnerHandle::Get()),
-           Bind(&TestLauncher::OnLaunchTestProcessFinished, Unretained(this),
-                completed_callback),
-           launched_callback));
+      BindOnce(&DoLaunchChildTestProcess, new_command_line, timeout, options,
+               redirect_stdio, RetainedRef(ThreadTaskRunnerHandle::Get()),
+               Bind(&TestLauncher::OnLaunchTestProcessFinished,
+                    Unretained(this), completed_callback),
+               launched_callback));
 }
 
 void TestLauncher::OnTestFinished(const TestResult& original_result) {
   ++test_finished_count_;
 
   TestResult result(original_result);
 
   if (result.output_snippet.length() > kOutputSnippetBytesLimit) {
     if (result.status == TestResult::TEST_SUCCESS)
       result.status = TestResult::TEST_EXCESSIVE_OUTPUT;
@@ skipping 470 matching lines @@
   MaybeSaveSummaryAsJSON({"EARLY_SUMMARY", kUnreliableResultsTag});
 
   test_started_count_ = launcher_delegate_->RunTests(this, test_names);
 
   if (test_started_count_ == 0) {
     fprintf(stdout, "0 tests run\n");
     fflush(stdout);
 
     // No tests have actually been started, so kick off the next iteration.
     ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, Bind(&TestLauncher::RunTestIteration, Unretained(this)));
+        FROM_HERE, BindOnce(&TestLauncher::RunTestIteration, Unretained(this)));
   }
 }
 
 void TestLauncher::RunTestIteration() {
   const bool stop_on_failure =
       CommandLine::ForCurrentProcess()->HasSwitch(kGTestBreakOnFailure);
   if (cycles_ == 0 ||
       (stop_on_failure && test_success_count_ != test_finished_count_)) {
     MessageLoop::current()->QuitWhenIdle();
     return;
   }
 
   // Special value "-1" means "repeat indefinitely".
   cycles_ = (cycles_ == -1) ? cycles_ : cycles_ - 1;
 
   test_found_count_ = 0;
   test_started_count_ = 0;
   test_finished_count_ = 0;
   test_success_count_ = 0;
   test_broken_count_ = 0;
   retry_count_ = 0;
   tests_to_retry_.clear();
   results_tracker_.OnTestIterationStarting();
 
   ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, Bind(&TestLauncher::RunTests, Unretained(this)));
+      FROM_HERE, BindOnce(&TestLauncher::RunTests, Unretained(this)));
 }
 
 void TestLauncher::MaybeSaveSummaryAsJSON(
     const std::vector<std::string>& additional_tags) {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kTestLauncherSummaryOutput)) {
     FilePath summary_path(command_line->GetSwitchValuePath(
                               switches::kTestLauncherSummaryOutput));
     if (!results_tracker_.SaveSummaryAsJSON(summary_path, additional_tags)) {
       LOG(ERROR) << "Failed to save test launcher output summary.";
@@ skipping 34 matching lines @@
   } else {
     // Signal failure, but continue to run all requested test iterations.
     // With the summary of all iterations at the end this is a good default.
     run_result_ = false;
   }
 
   results_tracker_.PrintSummaryOfCurrentIteration();
 
   // Kick off the next iteration.
   ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, Bind(&TestLauncher::RunTestIteration, Unretained(this)));
+      FROM_HERE, BindOnce(&TestLauncher::RunTestIteration, Unretained(this)));
 }
 
 void TestLauncher::OnOutputTimeout() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   AutoLock lock(*GetLiveProcessesLock());
 
   fprintf(stdout, "Still waiting for the following processes to finish:\n");
 
   for (const auto& pair : *GetLiveProcesses()) {
@@ skipping 46 matching lines @@
   }
 
   std::string snippet(full_output.substr(run_pos));
   if (end_pos != std::string::npos)
     snippet = full_output.substr(run_pos, end_pos - run_pos);
 
   return snippet;
 }
 
 }  // namespace base