Replace Closure in TaskRunner::PostTask with OneShotCallback

base/deferred_sequenced_task_runner.cc

 // Copyright (c) 2013 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 "base/deferred_sequenced_task_runner.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 
 namespace base {
 
 DeferredSequencedTaskRunner::DeferredTask::DeferredTask()
     : is_non_nestable(false) {
 }
 
-DeferredSequencedTaskRunner::DeferredTask::DeferredTask(
-    const DeferredTask& other) = default;
+DeferredSequencedTaskRunner::DeferredTask::DeferredTask(DeferredTask&& other) =
+    default;
 
 DeferredSequencedTaskRunner::DeferredTask::~DeferredTask() {
 }
 
+DeferredSequencedTaskRunner::DeferredTask&
+DeferredSequencedTaskRunner::DeferredTask::operator=(DeferredTask&& other) =
+    default;
+
 DeferredSequencedTaskRunner::DeferredSequencedTaskRunner(
     scoped_refptr<SequencedTaskRunner> target_task_runner)
     : started_(false), target_task_runner_(std::move(target_task_runner)) {}
 
 DeferredSequencedTaskRunner::~DeferredSequencedTaskRunner() {
 }
 
 bool DeferredSequencedTaskRunner::PostDelayedTask(
     const tracked_objects::Location& from_here,
-    const Closure& task,
+    OnceClosure task,
     TimeDelta delay) {
   AutoLock lock(lock_);
   if (started_) {
     DCHECK(deferred_tasks_queue_.empty());
-    return target_task_runner_->PostDelayedTask(from_here, task, delay);
+    return target_task_runner_->PostDelayedTask(from_here, std::move(task),
+                                                delay);
   }
 
-  QueueDeferredTask(from_here, task, delay, false /* is_non_nestable */);
+  QueueDeferredTask(from_here, std::move(task), delay,
+                    false /* is_non_nestable */);
   return true;
 }
 
 bool DeferredSequencedTaskRunner::RunsTasksOnCurrentThread() const {
   return target_task_runner_->RunsTasksOnCurrentThread();
 }
 
 bool DeferredSequencedTaskRunner::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
-    const Closure& task,
+    OnceClosure task,
     TimeDelta delay) {
   AutoLock lock(lock_);
   if (started_) {
     DCHECK(deferred_tasks_queue_.empty());
-    return target_task_runner_->PostNonNestableDelayedTask(from_here,
-                                                           task,
-                                                           delay);
+    return target_task_runner_->PostNonNestableDelayedTask(
+        from_here, std::move(task), delay);
   }
-  QueueDeferredTask(from_here, task, delay, true /* is_non_nestable */);
+  QueueDeferredTask(from_here, std::move(task), delay,
+                    true /* is_non_nestable */);
   return true;
 }
 
 void DeferredSequencedTaskRunner::QueueDeferredTask(
     const tracked_objects::Location& from_here,
-    const Closure& task,
+    OnceClosure task,
     TimeDelta delay,
     bool is_non_nestable) {
   DeferredTask deferred_task;
   deferred_task.posted_from = from_here;
-  deferred_task.task = task;
+  deferred_task.task = std::move(task);
   deferred_task.delay = delay;
   deferred_task.is_non_nestable = is_non_nestable;
-  deferred_tasks_queue_.push_back(deferred_task);
+  deferred_tasks_queue_.push_back(std::move(deferred_task));
 }
 
 
 void DeferredSequencedTaskRunner::Start() {
   AutoLock lock(lock_);
   DCHECK(!started_);
   started_ = true;
   for (std::vector<DeferredTask>::iterator i = deferred_tasks_queue_.begin();
       i != deferred_tasks_queue_.end();
       ++i) {
     const DeferredTask& task = *i;
     if (task.is_non_nestable) {
-      target_task_runner_->PostNonNestableDelayedTask(task.posted_from,
-                                                      task.task,
-                                                      task.delay);
+      target_task_runner_->PostNonNestableDelayedTask(
+          task.posted_from, std::move(task.task), task.delay);
     } else {
       target_task_runner_->PostDelayedTask(task.posted_from,
-                                           task.task,
-                                           task.delay);
+                                           std::move(task.task), task.delay);
     }
     // Replace the i-th element in the |deferred_tasks_queue_| with an empty
     // |DelayedTask| to ensure that |task| is destroyed before the next task
     // is posted.
     *i = DeferredTask();
   }
   deferred_tasks_queue_.clear();
 }
 
 }  // namespace base