TaskScheduler: Change Sequence::PeekTask to Sequence::TakeTask.

base/task_scheduler/scheduler_worker.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/scheduler_worker.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 52 matching lines @@
             DCHECK_EQ(detached_thread.get(), this);
             PlatformThread::Detach(thread_handle_);
             outer_ = nullptr;
             break;
           }
         }
         WaitForWork();
         continue;
       }
 
-      const Task* task = sequence->PeekTask();
-      const TimeTicks start_time = TimeTicks::Now();
-      if (outer_->task_tracker_->RunTask(task, sequence->token()))
-        outer_->delegate_->DidRunTask(task, start_time - task->sequenced_time);
+      std::unique_ptr<Task> task = sequence->TakeTask();
+      const TaskPriority task_priority = task->traits.priority();
+      const TimeDelta task_latency = TimeTicks::Now() - task->sequenced_time;
+      if (outer_->task_tracker_->RunTask(std::move(task), sequence->token()))
+        outer_->delegate_->DidRunTaskWithPriority(task_priority, task_latency);
 
-      const bool sequence_became_empty = sequence->PopTask();
+      const bool sequence_became_empty = sequence->Pop();
 
       // If |sequence| isn't empty immediately after the pop, re-enqueue it to
       // maintain the invariant that a non-empty Sequence is always referenced
       // by either a PriorityQueue or a SchedulerWorker. If it is empty
       // and there are live references to it, it will be enqueued when a Task is
       // added to it. Otherwise, it will be destroyed at the end of this scope.
       if (!sequence_became_empty)
         outer_->delegate_->ReEnqueueSequence(std::move(sequence));
 
       // Calling WakeUp() guarantees that this SchedulerWorker will run
@@ skipping 180 matching lines @@
   CreateThread();
 }
 
 bool SchedulerWorker::ShouldExitForTesting() const {
   AutoSchedulerLock auto_lock(should_exit_for_testing_lock_);
   return should_exit_for_testing_;
 }
 
 }  // namespace internal
 }  // namespace base