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

cc/tiles/image_controller_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 "cc/tiles/image_controller.h"
+
+#include <utility>
+
 #include "base/bind.h"
+#include "base/callback_helpers.h"
 #include "base/optional.h"
 #include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread_checker_impl.h"
 #include "cc/test/skia_common.h"
 #include "cc/tiles/image_decode_cache.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
@@ skipping 10 matching lines @@
       {
         base::AutoLock hold(lock_);
         if (shutdown_)
           break;
 
         if (queue_.empty()) {
           condition_.Wait();
           continue;
         }
 
-        task = queue_.front();
+        task = std::move(queue_.front());
         queue_.erase(queue_.begin());
       }
-      task.Run();
+      std::move(task).Run();
     }
   }
 
   void Shutdown() {
     base::AutoLock hold(lock_);
     shutdown_ = true;
     condition_.Signal();
   }
 
-  void PostTask(const base::Closure& task) {
+  void PostTask(base::Closure task) {
     base::AutoLock hold(lock_);
-    queue_.push_back(task);
+    queue_.push_back(std::move(task));
     condition_.Signal();
   }
 
  private:
   base::Lock lock_;
   base::ConditionVariable condition_;
   std::vector<base::Closure> queue_;
   bool shutdown_ = false;
 };
 
 class WorkerTaskRunner : public base::SequencedTaskRunner {
  public:
   WorkerTaskRunner() { thread_.Start(); }
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
-                                  const base::Closure& task,
+                                  base::Closure task,
                                   base::TimeDelta delay) override {
-    return PostDelayedTask(from_here, task, delay);
+    return PostDelayedTask(from_here, std::move(task), delay);
   }
 
   bool PostDelayedTask(const tracked_objects::Location& from_here,
-                       const base::Closure& task,
+                       base::Closure task,
                        base::TimeDelta delay) override {
-    thread_.PostTask(task);
+    thread_.PostTask(std::move(task));
     return true;
   }
 
   bool RunsTasksOnCurrentThread() const override { return false; }
 
  protected:
   ~WorkerTaskRunner() override {
     thread_.Shutdown();
     thread_.Join();
   }
@@ skipping 44 matching lines @@
 
  private:
   int number_of_refs_ = 0;
   scoped_refptr<TileTask> task_to_use_;
 };
 
 // A simple class that can receive decode callbacks.
 class DecodeClient {
  public:
   DecodeClient() {}
-  void Callback(const base::Closure& quit_closure,
+  void Callback(base::Closure quit_closure,
                 ImageController::ImageDecodeRequestId id,
                 ImageController::ImageDecodeResult result) {
     id_ = id;
     result_ = result;
-    quit_closure.Run();
+    std::move(quit_closure).Run();
   }
 
   ImageController::ImageDecodeRequestId id() { return id_; }
   ImageController::ImageDecodeResult result() { return result_; }
 
  private:
   ImageController::ImageDecodeRequestId id_ = 0;
   ImageController::ImageDecodeResult result_ =
       ImageController::ImageDecodeResult::FAILURE;
 };
@@ skipping 426 matching lines @@
             decode_client2.result());
 
   // Reset the controller since the order of destruction is wrong in this test
   // (|other_cache| should outlive the controller. This is normally done via
   // SetImageDecodeCache(nullptr) or it can be done in the dtor of the cache.)
   ResetController();
 }
 
 }  // namespace
 }  // namespace cc