Replace Closure in TaskRunner::PostTask with OneShotCallback

base/test/test_mock_time_task_runner.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/test/test_mock_time_task_runner.h"
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
@@ skipping 59 matching lines @@
 }  // namespace
 
 // TestMockTimeTaskRunner::TestOrderedPendingTask -----------------------------
 
 // Subclass of TestPendingTask which has a strictly monotonically increasing ID
 // for every task, so that tasks posted with the same 'time to run' can be run
 // in the order of being posted.
 struct TestMockTimeTaskRunner::TestOrderedPendingTask
     : public base::TestPendingTask {
   TestOrderedPendingTask();
+  TestOrderedPendingTask(TestOrderedPendingTask&&) = default;
   TestOrderedPendingTask(const tracked_objects::Location& location,
-                         const Closure& task,
+                         OnceClosure task,
                          TimeTicks post_time,
                          TimeDelta delay,
                          size_t ordinal,
                          TestNestability nestability);
   ~TestOrderedPendingTask();
+  TestOrderedPendingTask& operator=(TestOrderedPendingTask&&) = default;
 
   size_t ordinal;
 };
 
 TestMockTimeTaskRunner::TestOrderedPendingTask::TestOrderedPendingTask()
     : ordinal(0) {
 }
 
 TestMockTimeTaskRunner::TestOrderedPendingTask::TestOrderedPendingTask(
     const tracked_objects::Location& location,
-    const Closure& task,
+    OnceClosure task,
     TimeTicks post_time,
     TimeDelta delay,
     size_t ordinal,
     TestNestability nestability)
-    : base::TestPendingTask(location, task, post_time, delay, nestability),
-      ordinal(ordinal) {
-}
+    : base::TestPendingTask(location,
+                            std::move(task),
+                            post_time,
+                            delay,
+                            nestability),
+      ordinal(ordinal) {}
 
 TestMockTimeTaskRunner::TestOrderedPendingTask::~TestOrderedPendingTask() {
 }
 
 // TestMockTimeTaskRunner -----------------------------------------------------
 
 bool TestMockTimeTaskRunner::TemporalOrder::operator()(
     const TestOrderedPendingTask& first_task,
     const TestOrderedPendingTask& second_task) const {
   if (first_task.GetTimeToRun() == second_task.GetTimeToRun())
@@ skipping 73 matching lines @@
   return tasks_.empty() ? TimeDelta::Max()
                         : tasks_.top().GetTimeToRun() - now_ticks_;
 }
 
 bool TestMockTimeTaskRunner::RunsTasksOnCurrentThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
 bool TestMockTimeTaskRunner::PostDelayedTask(
     const tracked_objects::Location& from_here,
-    const Closure& task,
+    OnceClosure task,
     TimeDelta delay) {
   AutoLock scoped_lock(tasks_lock_);
-  tasks_.push(TestOrderedPendingTask(from_here, task, now_ticks_, delay,
-                                     next_task_ordinal_++,
+  tasks_.push(TestOrderedPendingTask(from_here, std::move(task), now_ticks_,
+                                     delay, next_task_ordinal_++,
                                      TestPendingTask::NESTABLE));
   return true;
 }
 
 bool TestMockTimeTaskRunner::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
-    const Closure& task,
+    OnceClosure task,
     TimeDelta delay) {
-  return PostDelayedTask(from_here, task, delay);
+  return PostDelayedTask(from_here, std::move(task), delay);
 }
 
 bool TestMockTimeTaskRunner::IsElapsingStopped() {
   return false;
 }
 
 void TestMockTimeTaskRunner::OnBeforeSelectingTask() {
   // Empty default implementation.
 }
 
@@ skipping 10 matching lines @@
   const TimeTicks original_now_ticks = now_ticks_;
   while (!IsElapsingStopped()) {
     OnBeforeSelectingTask();
     TestPendingTask task_info;
     if (!DequeueNextTask(original_now_ticks, max_delta, &task_info))
       break;
     // If tasks were posted with a negative delay, task_info.GetTimeToRun() will
     // be less than |now_ticks_|. ForwardClocksUntilTickTime() takes care of not
     // moving the clock backwards in this case.
     ForwardClocksUntilTickTime(task_info.GetTimeToRun());
-    task_info.task.Run();
+    std::move(task_info.task).Run();
     OnAfterTaskRun();
   }
 }
 
 void TestMockTimeTaskRunner::ForwardClocksUntilTickTime(TimeTicks later_ticks) {
   if (later_ticks <= now_ticks_)
     return;
 
   now_ += later_ticks - now_ticks_;
   now_ticks_ = later_ticks;
   OnAfterTimePassed();
 }
 
 bool TestMockTimeTaskRunner::DequeueNextTask(const TimeTicks& reference,
                                              const TimeDelta& max_delta,
                                              TestPendingTask* next_task) {
   AutoLock scoped_lock(tasks_lock_);
   if (!tasks_.empty() &&
       (tasks_.top().GetTimeToRun() - reference) <= max_delta) {
-    *next_task = tasks_.top();
+    *next_task = std::move(const_cast<TestOrderedPendingTask&>(tasks_.top()));
     tasks_.pop();
     return true;
   }
   return false;
 }
 
 }  // namespace base