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

base/task_scheduler/task_tracker.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 "base/task_scheduler/task_tracker.h"
 
 #include <limits>
 
 #include "base/callback.h"
 #include "base/debug/task_annotator.h"
@@ skipping 148 matching lines @@
 
   if (task->delayed_run_time.is_null())
     subtle::NoBarrier_AtomicIncrement(&num_pending_undelayed_tasks_, 1);
 
   debug::TaskAnnotator task_annotator;
   task_annotator.DidQueueTask(kQueueFunctionName, *task);
 
   return true;
 }
 
-bool TaskTracker::RunTask(const Task* task,
-                          const SequenceToken& sequence_token) {
+bool TaskTracker::RunTask(Task* task, const SequenceToken& sequence_token) {
   DCHECK(task);
   DCHECK(sequence_token.IsValid());
 
   const TaskShutdownBehavior shutdown_behavior =
       task->traits.shutdown_behavior();
   const bool can_run_task = BeforeRunTask(shutdown_behavior);
 
   if (can_run_task) {
     // All tasks run through here and the scheduler itself doesn't use
     // singletons. Therefore, it isn't necessary to reset the singleton allowed
@@ skipping 16 matching lines @@
         sequenced_task_runner_handle.reset(
             new SequencedTaskRunnerHandle(task->sequenced_task_runner_ref));
       } else if (task->single_thread_task_runner_ref) {
         single_thread_task_runner_handle.reset(
             new ThreadTaskRunnerHandle(task->single_thread_task_runner_ref));
       }
 
       TRACE_TASK_EXECUTION(kRunFunctionName, *task);
 
       debug::TaskAnnotator task_annotator;
-      task_annotator.RunTask(kQueueFunctionName, *task);
+      task_annotator.RunTask(kQueueFunctionName, task);
     }
 
     AfterRunTask(shutdown_behavior);
   }
 
   if (task->delayed_run_time.is_null())
     DecrementNumPendingUndelayedTasks();
 
   return can_run_task;
 }
@@ skipping 166 matching lines @@
       subtle::NoBarrier_AtomicIncrement(&num_pending_undelayed_tasks_, -1);
   DCHECK_GE(new_num_pending_undelayed_tasks, 0);
   if (new_num_pending_undelayed_tasks == 0) {
     AutoSchedulerLock auto_lock(flush_lock_);
     flush_cv_->Signal();
   }
 }
 
 }  // namespace internal
 }  // namespace base