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

mojo/public/cpp/bindings/tests/bind_task_runner_unittest.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 <utility>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr_info.h"
 #include "mojo/public/cpp/bindings/associated_interface_request.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/interfaces/bindings/tests/test_associated_interfaces.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
 class TestTaskRunner : public base::SingleThreadTaskRunner {
  public:
   TestTaskRunner()
       : thread_id_(base::PlatformThread::CurrentRef()),
         quit_called_(false),
         task_ready_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                     base::WaitableEvent::InitialState::NOT_SIGNALED) {}
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
-                                  const base::Closure& task,
+                                  base::Closure task,
                                   base::TimeDelta delay) override {
     NOTREACHED();
     return false;
   }
 
   bool PostDelayedTask(const tracked_objects::Location& from_here,
-                       const base::Closure& task,
+                       base::Closure task,
                        base::TimeDelta delay) override {
     {
       base::AutoLock locker(lock_);
-      tasks_.push(task);
+      tasks_.push(std::move(task));
     }
     task_ready_.Signal();
     return true;
   }
   bool RunsTasksOnCurrentThread() const override {
     return base::PlatformThread::CurrentRef() == thread_id_;
   }
 
   // Only quits when Quit() is called.
   void Run() {
     DCHECK(RunsTasksOnCurrentThread());
     quit_called_ = false;
 
     while (true) {
       {
         base::AutoLock locker(lock_);
         while (!tasks_.empty()) {
-          auto task = tasks_.front();
+          auto task = std::move(tasks_.front());
           tasks_.pop();
 
           {
             base::AutoUnlock unlocker(lock_);
-            task.Run();
+            std::move(task).Run();

[sky, 2017/03/22 17:34:11]

Is the std::move(task) really necessary?

             if (quit_called_)
               return;
           }
         }
       }
       task_ready_.Wait();
     }
   }
 
   void Quit() {
     DCHECK(RunsTasksOnCurrentThread());
     quit_called_ = true;
   }
 
   // Waits until one task is ready and runs it.
   void RunOneTask() {
     DCHECK(RunsTasksOnCurrentThread());
 
     while (true) {
       {
         base::AutoLock locker(lock_);
         if (!tasks_.empty()) {
-          auto task = tasks_.front();
+          auto task = std::move(tasks_.front());
           tasks_.pop();
 
           {
             base::AutoUnlock unlocker(lock_);
-            task.Run();
+            std::move(task).Run();

[sky, 2017/03/22 17:34:11]

Similar comment about the need for std::move(task) here.

             return;
           }
         }
       }
       task_ready_.Wait();
     }
   }
 
  private:
   ~TestTaskRunner() override {}
@@ skipping 278 matching lines @@
   EXPECT_TRUE(sender_impl_error);
   connection_ptr_task_runner_->Run();
   EXPECT_TRUE(connection_ptr_error);
   sender_ptr_task_runner_->Run();
   EXPECT_TRUE(sender_ptr_error);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo