Migrate base::TaskRunner from Closure to OnceClosure

chrome/browser/after_startup_task_utils_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 "chrome/browser/after_startup_task_utils.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 13 matching lines @@
 using content::TestBrowserThreadBundle;
 
 namespace {
 
 class WrappedTaskRunner : public base::TaskRunner {
  public:
   explicit WrappedTaskRunner(const scoped_refptr<TaskRunner>& real_runner)
       : real_task_runner_(real_runner) {}
 
   bool PostDelayedTask(const tracked_objects::Location& from_here,
-                       base::Closure task,
+                       base::OnceClosure task,
                        base::TimeDelta delay) override {
     ++posted_task_count_;
     return real_task_runner_->PostDelayedTask(
         from_here,
-        base::Bind(&WrappedTaskRunner::RunWrappedTask, this, std::move(task)),
+        base::BindOnce(&WrappedTaskRunner::RunWrappedTask, this,
+                       std::move(task)),
         base::TimeDelta());  // Squash all delays so our tests complete asap.
   }
 
   bool RunsTasksOnCurrentThread() const override {
     return real_task_runner_->RunsTasksOnCurrentThread();
   }
 
   base::TaskRunner* real_runner() const { return real_task_runner_.get(); }
 
   int total_task_count() const { return posted_task_count_ + ran_task_count_; }
   int posted_task_count() const { return posted_task_count_; }
   int ran_task_count() const { return ran_task_count_; }
 
   void reset_task_counts() {
     posted_task_count_ = 0;
     ran_task_count_ = 0;
   }
 
  private:
   ~WrappedTaskRunner() override {}
 
-  void RunWrappedTask(base::Closure task) {
+  void RunWrappedTask(base::OnceClosure task) {
     ++ran_task_count_;
     std::move(task).Run();
   }
 
   scoped_refptr<TaskRunner> real_task_runner_;
   int posted_task_count_ = 0;
   int ran_task_count_ = 0;
 };
 
 }  // namespace
@@ skipping 19 matching lines @@
         base::Bind(&AfterStartupTaskTest::GotIsOnBrowserStartupComplete,
                    &run_loop, &is_complete));
     run_loop.Run();
     return is_complete;
   }
 
   // Hop to the db thread and call PostAfterStartupTask.
   void PostAfterStartupTaskFromDBThread(
       const tracked_objects::Location& from_here,
       const scoped_refptr<base::TaskRunner>& task_runner,
-      base::Closure task) {
+      base::OnceClosure task) {
     RunLoop run_loop;
     db_thread_->real_runner()->PostTaskAndReply(
         FROM_HERE,
-        base::Bind(&AfterStartupTaskUtils::PostTask, from_here, task_runner,
-                   std::move(task)),
+        base::BindOnce(&AfterStartupTaskUtils::PostTask, from_here, task_runner,
+                       std::move(task)),
         base::Bind(&RunLoop::Quit, base::Unretained(&run_loop)));
     run_loop.Run();
   }
 
   // Make sure all tasks posted to the DB thread get run.
   void FlushDBThread() {
     RunLoop run_loop;
     db_thread_->real_runner()->PostTaskAndReply(
         FROM_HERE, base::Bind(&base::DoNothing),
         base::Bind(&RunLoop::Quit, base::Unretained(&run_loop)));
@@ skipping 103 matching lines @@
 
   AfterStartupTaskUtils::SetBrowserStartupIsCompleteForTesting();
   EXPECT_EQ(1, db_thread_->posted_task_count());
 
   FlushDBThread();
   RunLoop().RunUntilIdle();
   EXPECT_EQ(1, db_thread_->ran_task_count());
 
   EXPECT_EQ(0, ui_thread_->total_task_count());
 }