Replace Closure in TaskRunner::PostTask with OneShotCallback

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 a3d66ee6d3a58510e49557842b0498955f17fc83..397e2d1ce933e37a5a20dd8dda2ca21a38f21237 100644
--- a/cc/test/ordered_simple_task_runner.cc
+++ b/cc/test/ordered_simple_task_runner.cc
@@ -33,15 +33,21 @@ TestOrderablePendingTask::TestOrderablePendingTask()
       task_id_(TestOrderablePendingTask::task_id_counter++) {
 }
 
+TestOrderablePendingTask::TestOrderablePendingTask(TestOrderablePendingTask&&) =
+    default;
+
 TestOrderablePendingTask::TestOrderablePendingTask(
     const tracked_objects::Location& location,
-    const base::Closure& task,
+    base::OnceClosure 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::TestPendingTask(location,
+                            std::move(task),
+                            post_time,
+                            delay,
+                            nestability),
+      task_id_(TestOrderablePendingTask::task_id_counter++) {}
 
 size_t TestOrderablePendingTask::task_id_counter = 0;
 
@@ -99,27 +105,27 @@ base::TimeTicks OrderedSimpleTaskRunner::AbsoluteMaxNow() {
 // base::TestSimpleTaskRunner implementation
 bool OrderedSimpleTaskRunner::PostDelayedTask(
     const tracked_objects::Location& from_here,
-    const base::Closure& task,
+    base::OnceClosure task,
     base::TimeDelta delay) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  TestOrderablePendingTask pt(from_here, task, now_src_->NowTicks(), delay,
-                              base::TestPendingTask::NESTABLE);
+  TestOrderablePendingTask pt(from_here, std::move(task), now_src_->NowTicks(),
+                              delay, base::TestPendingTask::NESTABLE);
 
   TRACE_TASK("OrderedSimpleTaskRunner::PostDelayedTask", pt);
-  pending_tasks_.insert(pt);
+  pending_tasks_.insert(std::move(pt));
   return true;
 }
 
 bool OrderedSimpleTaskRunner::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
-    const base::Closure& task,
+    base::OnceClosure task,
     base::TimeDelta delay) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  TestOrderablePendingTask pt(from_here, task, now_src_->NowTicks(), delay,
-                              base::TestPendingTask::NON_NESTABLE);
+  TestOrderablePendingTask pt(from_here, std::move(task), now_src_->NowTicks(),
+                              delay, base::TestPendingTask::NON_NESTABLE);
 
   TRACE_TASK("OrderedSimpleTaskRunner::PostNonNestableDelayedTask", pt);
-  pending_tasks_.insert(pt);
+  pending_tasks_.insert(std::move(pt));
   return true;
 }
 
@@ -222,7 +228,7 @@ bool OrderedSimpleTaskRunner::RunTasksWhile(
                    "OrderedSimpleTaskRunner::RunPendingTasks running",
                    "task",
                    task_to_run->AsValue());
-      task_to_run->task.Run();
+      std::move(task_to_run->task).Run();
     }
 
     pending_tasks_.erase(task_to_run);
@@ -309,14 +315,18 @@ 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> pending_task_ids;
+  for (const auto& pending_task : pending_tasks_)
+    pending_task_ids.insert(pending_task.task_id());
+
   return base::Bind(&OrderedSimpleTaskRunner::TaskExistedInitiallyCallback,
-                    base::Unretained(this),
-                    pending_tasks_);
+                    base::Unretained(this), std::move(pending_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_tasks) {
+  return existing_tasks.find(pending_tasks_.begin()->task_id()) !=
+         existing_tasks.end();
 }
 
 base::Callback<bool(void)> OrderedSimpleTaskRunner::NowBefore(