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

content/renderer/categorized_worker_pool.cc

 // 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.
 
 #include "content/renderer/categorized_worker_pool.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "base/callback_helpers.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/raster/task_category.h"
 
 namespace content {
 namespace {
 
 // A thread which forwards to CategorizedWorkerPool::Run with the runnable
@@ skipping 25 matching lines @@
 class CategorizedWorkerPool::CategorizedWorkerPoolSequencedTaskRunner
     : public base::SequencedTaskRunner {
  public:
   explicit CategorizedWorkerPoolSequencedTaskRunner(
       cc::TaskGraphRunner* task_graph_runner)
       : task_graph_runner_(task_graph_runner),
         namespace_token_(task_graph_runner->GenerateNamespaceToken()) {}
 
   // Overridden from base::TaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
-                       const base::Closure& task,
+                       base::Closure task,
                        base::TimeDelta delay) override {
-    return PostNonNestableDelayedTask(from_here, task, delay);
+    return PostNonNestableDelayedTask(from_here, std::move(task), delay);
   }
   bool RunsTasksOnCurrentThread() const override { return true; }
 
   // Overridden from base::SequencedTaskRunner:
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
-                                  const base::Closure& task,
+                                  base::Closure task,
                                   base::TimeDelta delay) override {
     base::AutoLock lock(lock_);
 
     // Remove completed tasks.
     DCHECK(completed_tasks_.empty());
     task_graph_runner_->CollectCompletedTasks(namespace_token_,
                                               &completed_tasks_);
 
     tasks_.erase(tasks_.begin(), tasks_.begin() + completed_tasks_.size());
 
-    tasks_.push_back(make_scoped_refptr(new ClosureTask(task)));
+    tasks_.push_back(make_scoped_refptr(new ClosureTask(std::move(task))));
     graph_.Reset();
     for (const auto& graph_task : tasks_) {
       int dependencies = 0;
       if (!graph_.nodes.empty())
         dependencies = 1;
 
       // Treat any tasks that are enqueued through the SequencedTaskRunner as
       // FOREGROUND priority. We don't have enough information to know the
       // actual priority of such tasks, so we run them as soon as possible.
       cc::TaskGraph::Node node(graph_task, cc::TASK_CATEGORY_FOREGROUND,
@@ skipping 93 matching lines @@
   }
   while (!threads_.empty()) {
     threads_.back()->Join();
     threads_.pop_back();
   }
 }
 
 // Overridden from base::TaskRunner:
 bool CategorizedWorkerPool::PostDelayedTask(
     const tracked_objects::Location& from_here,
-    const base::Closure& task,
+    base::Closure task,
     base::TimeDelta delay) {
   base::AutoLock lock(lock_);
 
   // Remove completed tasks.
   DCHECK(completed_tasks_.empty());
   CollectCompletedTasksWithLockAcquired(namespace_token_, &completed_tasks_);
 
   cc::Task::Vector::iterator end = std::remove_if(
       tasks_.begin(), tasks_.end(), [this](const scoped_refptr<cc::Task>& e) {
         return std::find(this->completed_tasks_.begin(),
                          this->completed_tasks_.end(),
                          e) != this->completed_tasks_.end();
       });
   tasks_.erase(end, tasks_.end());
 
-  tasks_.push_back(make_scoped_refptr(new ClosureTask(task)));
+  tasks_.push_back(make_scoped_refptr(new ClosureTask(std::move(task))));
   graph_.Reset();
   for (const auto& graph_task : tasks_) {
     // Delayed tasks are assigned FOREGROUND category, ensuring that they run as
     // soon as possible once their delay has expired.
     graph_.nodes.push_back(
         cc::TaskGraph::Node(graph_task.get(), cc::TASK_CATEGORY_FOREGROUND,
                             0u /* priority */, 0u /* dependencies */));
   }
 
   ScheduleTasksWithLockAcquired(namespace_token_, &graph_);
@@ skipping 191 matching lines @@
       ShouldRunTaskForCategoryWithLockAcquired(
           cc::TASK_CATEGORY_NONCONCURRENT_FOREGROUND)) {
     has_ready_to_run_foreground_tasks_cv_.Signal();
   }
 
   if (ShouldRunTaskForCategoryWithLockAcquired(cc::TASK_CATEGORY_BACKGROUND)) {
     has_ready_to_run_background_tasks_cv_.Signal();
   }
 }
 
-CategorizedWorkerPool::ClosureTask::ClosureTask(const base::Closure& closure)
-    : closure_(closure) {}
+CategorizedWorkerPool::ClosureTask::ClosureTask(base::Closure closure)
+    : closure_(std::move(closure)) {}
 
 // Overridden from cc::Task:
 void CategorizedWorkerPool::ClosureTask::RunOnWorkerThread() {
-  closure_.Run();
-  closure_.Reset();
+  std::move(closure_).Run();
 }
 
 CategorizedWorkerPool::ClosureTask::~ClosureTask() {}
 
 }  // namespace content