Migrate base::TaskRunner from Closure to OnceClosure

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 <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 16 matching lines @@
 
 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,
-    Closure task,
+    OnceClosure task,
     TimeDelta delay) {
   AutoLock lock(lock_);
   if (started_) {
     DCHECK(deferred_tasks_queue_.empty());
     return target_task_runner_->PostDelayedTask(from_here, std::move(task),
                                                 delay);
   }
 
   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,
-    Closure task,
+    OnceClosure task,
     TimeDelta delay) {
   AutoLock lock(lock_);
   if (started_) {
     DCHECK(deferred_tasks_queue_.empty());
     return target_task_runner_->PostNonNestableDelayedTask(
         from_here, std::move(task), delay);
   }
   QueueDeferredTask(from_here, std::move(task), delay,
                     true /* is_non_nestable */);
   return true;
 }
 
 void DeferredSequencedTaskRunner::QueueDeferredTask(
     const tracked_objects::Location& from_here,
-    Closure task,
+    OnceClosure task,
     TimeDelta delay,
     bool is_non_nestable) {
   DCHECK(task);
 
   DeferredTask deferred_task;
   deferred_task.posted_from = from_here;
   deferred_task.task = std::move(task);
   deferred_task.delay = delay;
   deferred_task.is_non_nestable = is_non_nestable;
   deferred_tasks_queue_.push_back(std::move(deferred_task));
@@ skipping 12 matching lines @@
           task.posted_from, std::move(task.task), task.delay);
     } else {
       target_task_runner_->PostDelayedTask(task.posted_from,
                                            std::move(task.task), task.delay);
     }
   }
   deferred_tasks_queue_.clear();
 }
 
 }  // namespace base