Replace Closure in TaskRunner::PostTask with OneShotCallback

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc

 // Copyright 2015 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 "platform/scheduler/base/task_queue_impl.h"
 
 #include "base/trace_event/blame_context.h"
 #include "platform/scheduler/base/task_queue_manager.h"
 #include "platform/scheduler/base/task_queue_manager_delegate.h"
 #include "platform/scheduler/base/time_domain.h"
@@ skipping 33 matching lines @@
   // contains a strong reference to this TaskQueueImpl and the TaskQueueManager
   // destructor calls UnregisterTaskQueue on all task queues.
   DCHECK(any_thread().task_queue_manager == nullptr)
       << "UnregisterTaskQueue must be called first!";
 
 #endif
 }
 
 TaskQueueImpl::Task::Task()
     : PendingTask(tracked_objects::Location(),
-                  base::Closure(),
+                  base::OnceClosure(),
                   base::TimeTicks(),
                   true),
 #ifndef NDEBUG
       enqueue_order_set_(false),
 #endif
       enqueue_order_(0) {
   sequence_num = 0;
 }
 
 TaskQueueImpl::Task::Task(const tracked_objects::Location& posted_from,
-                          const base::Closure& task,
+                          base::OnceClosure task,
                           base::TimeTicks desired_run_time,
                           EnqueueOrder sequence_number,
                           bool nestable)
-    : PendingTask(posted_from, task, desired_run_time, nestable),
+    : PendingTask(posted_from, std::move(task), desired_run_time, nestable),
 #ifndef NDEBUG
       enqueue_order_set_(false),
 #endif
       enqueue_order_(0) {
   sequence_num = sequence_number;
 }
 
 TaskQueueImpl::Task::Task(const tracked_objects::Location& posted_from,
-                          const base::Closure& task,
+                          base::OnceClosure task,
                           base::TimeTicks desired_run_time,
                           EnqueueOrder sequence_number,
                           bool nestable,
                           EnqueueOrder enqueue_order)
-    : PendingTask(posted_from, task, desired_run_time, nestable),
+    : PendingTask(posted_from, std::move(task), desired_run_time, nestable),
 #ifndef NDEBUG
       enqueue_order_set_(true),
 #endif
       enqueue_order_(enqueue_order) {
   sequence_num = sequence_number;
 }
 
 TaskQueueImpl::AnyThread::AnyThread(TaskQueueManager* task_queue_manager,
                                     TimeDomain* time_domain)
     : task_queue_manager(task_queue_manager), time_domain(time_domain) {}
@@ skipping 33 matching lines @@
   main_thread_only().delayed_work_queue.reset();
 }
 
 bool TaskQueueImpl::RunsTasksOnCurrentThread() const {
   base::AutoLock lock(any_thread_lock_);
   return base::PlatformThread::CurrentId() == thread_id_;
 }
 
 
 bool TaskQueueImpl::PostDelayedTask(const tracked_objects::Location& from_here,
-                                    const base::Closure& task,
+                                    base::OnceClosure task,
                                     base::TimeDelta delay) {
   if (delay.is_zero())
-    return PostImmediateTaskImpl(from_here, task, TaskType::NORMAL);
+    return PostImmediateTaskImpl(from_here, std::move(task), TaskType::NORMAL);
 
-  return PostDelayedTaskImpl(from_here, task, delay, TaskType::NORMAL);
+  return PostDelayedTaskImpl(
+      from_here, std::move(task), delay, TaskType::NORMAL);
 }
 
 bool TaskQueueImpl::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
-    const base::Closure& task,
+    base::OnceClosure task,
     base::TimeDelta delay) {
-  if (delay.is_zero())
-    return PostImmediateTaskImpl(from_here, task, TaskType::NON_NESTABLE);
+  if (delay.is_zero()) {
+    return PostImmediateTaskImpl(
+        from_here, std::move(task), TaskType::NON_NESTABLE);
+  }
 
-  return PostDelayedTaskImpl(from_here, task, delay, TaskType::NON_NESTABLE);
+  return PostDelayedTaskImpl(
+      from_here, std::move(task), delay, TaskType::NON_NESTABLE);
 }
 
 bool TaskQueueImpl::PostImmediateTaskImpl(
     const tracked_objects::Location& from_here,
-    const base::Closure& task,
+    base::OnceClosure task,
     TaskType task_type) {
   base::AutoLock lock(any_thread_lock_);
   if (!any_thread().task_queue_manager)
     return false;
 
   EnqueueOrder sequence_number =
       any_thread().task_queue_manager->GetNextSequenceNumber();
 
   PushOntoImmediateIncomingQueueLocked(
       from_here,
-      task,
+      std::move(task),
       base::TimeTicks(),
       sequence_number,
       task_type != TaskType::NON_NESTABLE);
   return true;
 }
 
 bool TaskQueueImpl::PostDelayedTaskImpl(
     const tracked_objects::Location& from_here,
-    const base::Closure& task,
+    base::OnceClosure task,
     base::TimeDelta delay,
     TaskType task_type) {
   DCHECK_GT(delay, base::TimeDelta());
   if (base::PlatformThread::CurrentId() == thread_id_) {
     // Lock-free fast path for delayed tasks posted from the main thread.
     if (!main_thread_only().task_queue_manager)
       return false;
 
     EnqueueOrder sequence_number =
         main_thread_only().task_queue_manager->GetNextSequenceNumber();
 
     base::TimeTicks time_domain_now = main_thread_only().time_domain->Now();
     base::TimeTicks time_domain_delayed_run_time = time_domain_now + delay;
     PushOntoDelayedIncomingQueueFromMainThread(
-        Task(from_here, task, time_domain_delayed_run_time, sequence_number,
+        Task(from_here, std::move(task), time_domain_delayed_run_time, sequence_number,
              task_type != TaskType::NON_NESTABLE),
         time_domain_now);
   } else {
     // NOTE posting a delayed task from a different thread is not expected to
     // be common. This pathway is less optimal than perhaps it could be
     // because it causes two main thread tasks to be run.  Should this
     // assumption prove to be false in future, we may need to revisit this.
     base::AutoLock lock(any_thread_lock_);
     if (!any_thread().task_queue_manager)
       return false;
 
     EnqueueOrder sequence_number =
         any_thread().task_queue_manager->GetNextSequenceNumber();
 
     base::TimeTicks time_domain_now = any_thread().time_domain->Now();
     base::TimeTicks time_domain_delayed_run_time = time_domain_now + delay;
     PushOntoDelayedIncomingQueueLocked(
-        Task(from_here, task, time_domain_delayed_run_time, sequence_number,
-             task_type != TaskType::NON_NESTABLE));
+        Task(from_here, std::move(task), time_domain_delayed_run_time,
+             sequence_number, task_type != TaskType::NON_NESTABLE));
   }
   return true;
 }
 
 void TaskQueueImpl::PushOntoDelayedIncomingQueueFromMainThread(
     Task pending_task, base::TimeTicks now) {
   main_thread_only().task_queue_manager->DidQueueTask(pending_task);
 
   // Schedule a later call to MoveReadyDelayedTasksToDelayedWorkQueue.
   base::TimeTicks delayed_run_time = pending_task.delayed_run_time;
@@ skipping 12 matching lines @@
      FROM_HERE,
      base::Bind(&TaskQueueImpl::ScheduleDelayedWorkTask, this,
                 base::Passed(&pending_task)),
      base::TimeTicks(),
      thread_hop_task_sequence_number,
      false);
 }
 
 void TaskQueueImpl::PushOntoImmediateIncomingQueueLocked(
          const tracked_objects::Location& posted_from,
-         const base::Closure& task,
+         base::OnceClosure task,
          base::TimeTicks desired_run_time,
          EnqueueOrder sequence_number,
          bool nestable) {
   if (any_thread().immediate_incoming_queue.empty())
     any_thread().time_domain->RegisterAsUpdatableTaskQueue(this);
   // If the |immediate_incoming_queue| is empty we need a DoWork posted to make
   // it run.
   if (any_thread().immediate_incoming_queue.empty()) {
     // There's no point posting a DoWork for a disabled queue, however we can
     // only tell if it's disabled from the main thread.
     if (base::PlatformThread::CurrentId() == thread_id_) {
       if (main_thread_only().is_enabled && !BlockedByFenceLocked())
         any_thread().task_queue_manager->MaybeScheduleImmediateWork(FROM_HERE);
     } else {
       any_thread().task_queue_manager->MaybeScheduleImmediateWork(FROM_HERE);
     }
   }
   any_thread().immediate_incoming_queue.emplace(
-      posted_from, task, desired_run_time, sequence_number, nestable, sequence_number);
+      posted_from, std::move(task), desired_run_time, sequence_number, nestable, sequence_number);
   any_thread().task_queue_manager->DidQueueTask( any_thread().immediate_incoming_queue.back());
   TraceQueueSize(true);
 }
 
 void TaskQueueImpl::ScheduleDelayedWorkTask(Task pending_task) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   base::TimeTicks delayed_run_time = pending_task.delayed_run_time;
   base::TimeTicks time_domain_now = main_thread_only().time_domain->Now();
   // Make sure |delayed_run_time| isn't in the past.
   if (delayed_run_time < time_domain_now) {
@@ skipping 396 matching lines @@
   state->SetBoolean("is_cancelled", task.task.IsCancelled());
   state->SetDouble(
       "delayed_run_time",
       (task.delayed_run_time - base::TimeTicks()).InMicroseconds() / 1000.0L);
   state->EndDictionary();
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink