Split Closure part of TestPendingTask out of the struct

base/test/test_mock_time_task_runner.cc

Index: base/test/test_mock_time_task_runner.cc
diff --git a/base/test/test_mock_time_task_runner.cc b/base/test/test_mock_time_task_runner.cc
index f0ba9aa102c4f38d1a273762dad9b60e7b4a28fe..08d8766fe07fb6e13af4fa4232ac48d1f09c6914 100644
--- a/base/test/test_mock_time_task_runner.cc
+++ b/base/test/test_mock_time_task_runner.cc
@@ -74,46 +74,42 @@ Time MockClock::Now() {
 // 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()
@@ -149,8 +145,7 @@ void TestMockTimeTaskRunner::FastForwardUntilNoTasksRemain() {
 void TestMockTimeTaskRunner::ClearPendingTasks() {
   DCHECK(thread_checker_.CalledOnValidThread());
   AutoLock scoped_lock(tasks_lock_);
-  while (!tasks_.empty())
-    tasks_.pop();
+  tasks_.clear();
 }
 
 Time TestMockTimeTaskRunner::Now() const {
@@ -173,12 +168,11 @@ std::unique_ptr<TickClock> TestMockTimeTaskRunner::GetMockTickClock() const {
   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;
 }
 
@@ -194,8 +188,11 @@ size_t TestMockTimeTaskRunner::GetPendingTaskCount() const {
 
 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 {
@@ -207,9 +204,11 @@ bool TestMockTimeTaskRunner::PostDelayedTask(
     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;
 }
 
@@ -241,14 +240,15 @@ void TestMockTimeTaskRunner::ProcessAllTasksNoLaterThan(TimeDelta max_delta) {
   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();
   }
 }
@@ -262,17 +262,24 @@ void TestMockTimeTaskRunner::ForwardClocksUntilTickTime(TimeTicks 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