Split Closure part of TestPendingTask out of the struct

cc/test/ordered_simple_task_runner.cc

Index: cc/test/ordered_simple_task_runner.cc
diff --git a/cc/test/ordered_simple_task_runner.cc b/cc/test/ordered_simple_task_runner.cc
index 9dc4bbcd2dacb680d586699576a632e286aab037..dcf6f5fd4069e3b3b912df29e6a6f18b454dc2d8 100644
--- a/cc/test/ordered_simple_task_runner.cc
+++ b/cc/test/ordered_simple_task_runner.cc
@@ -28,33 +28,28 @@
 namespace cc {
 
 // TestOrderablePendingTask implementation
-TestOrderablePendingTask::TestOrderablePendingTask()
-    : base::TestPendingTask(),
-      task_id_(TestOrderablePendingTask::task_id_counter++) {
-}
+TestOrderablePendingTaskInfo::TestOrderablePendingTaskInfo()
+    : task_id_(TestOrderablePendingTaskInfo::task_id_counter++) {}
 
-TestOrderablePendingTask::TestOrderablePendingTask(
+TestOrderablePendingTaskInfo::TestOrderablePendingTaskInfo(
     const tracked_objects::Location& location,
-    const base::Closure& task,
     base::TimeTicks post_time,
     base::TimeDelta delay,
     TestNestability nestability)
-    : base::TestPendingTask(location, task, post_time, delay, nestability),
-      task_id_(TestOrderablePendingTask::task_id_counter++) {
-}
+    : base::TestPendingTaskInfo(location, post_time, delay, nestability),
+      task_id_(TestOrderablePendingTaskInfo::task_id_counter++) {}
 
-size_t TestOrderablePendingTask::task_id_counter = 0;
+size_t TestOrderablePendingTaskInfo::task_id_counter = 0;
 
-TestOrderablePendingTask::~TestOrderablePendingTask() {
-}
+TestOrderablePendingTaskInfo::~TestOrderablePendingTaskInfo() {}
 
-bool TestOrderablePendingTask::operator==(
-    const TestOrderablePendingTask& other) const {
+bool TestOrderablePendingTaskInfo::operator==(
+    const TestOrderablePendingTaskInfo& other) const {
   return task_id_ == other.task_id_;
 }
 
-bool TestOrderablePendingTask::operator<(
-    const TestOrderablePendingTask& other) const {
+bool TestOrderablePendingTaskInfo::operator<(
+    const TestOrderablePendingTaskInfo& other) const {
   if (*this == other)
     return false;
 
@@ -65,14 +60,14 @@ bool TestOrderablePendingTask::operator<(
 }
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
-TestOrderablePendingTask::AsValue() const {
+TestOrderablePendingTaskInfo::AsValue() const {
   std::unique_ptr<base::trace_event::TracedValue> state(
       new base::trace_event::TracedValue());
   AsValueInto(state.get());
   return std::move(state);
 }
 
-void TestOrderablePendingTask::AsValueInto(
+void TestOrderablePendingTaskInfo::AsValueInto(
     base::trace_event::TracedValue* state) const {
   state->SetInteger("id", base::saturated_cast<int>(task_id_));
   state->SetInteger("run_at", GetTimeToRun().ToInternalValue());
@@ -102,11 +97,11 @@ bool OrderedSimpleTaskRunner::PostDelayedTask(
     const base::Closure& task,
     base::TimeDelta delay) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  TestOrderablePendingTask pt(from_here, task, now_src_->NowTicks(), delay,
-                              base::TestPendingTask::NESTABLE);
+  TestOrderablePendingTaskInfo pt(from_here, now_src_->NowTicks(), delay,
+                                  base::TestPendingTaskInfo::NESTABLE);
 
   TRACE_TASK("OrderedSimpleTaskRunner::PostDelayedTask", pt);
-  pending_tasks_.insert(pt);
+  pending_tasks_.insert(std::make_pair(pt, task));
   return true;
 }
 
@@ -115,11 +110,11 @@ bool OrderedSimpleTaskRunner::PostNonNestableDelayedTask(
     const base::Closure& task,
     base::TimeDelta delay) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  TestOrderablePendingTask pt(from_here, task, now_src_->NowTicks(), delay,
-                              base::TestPendingTask::NON_NESTABLE);
+  TestOrderablePendingTaskInfo pt(from_here, now_src_->NowTicks(), delay,
+                                  base::TestPendingTaskInfo::NON_NESTABLE);
 
   TRACE_TASK("OrderedSimpleTaskRunner::PostNonNestableDelayedTask", pt);
-  pending_tasks_.insert(pt);
+  pending_tasks_.insert(std::make_pair(pt, task));
   return true;
 }
 
@@ -141,7 +136,8 @@ base::TimeTicks OrderedSimpleTaskRunner::NextTaskTime() {
     return AbsoluteMaxNow();
   }
 
-  return pending_tasks_.begin()->GetTimeToRun();
+  const base::TestPendingTaskInfo& task_info = pending_tasks_.begin()->first;
+  return task_info.GetTimeToRun();
 }
 
 base::TimeDelta OrderedSimpleTaskRunner::DelayToNextTaskTime() {
@@ -215,14 +211,15 @@ bool OrderedSimpleTaskRunner::RunTasksWhile(
       break;
     }
 
-    std::set<TestOrderablePendingTask>::iterator task_to_run =
+    TestOrderablePendingTaskQueue::iterator task_to_run =
         pending_tasks_.begin();
     {
-      TRACE_EVENT1("cc",
-                   "OrderedSimpleTaskRunner::RunPendingTasks running",
-                   "task",
-                   task_to_run->AsValue());
-      task_to_run->task.Run();
+      const base::TestPendingTaskInfo& task_info = task_to_run->first;
+      base::OnceClosure task = std::move(task_to_run->second);
+
+      TRACE_EVENT1("cc", "OrderedSimpleTaskRunner::RunPendingTasks running",
+                   "task", task_info.AsValue());
+      std::move(task).Run();
     }
 
     pending_tasks_.erase(task_to_run);
@@ -277,12 +274,9 @@ void OrderedSimpleTaskRunner::AsValueInto(
                     base::saturated_cast<int>(pending_tasks_.size()));
 
   state->BeginArray("tasks");
-  for (std::set<TestOrderablePendingTask>::const_iterator it =
-           pending_tasks_.begin();
-       it != pending_tasks_.end();
-       ++it) {
+  for (const auto& pending_task : pending_tasks_) {
     state->BeginDictionary();
-    it->AsValueInto(state);
+    pending_task.first.AsValueInto(state);
     state->EndDictionary();
   }
   state->EndArray();
@@ -310,15 +304,17 @@ bool OrderedSimpleTaskRunner::TaskRunCountBelowCallback(size_t max_tasks,
 }
 
 base::Callback<bool(void)> OrderedSimpleTaskRunner::TaskExistedInitially() {
-  // base::Bind takes a copy of pending_tasks_
+  std::set<size_t> existing_task_ids;
+  for (const auto& task : pending_tasks_)
+    existing_task_ids.insert(task.first.task_id());
   return base::Bind(&OrderedSimpleTaskRunner::TaskExistedInitiallyCallback,
-                    base::Unretained(this),
-                    pending_tasks_);
+                    base::Unretained(this), std::move(existing_task_ids));
 }
 
 bool OrderedSimpleTaskRunner::TaskExistedInitiallyCallback(
-    const std::set<TestOrderablePendingTask>& existing_tasks) {
-  return existing_tasks.find(*pending_tasks_.begin()) != existing_tasks.end();
+    const std::set<size_t>& existing_task_ids) {
+  const TestOrderablePendingTaskInfo& task_info = pending_tasks_.begin()->first;
+  return existing_task_ids.find(task_info.task_id()) != existing_task_ids.end();
 }
 
 base::Callback<bool(void)> OrderedSimpleTaskRunner::NowBefore(