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

base/task_scheduler/scheduler_worker_pool_impl.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_pool_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 220 matching lines @@
   ~SchedulerWorkerDelegateImpl() override;
 
   PriorityQueue* single_threaded_priority_queue() {
     return &single_threaded_priority_queue_;
   }
 
   // SchedulerWorker::Delegate:
   void OnMainEntry(SchedulerWorker* worker,
                    const TimeDelta& detach_duration) override;
   scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override;
-  void DidRunTask(const Task* task, const TimeDelta& task_latency) override;
+  void DidRunTaskWithPriority(TaskPriority task_priority,
+                              const TimeDelta& task_latency) override;
   void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override;
   TimeDelta GetSleepTimeout() override;
   bool CanDetach(SchedulerWorker* worker) override;
 
   void RegisterSingleThreadTaskRunner() {
     // No barrier as barriers only affect sequential consistency which is
     // irrelevant in a single variable use case (they don't force an immediate
     // flush anymore than atomics do by default).
     subtle::NoBarrier_AtomicIncrement(&num_single_threaded_runners_, 1);
   }
@@ skipping 329 matching lines @@
   DCHECK(sequence);
 
   outer_->RemoveFromIdleWorkersStack(worker);
   idle_start_time_ = TimeTicks();
   did_detach_since_last_get_work_ = false;
   last_get_work_returned_nullptr_ = false;
 
   return sequence;
 }
 
-void SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::DidRunTask(
-    const Task* task,
-    const TimeDelta& task_latency) {
+void SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::
+    DidRunTaskWithPriority(TaskPriority task_priority,
+                           const TimeDelta& task_latency) {
   ++num_tasks_since_last_wait_;
 
-  const int priority_index = static_cast<int>(task->traits.priority());
+  const int priority_index = static_cast<int>(task_priority);
 
   // As explained in the header file, histograms are allocated on demand. It
   // doesn't matter if an element of |task_latency_histograms_| is set multiple
   // times since GetTaskLatencyHistogram() is idempotent. As explained in the
   // comment at the top of histogram_macros.h, barriers are required.
   HistogramBase* task_latency_histogram = reinterpret_cast<HistogramBase*>(
       subtle::Acquire_Load(&outer_->task_latency_histograms_[priority_index]));
   if (!task_latency_histogram) {
     task_latency_histogram =
-        GetTaskLatencyHistogram(outer_->name_, task->traits.priority());
+        GetTaskLatencyHistogram(outer_->name_, task_priority);
     subtle::Release_Store(
         &outer_->task_latency_histograms_[priority_index],
         reinterpret_cast<subtle::AtomicWord>(task_latency_histogram));
   }
 
   task_latency_histogram->AddTime(task_latency);
 }
 
 void SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::
     ReEnqueueSequence(scoped_refptr<Sequence> sequence) {
@@ skipping 135 matching lines @@
   AutoSchedulerLock auto_lock(idle_workers_stack_lock_);
   idle_workers_stack_.Remove(worker);
 }
 
 bool SchedulerWorkerPoolImpl::CanWorkerDetachForTesting() {
   return !worker_detachment_disallowed_.IsSet();
 }
 
 }  // namespace internal
 }  // namespace base