Use OnceClosure in TestPendingTask

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 65 matching lines @@
 // in the order of being posted.
 struct TestMockTimeTaskRunner::TestOrderedPendingTask
     : public base::TestPendingTask {
   TestOrderedPendingTask();
   TestOrderedPendingTask(const tracked_objects::Location& location,
                          const Closure& task,
                          TimeTicks post_time,
                          TimeDelta delay,
                          size_t ordinal,
                          TestNestability nestability);
+  TestOrderedPendingTask(TestOrderedPendingTask&&);
   ~TestOrderedPendingTask();
 
+  TestOrderedPendingTask& operator=(TestOrderedPendingTask&&);
+
   size_t ordinal;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestOrderedPendingTask);
 };
 
 TestMockTimeTaskRunner::TestOrderedPendingTask::TestOrderedPendingTask()
     : ordinal(0) {
 }
 
 TestMockTimeTaskRunner::TestOrderedPendingTask::TestOrderedPendingTask(
+    TestOrderedPendingTask&&) = default;
+
+TestMockTimeTaskRunner::TestOrderedPendingTask::TestOrderedPendingTask(
     const tracked_objects::Location& location,
     const Closure& task,
     TimeTicks post_time,
     TimeDelta delay,
     size_t ordinal,
     TestNestability nestability)
     : base::TestPendingTask(location, task, post_time, delay, nestability),
-      ordinal(ordinal) {
-}
+      ordinal(ordinal) {}
 
 TestMockTimeTaskRunner::TestOrderedPendingTask::~TestOrderedPendingTask() {
 }
 
+TestMockTimeTaskRunner::TestOrderedPendingTask&
+TestMockTimeTaskRunner::TestOrderedPendingTask::operator=(
+    TestOrderedPendingTask&&) = default;
+
 // TestMockTimeTaskRunner -----------------------------------------------------
 
 bool TestMockTimeTaskRunner::TemporalOrder::operator()(
     const TestOrderedPendingTask& first_task,
     const TestOrderedPendingTask& second_task) const {
   if (first_task.GetTimeToRun() == second_task.GetTimeToRun())
     return first_task.ordinal > second_task.ordinal;
   return first_task.GetTimeToRun() > second_task.GetTimeToRun();
 }
 
@@ skipping 50 matching lines @@
 }
 
 std::unique_ptr<TickClock> TestMockTimeTaskRunner::GetMockTickClock() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return MakeUnique<MockTickClock>(this);
 }
 
 std::deque<TestPendingTask> TestMockTimeTaskRunner::TakePendingTasks() {
   std::deque<TestPendingTask> tasks;
   while (!tasks_.empty()) {
-    tasks.push_back(tasks_.top());
+    tasks.push_back(
+        std::move(const_cast<TestOrderedPendingTask&>(tasks_.top())));

[dcheng, 2017/01/24 09:15:52]

Nit: comment here too.

[tzik, 2017/01/24 11:46:27]

Done.

     tasks_.pop();
   }
   return tasks;
 }
 
 bool TestMockTimeTaskRunner::HasPendingTask() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return !tasks_.empty();
 }
 
@@ skipping 51 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()));

[dcheng, 2017/01/24 09:15:52]

And here.

[tzik, 2017/01/24 11:46:27]

Done.

     tasks_.pop();
     return true;
   }
   return false;
 }
 
 }  // namespace base