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

base/test/scoped_task_scheduler.cc

 // Copyright 2016 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/test/scoped_task_scheduler.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
+#include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_base.h"
 #include "base/run_loop.h"
 #include "base/sequence_token.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
@@ skipping 13 matching lines @@
  public:
   // |external_message_loop| is an externally provided MessageLoop on which to
   // run tasks. A MessageLoop will be created by TestTaskScheduler if
   // |external_message_loop| is nullptr.
   explicit TestTaskScheduler(MessageLoop* external_message_loop);
   ~TestTaskScheduler() override;
 
   // TaskScheduler:
   void PostDelayedTaskWithTraits(const tracked_objects::Location& from_here,
                                  const TaskTraits& traits,
-                                 const Closure& task,
+                                 Closure task,
                                  TimeDelta delay) override;
   scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(
       const TaskTraits& traits) override;
   scoped_refptr<SequencedTaskRunner> CreateSequencedTaskRunnerWithTraits(
       const TaskTraits& traits) override;
   scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunnerWithTraits(
       const TaskTraits& traits) override;
   std::vector<const HistogramBase*> GetHistograms() const override;
   int GetMaxConcurrentTasksWithTraitsDeprecated(
       const TaskTraits& traits) const override;
@@ skipping 47 matching lines @@
 };
 
 class TestTaskSchedulerTaskRunner : public SingleThreadTaskRunner {
  public:
   TestTaskSchedulerTaskRunner(TestTaskScheduler* task_scheduler,
                               ExecutionMode execution_mode,
                               TaskTraits traits);
 
   // SingleThreadTaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
-                       const Closure& closure,
+                       Closure closure,
                        TimeDelta delay) override;
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
-                                  const Closure& closure,
+                                  Closure closure,
                                   TimeDelta delay) override;
   bool RunsTasksOnCurrentThread() const override;
 
  private:
   ~TestTaskSchedulerTaskRunner() override;
 
   TestTaskScheduler* const task_scheduler_;
   const ExecutionMode execution_mode_;
   const SequenceToken sequence_token_;
   const TaskTraits traits_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTaskSchedulerTaskRunner);
 };
 
 TestTaskScheduler::TestTaskScheduler(MessageLoop* external_message_loop)
     : message_loop_owned_(external_message_loop ? nullptr
                                                 : MakeUnique<MessageLoop>()),
       message_loop_(message_loop_owned_ ? message_loop_owned_.get()
                                         : external_message_loop) {}
 
 TestTaskScheduler::~TestTaskScheduler() {
   // Shutdown if it hasn't already been done explicitly.
   if (!task_tracker_.HasShutdownStarted())
     Shutdown();
 }
 
 void TestTaskScheduler::PostDelayedTaskWithTraits(
     const tracked_objects::Location& from_here,
     const TaskTraits& traits,
-    const Closure& task,
+    Closure task,
     TimeDelta delay) {
-  CreateTaskRunnerWithTraits(traits)->PostDelayedTask(from_here, task, delay);
+  CreateTaskRunnerWithTraits(traits)->PostDelayedTask(from_here,
+                                                      std::move(task), delay);
 }
 
 scoped_refptr<TaskRunner> TestTaskScheduler::CreateTaskRunnerWithTraits(
     const TaskTraits& traits) {
   return make_scoped_refptr(
       new TestTaskSchedulerTaskRunner(this, ExecutionMode::PARALLEL, traits));
 }
 
 scoped_refptr<SequencedTaskRunner>
 TestTaskScheduler::CreateSequencedTaskRunnerWithTraits(
@@ skipping 80 matching lines @@
     TaskTraits traits)
     : task_scheduler_(task_scheduler),
       execution_mode_(execution_mode),
       sequence_token_(execution_mode == ExecutionMode::PARALLEL
                           ? SequenceToken()
                           : SequenceToken::Create()),
       traits_(traits) {}
 
 bool TestTaskSchedulerTaskRunner::PostDelayedTask(
     const tracked_objects::Location& from_here,
-    const Closure& closure,
+    Closure closure,
     TimeDelta delay) {
-  auto task = MakeUnique<internal::Task>(from_here, closure, traits_, delay);
+  auto task =
+      MakeUnique<internal::Task>(from_here, std::move(closure), traits_, delay);
   if (execution_mode_ == ExecutionMode::SEQUENCED)
     task->sequenced_task_runner_ref = make_scoped_refptr(this);
   else if (execution_mode_ == ExecutionMode::SINGLE_THREADED)
     task->single_thread_task_runner_ref = make_scoped_refptr(this);
   return task_scheduler_->PostTask(std::move(task), sequence_token_);
 }
 
 bool TestTaskSchedulerTaskRunner::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
-    const Closure& closure,
+    Closure closure,
     TimeDelta delay) {
   // Tasks are never nested within the task scheduler.
-  return PostDelayedTask(from_here, closure, delay);
+  return PostDelayedTask(from_here, std::move(closure), delay);
 }
 
 bool TestTaskSchedulerTaskRunner::RunsTasksOnCurrentThread() const {
   if (execution_mode_ == ExecutionMode::PARALLEL)
     return task_scheduler_->RunsTasksOnCurrentThread();
   return sequence_token_ == SequenceToken::GetForCurrentThread();
 }
 
 TestTaskSchedulerTaskRunner::~TestTaskSchedulerTaskRunner() = default;
 
@@ skipping 12 matching lines @@
   DCHECK_EQ(task_scheduler_, TaskScheduler::GetInstance());
 
   // Per contract, call JoinForTesting() before deleting the TaskScheduler.
   TaskScheduler::GetInstance()->JoinForTesting();
 
   TaskScheduler::SetInstance(nullptr);
 }
 
 }  // namespace test
 }  // namespace base