Migrate base::TaskRunner from Closure to OnceClosure

content/browser/startup_task_runner_unittest.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 "content/browser/startup_task_runner.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 70 matching lines @@
                bool(const tracked_objects::Location&, base::TimeDelta));
   MOCK_METHOD2(PostNonNestableDelayedTask,
                bool(const tracked_objects::Location&, base::TimeDelta));
 };
 
 class TaskRunnerProxy : public base::SingleThreadTaskRunner {
  public:
   TaskRunnerProxy(MockTaskRunner* mock) : mock_(mock) {}
   bool RunsTasksOnCurrentThread() const override { return true; }
   bool PostDelayedTask(const tracked_objects::Location& location,
-                       base::Closure closure,
+                       base::OnceClosure closure,
                        base::TimeDelta delta) override {
     last_task_ = std::move(closure);
     return mock_->PostDelayedTask(location, delta);
   }
   bool PostNonNestableDelayedTask(const tracked_objects::Location& location,
-                                  base::Closure closure,
+                                  base::OnceClosure closure,
                                   base::TimeDelta delta) override {
     last_task_ = std::move(closure);
     return mock_->PostNonNestableDelayedTask(location, delta);
   }
 
-  base::Closure TakeLastTaskClosure() { return std::move(last_task_); }
+  base::OnceClosure TakeLastTaskClosure() { return std::move(last_task_); }
 
  private:
   ~TaskRunnerProxy() override {}
 
   MockTaskRunner* mock_;
-  base::Closure last_task_;
+  base::OnceClosure last_task_;
 };
 
 TEST_F(StartupTaskRunnerTest, SynchronousExecution) {
   MockTaskRunner mock_runner;
   scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner);
 
   EXPECT_CALL(mock_runner, PostDelayedTask(_, _)).Times(0);
   EXPECT_CALL(mock_runner, PostNonNestableDelayedTask(_, _)).Times(0);
 
   StartupTaskRunner runner(base::Bind(&Observer), proxy);
@@ skipping 184 matching lines @@
   EXPECT_EQ(observer_calls, 1);
   EXPECT_EQ(observer_result, 1);
 
   // Check that running synchronously now doesn't do anything
   runner.RunAllTasksNow();
   EXPECT_EQ(observer_calls, 1);
   EXPECT_EQ(task_count, 1);
 }
 }  // namespace
 }  // namespace content