Migrate base::TaskRunner from Closure to OnceClosure

base/threading/worker_pool_posix.cc

 // Copyright (c) 2012 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/threading/worker_pool_posix.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 31 matching lines @@
 
 class WorkerPoolImpl {
  public:
   WorkerPoolImpl();
 
   // WorkerPoolImpl is only instantiated as a leaky LazyInstance, so the
   // destructor is never called.
   ~WorkerPoolImpl() = delete;
 
   void PostTask(const tracked_objects::Location& from_here,
-                base::Closure task,
+                base::OnceClosure task,
                 bool task_is_slow);
 
  private:
   scoped_refptr<base::PosixDynamicThreadPool> pool_;
 };
 
 WorkerPoolImpl::WorkerPoolImpl()
     : pool_(new base::PosixDynamicThreadPool("WorkerPool",
                                              kIdleSecondsBeforeExit)) {}
 
 void WorkerPoolImpl::PostTask(const tracked_objects::Location& from_here,
-                              base::Closure task,
+                              base::OnceClosure task,
                               bool task_is_slow) {
   pool_->PostTask(from_here, std::move(task));
 }
 
 base::LazyInstance<WorkerPoolImpl>::Leaky g_lazy_worker_pool =
     LAZY_INSTANCE_INITIALIZER;
 
 class WorkerThread : public PlatformThread::Delegate {
  public:
   WorkerThread(const std::string& name_prefix,
@@ skipping 32 matching lines @@
   }
 
   // The WorkerThread is non-joinable, so it deletes itself.
   delete this;
 }
 
 }  // namespace
 
 // static
 bool WorkerPool::PostTask(const tracked_objects::Location& from_here,
-                          base::Closure task,
+                          base::OnceClosure task,
                           bool task_is_slow) {
   g_lazy_worker_pool.Pointer()->PostTask(from_here, std::move(task),
                                          task_is_slow);
   return true;
 }
 
 // static
 bool WorkerPool::RunsTasksOnCurrentThread() {
   return g_worker_pool_running_on_this_thread.Get().Get();
 }
 
 PosixDynamicThreadPool::PosixDynamicThreadPool(const std::string& name_prefix,
                                                int idle_seconds_before_exit)
     : name_prefix_(name_prefix),
       idle_seconds_before_exit_(idle_seconds_before_exit),
       pending_tasks_available_cv_(&lock_),
       num_idle_threads_(0) {}
 
 PosixDynamicThreadPool::~PosixDynamicThreadPool() {
   while (!pending_tasks_.empty())
     pending_tasks_.pop();
 }
 
 void PosixDynamicThreadPool::PostTask(
     const tracked_objects::Location& from_here,
-    base::Closure task) {
+    base::OnceClosure task) {
   PendingTask pending_task(from_here, std::move(task));
   AddTask(&pending_task);
 }
 
 void PosixDynamicThreadPool::AddTask(PendingTask* pending_task) {
   DCHECK(pending_task);
   DCHECK(pending_task->task);
   AutoLock locked(lock_);
 
   pending_tasks_.push(std::move(*pending_task));
@@ skipping 27 matching lines @@
       return PendingTask(FROM_HERE, base::Closure());
     }
   }
 
   PendingTask pending_task = std::move(pending_tasks_.front());
   pending_tasks_.pop();
   return pending_task;
 }
 
 }  // namespace base