Migrate base::TaskRunner from Closure to OnceClosure

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/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 {
 namespace {
 
 class TestWorkerThread : public base::SimpleThread {
  public:
   TestWorkerThread()
       : base::SimpleThread("test_worker_thread"), condition_(&lock_) {}
 
   void Run() override {
     for (;;) {
-      base::Closure task;
+      base::OnceClosure task;
       {
         base::AutoLock hold(lock_);
         if (shutdown_)
           break;
 
         if (queue_.empty()) {
           condition_.Wait();
           continue;
         }
 
         task = std::move(queue_.front());
         queue_.erase(queue_.begin());
       }
       std::move(task).Run();
     }
   }
 
   void Shutdown() {
     base::AutoLock hold(lock_);
     shutdown_ = true;
     condition_.Signal();
   }
 
-  void PostTask(base::Closure task) {
+  void PostTask(base::OnceClosure task) {
     base::AutoLock hold(lock_);
     queue_.push_back(std::move(task));
     condition_.Signal();
   }
 
  private:
   base::Lock lock_;
   base::ConditionVariable condition_;
-  std::vector<base::Closure> queue_;
+  std::vector<base::OnceClosure> queue_;
   bool shutdown_ = false;
 };
 
 class WorkerTaskRunner : public base::SequencedTaskRunner {
  public:
   WorkerTaskRunner() { thread_.Start(); }
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
-                                  base::Closure task,
+                                  base::OnceClosure task,
                                   base::TimeDelta delay) override {
     return PostDelayedTask(from_here, std::move(task), delay);
   }
 
   bool PostDelayedTask(const tracked_objects::Location& from_here,
-                       base::Closure task,
+                       base::OnceClosure task,
                        base::TimeDelta delay) override {
     thread_.PostTask(std::move(task));
     return true;
   }
 
   bool RunsTasksOnCurrentThread() const override { return false; }
 
  protected:
   ~WorkerTaskRunner() override {
     thread_.Shutdown();
@@ skipping 46 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(base::Closure quit_closure,
+  void Callback(base::OnceClosure quit_closure,
                 ImageController::ImageDecodeRequestId id,
                 ImageController::ImageDecodeResult result) {
     id_ = id;
     result_ = result;
     std::move(quit_closure).Run();
   }
 
   ImageController::ImageDecodeRequestId id() { return id_; }
   ImageController::ImageDecodeResult result() { return result_; }
 
@@ skipping 431 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