Split Closure part of TestPendingTask out of the struct

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 56 matching lines @@
   return task_runner_->Now();
 }
 
 }  // 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(const tracked_objects::Location& location,
-                         const Closure& task,
-                         TimeTicks post_time,
-                         TimeDelta delay,
-                         size_t ordinal,
-                         TestNestability nestability);
-  ~TestOrderedPendingTask();
+struct TestMockTimeTaskRunner::TestOrderedPendingTaskInfo
+    : public base::TestPendingTaskInfo {
+  TestOrderedPendingTaskInfo();
+  TestOrderedPendingTaskInfo(const tracked_objects::Location& location,
+                             TimeTicks post_time,
+                             TimeDelta delay,
+                             size_t ordinal,
+                             TestNestability nestability);
+  ~TestOrderedPendingTaskInfo();
 
   size_t ordinal;
 };
 
-TestMockTimeTaskRunner::TestOrderedPendingTask::TestOrderedPendingTask()
-    : ordinal(0) {
-}
+TestMockTimeTaskRunner::TestOrderedPendingTaskInfo::TestOrderedPendingTaskInfo()
+    : ordinal(0) {}
 
-TestMockTimeTaskRunner::TestOrderedPendingTask::TestOrderedPendingTask(
+TestMockTimeTaskRunner::TestOrderedPendingTaskInfo::TestOrderedPendingTaskInfo(
     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) {
-}
+    : base::TestPendingTaskInfo(location, post_time, delay, nestability),
+      ordinal(ordinal) {}
 
-TestMockTimeTaskRunner::TestOrderedPendingTask::~TestOrderedPendingTask() {
-}
+TestMockTimeTaskRunner::TestOrderedPendingTaskInfo::
+    ~TestOrderedPendingTaskInfo() {}
 
 // TestMockTimeTaskRunner -----------------------------------------------------
 
 bool TestMockTimeTaskRunner::TemporalOrder::operator()(
-    const TestOrderedPendingTask& first_task,
-    const TestOrderedPendingTask& second_task) const {
+    const TestOrderedPendingTaskInfo& first_task,
+    const TestOrderedPendingTaskInfo& second_task) const {
   if (first_task.GetTimeToRun() == second_task.GetTimeToRun())
-    return first_task.ordinal > second_task.ordinal;
-  return first_task.GetTimeToRun() > second_task.GetTimeToRun();
+    return first_task.ordinal < second_task.ordinal;
+  return first_task.GetTimeToRun() < second_task.GetTimeToRun();
 }
 
 TestMockTimeTaskRunner::TestMockTimeTaskRunner()
     : now_(Time::UnixEpoch()), next_task_ordinal_(0) {
 }
 
 TestMockTimeTaskRunner::TestMockTimeTaskRunner(Time start_time,
                                                TimeTicks start_ticks)
     : now_(Time::UnixEpoch()), now_ticks_(start_ticks), next_task_ordinal_(0) {}
 
@@ skipping 15 matching lines @@
 }
 
 void TestMockTimeTaskRunner::FastForwardUntilNoTasksRemain() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ProcessAllTasksNoLaterThan(TimeDelta::Max());
 }
 
 void TestMockTimeTaskRunner::ClearPendingTasks() {
   DCHECK(thread_checker_.CalledOnValidThread());
   AutoLock scoped_lock(tasks_lock_);
-  while (!tasks_.empty())
-    tasks_.pop();
+  tasks_.clear();
 }
 
 Time TestMockTimeTaskRunner::Now() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return now_;
 }
 
 TimeTicks TestMockTimeTaskRunner::NowTicks() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return now_ticks_;
 }
 
 std::unique_ptr<Clock> TestMockTimeTaskRunner::GetMockClock() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return MakeUnique<MockClock>(this);
 }
 
 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_.pop();
-  }
+TestPendingTaskQueue TestMockTimeTaskRunner::TakePendingTasks() {
+  TestPendingTaskQueue tasks;
+  for (auto& task : tasks_)
+    tasks.push_back(std::move(task));
+  tasks_.clear();
   return tasks;
 }
 
 bool TestMockTimeTaskRunner::HasPendingTask() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return !tasks_.empty();
 }
 
 size_t TestMockTimeTaskRunner::GetPendingTaskCount() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return tasks_.size();
 }
 
 TimeDelta TestMockTimeTaskRunner::NextPendingTaskDelay() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return tasks_.empty() ? TimeDelta::Max()
-                        : tasks_.top().GetTimeToRun() - now_ticks_;
+  if (tasks_.empty())
+    return TimeDelta::Max();
+
+  const TestPendingTaskInfo& task_info = tasks_.begin()->first;
+  return task_info.GetTimeToRun() - now_ticks_;
 }
 
 bool TestMockTimeTaskRunner::RunsTasksOnCurrentThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
 bool TestMockTimeTaskRunner::PostDelayedTask(
     const tracked_objects::Location& from_here,
     const Closure& task,
     TimeDelta delay) {
   AutoLock scoped_lock(tasks_lock_);
-  tasks_.push(TestOrderedPendingTask(from_here, task, now_ticks_, delay,
-                                     next_task_ordinal_++,
-                                     TestPendingTask::NESTABLE));
+
+  TestOrderedPendingTaskInfo task_info(from_here, now_ticks_, delay,
+                                       next_task_ordinal_++,
+                                       TestPendingTaskInfo::NESTABLE);
+  tasks_.insert(std::make_pair(task_info, task));
   return true;
 }
 
 bool TestMockTimeTaskRunner::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
     const Closure& task,
     TimeDelta delay) {
   return PostDelayedTask(from_here, task, delay);
 }
 
@@ skipping 11 matching lines @@
 
 void TestMockTimeTaskRunner::OnAfterTaskRun() {
   // Empty default implementation.
 }
 
 void TestMockTimeTaskRunner::ProcessAllTasksNoLaterThan(TimeDelta max_delta) {
   DCHECK_GE(max_delta, TimeDelta());
   const TimeTicks original_now_ticks = now_ticks_;
   while (!IsElapsingStopped()) {
     OnBeforeSelectingTask();
-    TestPendingTask task_info;
-    if (!DequeueNextTask(original_now_ticks, max_delta, &task_info))
+    TestPendingTaskInfo task_info;
+    OnceClosure task;
+    if (!DequeueNextTask(original_now_ticks, max_delta, &task_info, &task))
       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).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) {
+bool TestMockTimeTaskRunner::DequeueNextTask(
+    const TimeTicks& reference,
+    const TimeDelta& max_delta,
+    TestPendingTaskInfo* next_task_info,
+    OnceClosure* next_task) {
   AutoLock scoped_lock(tasks_lock_);
-  if (!tasks_.empty() &&
-      (tasks_.top().GetTimeToRun() - reference) <= max_delta) {
-    *next_task = tasks_.top();
-    tasks_.pop();
-    return true;
-  }
-  return false;
+  if (tasks_.empty())
+    return false;
+
+  auto itr = tasks_.begin();
+  const TestPendingTaskInfo& task_info = itr->first;
+  if ((task_info.GetTimeToRun() - reference) > max_delta)
+    return false;
+
+  *next_task_info = task_info;
+  *next_task = std::move(itr->second);
+  tasks_.erase(itr);
+  return true;
 }
 
 }  // namespace base