Replace Closure in TaskRunner::PostTask with OneShotCallback

content/renderer/categorized_worker_pool.h

 // Copyright 2015 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.
 
 #ifndef CONTENT_RENDERER_CATEGORIZED_WORKER_POOL_H_
 #define CONTENT_RENDERER_CATEGORIZED_WORKER_POOL_H_
 
 #include <memory>
 
 #include "base/callback.h"
@@ skipping 18 matching lines @@
 //    schedule a graph of tasks with their dependencies.
 // 3. CreateSequencedTaskRunner() creates a sequenced task runner that might run
 //    in parallel with other instances of sequenced task runners.
 class CONTENT_EXPORT CategorizedWorkerPool : public base::TaskRunner,
                                              public cc::TaskGraphRunner {
  public:
   CategorizedWorkerPool();
 
   // Overridden from base::TaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
-                       const base::Closure& task,
+                       base::OnceClosure task,
                        base::TimeDelta delay) override;
   bool RunsTasksOnCurrentThread() const override;
 
   // Overridden from cc::TaskGraphRunner:
   cc::NamespaceToken GetNamespaceToken() override;
   void ScheduleTasks(cc::NamespaceToken token, cc::TaskGraph* graph) override;
   void WaitForTasksToFinishRunning(cc::NamespaceToken token) override;
   void CollectCompletedTasks(cc::NamespaceToken token,
                              cc::Task::Vector* completed_tasks) override;
 
@@ skipping 24 matching lines @@
 
  private:
   class CategorizedWorkerPoolSequencedTaskRunner;
   friend class CategorizedWorkerPoolSequencedTaskRunner;
 
   // Simple Task for the TaskGraphRunner that wraps a closure.
   // This class is used to schedule TaskRunner tasks on the
   // |task_graph_runner_|.
   class ClosureTask : public cc::Task {
    public:
-    explicit ClosureTask(const base::Closure& closure);
+    explicit ClosureTask(base::OnceClosure closure);
 
     // Overridden from cc::Task:
     void RunOnWorkerThread() override;
 
    protected:
     ~ClosureTask() override;
 
    private:
-    base::Closure closure_;
+    base::OnceClosure closure_;
 
     DISALLOW_COPY_AND_ASSIGN(ClosureTask);
   };
 
   void ScheduleTasksWithLockAcquired(cc::NamespaceToken token,
                                      cc::TaskGraph* graph);
   void CollectCompletedTasksWithLockAcquired(cc::NamespaceToken token,
                                              cc::Task::Vector* completed_tasks);
 
   // Runs a task from one of the provided categories. Categories listed first
@@ skipping 35 matching lines @@
   // Condition variable that is waited on by origin threads until a namespace
   // has finished running all associated tasks.
   base::ConditionVariable has_namespaces_with_finished_running_tasks_cv_;
   // Set during shutdown. Tells Run() to return when no more tasks are pending.
   bool shutdown_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_CATEGORIZED_WORKER_POOL_H_