Pass Callback to TaskRunner by value and consume it on invocation (1)

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>
 #include <set>
 #include <sstream>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 
 #define TRACE_TASK(function, task) \
   TRACE_EVENT_INSTANT1(            \
       "cc", function, TRACE_EVENT_SCOPE_THREAD, "task", task.AsValue());
 
 #define TRACE_TASK_RUN(function, tag, task)
 
 namespace cc {
 
 // TestOrderablePendingTask implementation
 TestOrderablePendingTask::TestOrderablePendingTask()
     : base::TestPendingTask(),
       task_id_(TestOrderablePendingTask::task_id_counter++) {
 }
 
 TestOrderablePendingTask::TestOrderablePendingTask(
     const tracked_objects::Location& location,
-    const base::Closure& task,
+    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::TestPendingTask(location,
+                            std::move(task),
+                            post_time,
+                            delay,
+                            nestability),
+      task_id_(TestOrderablePendingTask::task_id_counter++) {}
 
 TestOrderablePendingTask::TestOrderablePendingTask(TestOrderablePendingTask&&) =
     default;
 
 TestOrderablePendingTask& TestOrderablePendingTask::operator=(
     TestOrderablePendingTask&&) = default;
 
 size_t TestOrderablePendingTask::task_id_counter = 0;
 
 TestOrderablePendingTask::~TestOrderablePendingTask() {
@@ skipping 43 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::Closure 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(std::move(pt));
   return true;
 }
 
 bool OrderedSimpleTaskRunner::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
-    const base::Closure& task,
+    base::Closure 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(std::move(pt));
   return true;
 }
 
 bool OrderedSimpleTaskRunner::RunsTasksOnCurrentThread() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return true;
 }
@@ skipping 234 matching lines @@
   while (it != pending_tasks_.end()) {
     if (it->task.IsCancelled()) {
       it = pending_tasks_.erase(it);
     } else {
       it++;
     }
   }
 }
 
 }  // namespace cc