Replace Closure in TaskRunner::PostTask with OneShotCallback

cc/test/ordered_simple_task_runner.cc

 // Copyright 2014 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 "cc/test/ordered_simple_task_runner.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 15 matching lines @@
 #define TRACE_TASK_RUN(function, tag, task)
 
 namespace cc {
 
 // TestOrderablePendingTask implementation
 TestOrderablePendingTask::TestOrderablePendingTask()
     : base::TestPendingTask(),
       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;
 
 TestOrderablePendingTask::~TestOrderablePendingTask() {
 }
 
 bool TestOrderablePendingTask::operator==(
     const TestOrderablePendingTask& other) const {
   return task_id_ == other.task_id_;
 }
@@ skipping 37 matching lines @@
 
 // static
 base::TimeTicks OrderedSimpleTaskRunner::AbsoluteMaxNow() {
   return base::TimeTicks::FromInternalValue(
       std::numeric_limits<int64_t>::max());
 }
 
 // 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;
 }
 
 bool OrderedSimpleTaskRunner::RunsTasksOnCurrentThread() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return true;
 }
 
 size_t OrderedSimpleTaskRunner::NumPendingTasks() const {
   return pending_tasks_.size();
@@ skipping 82 matching lines @@
       break;
     }
 
     std::set<TestOrderablePendingTask>::iterator task_to_run =
         pending_tasks_.begin();
     {
       TRACE_EVENT1("cc",
                    "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);
   }
 
   return HasPendingTasks();
 }
 
 bool OrderedSimpleTaskRunner::RunPendingTasks() {
   return RunTasksWhile(TaskExistedInitially());
@@ skipping 66 matching lines @@
                     base::Owned(new size_t(0)));
 }
 
 bool OrderedSimpleTaskRunner::TaskRunCountBelowCallback(size_t max_tasks,
                                                         size_t* tasks_run) {
   return (*tasks_run)++ < 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(
     base::TimeTicks stop_at) {
   return base::Bind(&OrderedSimpleTaskRunner::NowBeforeCallback,
                     base::Unretained(this),
                     stop_at);
 }
 bool OrderedSimpleTaskRunner::NowBeforeCallback(base::TimeTicks stop_at) {
   return NextTaskTime() <= stop_at;
 }
 
 base::Callback<bool(void)> OrderedSimpleTaskRunner::AdvanceNow() {
   return base::Bind(&OrderedSimpleTaskRunner::AdvanceNowCallback,
                     base::Unretained(this));
 }
 
 bool OrderedSimpleTaskRunner::AdvanceNowCallback() {
   base::TimeTicks next_task_time = NextTaskTime();
   if (now_src_->NowTicks() < next_task_time) {
     now_src_->Advance(next_task_time - now_src_->NowTicks());
   }
   return true;
 }
 
 }  // namespace cc