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

base/task_scheduler/scheduler_single_thread_task_runner_manager.cc

 // Copyright 2017 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/task_scheduler/scheduler_single_thread_task_runner_manager.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/atomic_flag.h"
 #include "base/task_scheduler/delayed_task_manager.h"
 #include "base/task_scheduler/scheduler_worker.h"
 #include "base/task_scheduler/sequence.h"
@@ skipping 120 matching lines @@
       SchedulerSingleThreadTaskRunnerManager* const outer,
       const TaskTraits& traits,
       SchedulerWorker* worker)
       : outer_(outer), traits_(traits), worker_(worker) {
     DCHECK(outer_);
     DCHECK(worker_);
   }
 
   // SingleThreadTaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
-                       const Closure& closure,
+                       Closure closure,
                        TimeDelta delay) override {
-    auto task = MakeUnique<Task>(from_here, closure, traits_, delay);
+    auto task = MakeUnique<Task>(from_here, std::move(closure), traits_, delay);
     task->single_thread_task_runner_ref = this;
 
     if (!outer_->task_tracker_->WillPostTask(task.get()))
       return false;
 
     if (task->delayed_run_time.is_null()) {
       PostTaskNow(std::move(task));
     } else {
       outer_->delayed_task_manager_->AddDelayedTask(
           std::move(task), Bind(&SchedulerSingleThreadTaskRunner::PostTaskNow,
                                 Unretained(this)));
     }
     return true;
   }
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
-                                  const Closure& closure,
+                                  Closure closure,
                                   base::TimeDelta delay) override {
     // Tasks are never nested within the task scheduler.
-    return PostDelayedTask(from_here, closure, delay);
+    return PostDelayedTask(from_here, std::move(closure), delay);
   }
 
   bool RunsTasksOnCurrentThread() const override {
     return GetDelegate()->RunsTasksOnCurrentThread();
   }
 
  private:
   ~SchedulerSingleThreadTaskRunner() override {
     outer_->UnregisterSchedulerWorker(worker_);
   }
@@ skipping 116 matching lines @@
                      });
     DCHECK(worker_iter != workers_.end());
     worker_to_destroy = std::move(*worker_iter);
     workers_.erase(worker_iter);
   }
   worker_to_destroy->Cleanup();
 }
 
 }  // namespace internal
 }  // namespace base