Replace Closure in TaskRunner::PostTask with OneShotCallback

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 "base/bind.h"
 #include "base/callback.h"
@@ skipping 18 matching lines @@
     g_worker_pool_running_on_this_thread = LAZY_INSTANCE_INITIALIZER;
 
 const int kIdleSecondsBeforeExit = 10 * 60;
 
 class WorkerPoolImpl {
  public:
   WorkerPoolImpl();
   ~WorkerPoolImpl();
 
   void PostTask(const tracked_objects::Location& from_here,
-                const base::Closure& task,
+                OnceClosure task,
                 bool task_is_slow);
 
  private:
   scoped_refptr<base::PosixDynamicThreadPool> pool_;
 };
 
 WorkerPoolImpl::WorkerPoolImpl()
     : pool_(new base::PosixDynamicThreadPool("WorkerPool",
                                              kIdleSecondsBeforeExit)) {}
 
 WorkerPoolImpl::~WorkerPoolImpl() {
   pool_->Terminate();
 }
 
 void WorkerPoolImpl::PostTask(const tracked_objects::Location& from_here,
-                              const base::Closure& task,
+                              OnceClosure task,
                               bool task_is_slow) {
-  pool_->PostTask(from_here, task);
+  pool_->PostTask(from_here, std::move(task));
 }
 
 base::LazyInstance<WorkerPoolImpl> g_lazy_worker_pool =
     LAZY_INSTANCE_INITIALIZER;
 
 class WorkerThread : public PlatformThread::Delegate {
  public:
   WorkerThread(const std::string& name_prefix,
                base::PosixDynamicThreadPool* pool)
       : name_prefix_(name_prefix), pool_(pool) {}
@@ skipping 15 matching lines @@
   PlatformThread::SetName(name);
 
   for (;;) {
     PendingTask pending_task = pool_->WaitForTask();
     if (pending_task.task.is_null())
       break;
     TRACE_TASK_EXECUTION("WorkerThread::ThreadMain::Run", pending_task);
 
     tracked_objects::TaskStopwatch stopwatch;
     stopwatch.Start();
-    pending_task.task.Run();
+    std::move(pending_task.task).Run();
     stopwatch.Stop();
 
     tracked_objects::ThreadData::TallyRunOnWorkerThreadIfTracking(
         pending_task.birth_tally, pending_task.time_posted, stopwatch);
   }
 
   // The WorkerThread is non-joinable, so it deletes itself.
   delete this;
 }
 
 }  // namespace
 
 // static
 bool WorkerPool::PostTask(const tracked_objects::Location& from_here,
-                          const base::Closure& task,
+                          OnceClosure task,
                           bool task_is_slow) {
-  g_lazy_worker_pool.Pointer()->PostTask(from_here, task, 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)
@@ skipping 12 matching lines @@
   {
     AutoLock locked(lock_);
     DCHECK(!terminated_) << "Thread pool is already terminated.";
     terminated_ = true;
   }
   pending_tasks_available_cv_.Broadcast();
 }
 
 void PosixDynamicThreadPool::PostTask(
     const tracked_objects::Location& from_here,
-    const base::Closure& task) {
-  PendingTask pending_task(from_here, task);
+    OnceClosure task) {
+  PendingTask pending_task(from_here, std::move(task));
   AddTask(&pending_task);
 }
 
 void PosixDynamicThreadPool::AddTask(PendingTask* pending_task) {
   AutoLock locked(lock_);
   DCHECK(!terminated_)
       << "This thread pool is already terminated.  Do not post new tasks.";
 
   pending_tasks_.push(std::move(*pending_task));
 
@@ skipping 29 matching lines @@
       return PendingTask(FROM_HERE, base::Closure());
     }
   }
 
   PendingTask pending_task = std::move(pending_tasks_.front());
   pending_tasks_.pop();
   return pending_task;
 }
 
 }  // namespace base