Replace base::Callback with base::OnceCallback in base::PendingTask

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

 // Copyright 2014 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_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 20 matching lines @@
 
 void RecordImmediateTaskQueueingDuration(tracked_objects::Duration duration) {
   UMA_HISTOGRAM_TIMES(
       "RendererScheduler.TaskQueueManager.ImmediateTaskQueueingDuration",
       base::TimeDelta::FromMilliseconds(duration.InMilliseconds()));
 }
 
 double MonotonicTimeInSeconds(base::TimeTicks timeTicks) {
   return (timeTicks - base::TimeTicks()).InSecondsF();
 }
+
+// Converts a OnceClosure to a RepeatingClosure. It hits CHECK failure to run
+// the resulting RepeatingClosure more than once.
+// TODO(tzik): This will be unneeded after the Closure-to-OnceClosure migration
+// on TaskRunner finished. Remove it once it gets unneeded.
+base::RepeatingClosure UnsafeConvertOnceClosureToRepeating(
+    base::OnceClosure cb) {
+  return base::BindRepeating([](base::OnceClosure cb) { std::move(cb).Run(); },
+                             base::Passed(&cb));
+}
 }
 
 TaskQueueManager::TaskQueueManager(
     scoped_refptr<TaskQueueManagerDelegate> delegate,
     const char* tracing_category,
     const char* disabled_by_default_tracing_category,
     const char* disabled_by_default_verbose_tracing_category)
     : real_time_domain_(new RealTimeDomain(tracing_category)),
       delegate_(delegate),
       task_was_run_on_quiescence_monitored_queue_(false),
@@ skipping 261 matching lines @@
 
   internal::TaskQueueImpl* queue = work_queue->task_queue();
   if (queue->GetQuiescenceMonitored())
     task_was_run_on_quiescence_monitored_queue_ = true;
 
   if (!pending_task.nestable && delegate_->IsNested()) {
     // Defer non-nestable work to the main task runner.  NOTE these tasks can be
     // arbitrarily delayed so the additional delay should not be a problem.
     // TODO(skyostil): Figure out a way to not forget which task queue the
     // task is associated with. See http://crbug.com/522843.
-    delegate_->PostNonNestableTask(pending_task.posted_from,
-                                   std::move(pending_task.task));
+    // TODO(tzik): Remove base::UnsafeConvertOnceClosureToRepeating once
+    // TaskRunners have migrated to OnceClosure.
+    delegate_->PostNonNestableTask(
+        pending_task.posted_from,
+        UnsafeConvertOnceClosureToRepeating(std::move(pending_task.task)));
     return ProcessTaskResult::DEFERRED;
   }
 
   MaybeRecordTaskDelayHistograms(pending_task, queue);
 
   TRACE_TASK_EXECUTION("TaskQueueManager::ProcessTaskFromWorkQueue",
                        pending_task);
   if (queue->GetShouldNotifyObservers()) {
     FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver, task_observers_,
                       WillProcessTask(pending_task));
     queue->NotifyWillProcessTask(pending_task);
   }
   TRACE_EVENT1(tracing_category_, "TaskQueueManager::RunTask", "queue",
                queue->GetName());
   // NOTE when TaskQueues get unregistered a reference ends up getting retained
   // by |queues_to_delete_| which is cleared at the top of |DoWork|. This means
   // we are OK to use raw pointers here.
   internal::TaskQueueImpl* prev_executing_task_queue =
       currently_executing_task_queue_;
   currently_executing_task_queue_ = queue;
-  task_annotator_.RunTask("TaskQueueManager::PostTask", pending_task);
+  task_annotator_.RunTask("TaskQueueManager::PostTask", &pending_task);
   // Detect if the TaskQueueManager just got deleted.  If this happens we must
   // not access any member variables after this point.
   if (protect->HasOneRef())
     return ProcessTaskResult::TASK_QUEUE_MANAGER_DELETED;
 
   currently_executing_task_queue_ = prev_executing_task_queue;
 
   if (queue->GetShouldNotifyObservers()) {
     FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver, task_observers_,
                       DidProcessTask(pending_task));
@@ skipping 110 matching lines @@
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(!work_queue->Empty());
   if (observer_) {
     observer_->OnTriedToExecuteBlockedTask(*work_queue->task_queue(),
                                            *work_queue->GetFrontTask());
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink