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

base/task_scheduler/scheduler_worker_unittest.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 <memory>
 #include <vector>
@@ skipping 28 matching lines @@
 class SchedulerWorkerDefaultDelegate : public SchedulerWorker::Delegate {
  public:
   SchedulerWorkerDefaultDelegate() = default;
 
   // SchedulerWorker::Delegate:
   void OnMainEntry(SchedulerWorker* worker,
                    const TimeDelta& detach_duration) override {}
   scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override {
     return nullptr;
   }
-  void DidRunTask(const Task* task, const TimeDelta& task_latency) override {
-    ADD_FAILURE() << "Unexpected call to DidRunTask()";
+  void DidRunTaskWithPriority(TaskPriority task_priority,
+                              const TimeDelta& task_latency) override {
+    ADD_FAILURE() << "Unexpected call to DidRunTaskWithPriority()";
   }
   void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override {
     ADD_FAILURE() << "Unexpected call to ReEnqueueSequence()";
   }
   TimeDelta GetSleepTimeout() override { return TimeDelta::Max(); }
   bool CanDetach(SchedulerWorker* worker) override { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SchedulerWorkerDefaultDelegate);
 };
@@ skipping 58 matching lines @@
 
   std::unique_ptr<SchedulerWorker> worker_;
 
  private:
   class TestSchedulerWorkerDelegate : public SchedulerWorkerDefaultDelegate {
    public:
     TestSchedulerWorkerDelegate(TaskSchedulerWorkerTest* outer)
         : outer_(outer) {}
 
     ~TestSchedulerWorkerDelegate() override {
-      EXPECT_FALSE(IsCallToDidRunTaskExpected());
+      EXPECT_FALSE(IsCallToDidRunTaskWithPriorityExpected());
     }
 
     // SchedulerWorker::Delegate:
     void OnMainEntry(SchedulerWorker* worker,
                      const TimeDelta& detach_duration) override {
       outer_->worker_set_.Wait();
       EXPECT_EQ(outer_->worker_.get(), worker);
-      EXPECT_FALSE(IsCallToDidRunTaskExpected());
+      EXPECT_FALSE(IsCallToDidRunTaskWithPriorityExpected());
 
       // Without synchronization, OnMainEntry() could be called twice without
       // generating an error.
       AutoSchedulerLock auto_lock(outer_->lock_);
       EXPECT_FALSE(outer_->main_entry_called_.IsSignaled());
       outer_->main_entry_called_.Signal();
     }
 
     scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override {
-      EXPECT_FALSE(IsCallToDidRunTaskExpected());
+      EXPECT_FALSE(IsCallToDidRunTaskWithPriorityExpected());
       EXPECT_EQ(outer_->worker_.get(), worker);
 
       {
         AutoSchedulerLock auto_lock(outer_->lock_);
 
         // Increment the number of times that this method has been called.
         ++outer_->num_get_work_;
         outer_->num_get_work_cv_->Signal();
 
         // Verify that this method isn't called more times than expected.
         EXPECT_LE(outer_->num_get_work_, outer_->max_get_work_);
 
         // Check if a Sequence should be returned.
         if (outer_->num_sequences_to_create_ == 0)
           return nullptr;
         --outer_->num_sequences_to_create_;
       }
 
       // Create a Sequence with TasksPerSequence() Tasks.
       scoped_refptr<Sequence> sequence(new Sequence);
       for (size_t i = 0; i < outer_->TasksPerSequence(); ++i) {
         std::unique_ptr<Task> task(new Task(
             FROM_HERE, Bind(&TaskSchedulerWorkerTest::RunTaskCallback,
                             Unretained(outer_)),
             TaskTraits(), TimeDelta()));
         EXPECT_TRUE(outer_->task_tracker_.WillPostTask(task.get()));
         sequence->PushTask(std::move(task));
       }
 
-      ExpectCallToDidRunTask(sequence->PeekTask());
+      ExpectCallToDidRunTaskWithPriority(sequence->PeekTaskTraits().priority());
 
       {
         // Add the Sequence to the vector of created Sequences.
         AutoSchedulerLock auto_lock(outer_->lock_);
         outer_->created_sequences_.push_back(sequence);
       }
 
       return sequence;
     }
 
-    void DidRunTask(const Task* task, const TimeDelta& task_latency) override {
-      AutoSchedulerLock auto_lock(expect_did_run_task_lock_);
-      EXPECT_EQ(expect_did_run_task_, task);
-      expect_did_run_task_ = nullptr;
+    void DidRunTaskWithPriority(TaskPriority task_priority,
+                                const TimeDelta& task_latency) override {
+      AutoSchedulerLock auto_lock(expect_did_run_task_with_priority_lock_);
+      EXPECT_TRUE(expect_did_run_task_with_priority_);
+      EXPECT_EQ(expected_task_priority_, task_priority);
       EXPECT_FALSE(task_latency.is_max());
+      expect_did_run_task_with_priority_ = false;
     }
 
     // This override verifies that |sequence| contains the expected number of
     // Tasks and adds it to |enqueued_sequences_|. Unlike a normal
     // EnqueueSequence implementation, it doesn't reinsert |sequence| into a
     // queue for further execution.
     void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override {
-      EXPECT_FALSE(IsCallToDidRunTaskExpected());
+      EXPECT_FALSE(IsCallToDidRunTaskWithPriorityExpected());
       EXPECT_GT(outer_->TasksPerSequence(), 1U);
 
       // Verify that |sequence| contains TasksPerSequence() - 1 Tasks.
       for (size_t i = 0; i < outer_->TasksPerSequence() - 1; ++i) {
-        EXPECT_TRUE(sequence->PeekTask());
-        sequence->PopTask();
+        EXPECT_TRUE(sequence->TakeTask());
+        EXPECT_EQ(i == outer_->TasksPerSequence() - 2, sequence->Pop());
       }
-      EXPECT_FALSE(sequence->PeekTask());
 
       // Add |sequence| to |re_enqueued_sequences_|.
       AutoSchedulerLock auto_lock(outer_->lock_);
       outer_->re_enqueued_sequences_.push_back(std::move(sequence));
       EXPECT_LE(outer_->re_enqueued_sequences_.size(),
                 outer_->created_sequences_.size());
     }
 
    private:
-    // Expect a call to DidRunTask() with |task| as argument before the next
-    // call to any other method of this delegate.
-    void ExpectCallToDidRunTask(const Task* task) {
-      AutoSchedulerLock auto_lock(expect_did_run_task_lock_);
-      expect_did_run_task_ = task;
+    // Expect a call to DidRunTaskWithPriority() with |task_priority| as
+    // argument before the next call to any other method of this delegate.
+    void ExpectCallToDidRunTaskWithPriority(TaskPriority task_priority) {
+      AutoSchedulerLock auto_lock(expect_did_run_task_with_priority_lock_);
+      expect_did_run_task_with_priority_ = true;
+      expected_task_priority_ = task_priority;
     }
 
-    bool IsCallToDidRunTaskExpected() const {
-      AutoSchedulerLock auto_lock(expect_did_run_task_lock_);
-      return expect_did_run_task_ != nullptr;
+    bool IsCallToDidRunTaskWithPriorityExpected() const {
+      AutoSchedulerLock auto_lock(expect_did_run_task_with_priority_lock_);
+      return expect_did_run_task_with_priority_;
     }
 
     TaskSchedulerWorkerTest* outer_;
 
-    // Synchronizes access to |expect_did_run_task_|.
-    mutable SchedulerLock expect_did_run_task_lock_;
+    // Synchronizes access to |expect_did_run_task_with_priority_| and
+    // |expected_task_priority_|.
+    mutable SchedulerLock expect_did_run_task_with_priority_lock_;
 
-    // Expected task for the next call to DidRunTask(). DidRunTask() should not
-    // be called when this is nullptr. No method other than DidRunTask() should
-    // be called on this delegate when this is not nullptr.
-    const Task* expect_did_run_task_ = nullptr;
+    // Whether the next method called on this delegate should be
+    // DidRunTaskWithPriority().
+    bool expect_did_run_task_with_priority_ = false;
+
+    // Expected priority for the next call to DidRunTaskWithPriority().
+    TaskPriority expected_task_priority_ = TaskPriority::BACKGROUND;
   };
 
   void RunTaskCallback() {
     AutoSchedulerLock auto_lock(lock_);
     ++num_run_tasks_;
     EXPECT_LE(num_run_tasks_, created_sequences_.size());
   }
 
   TaskTracker task_tracker_;
 
@@ skipping 128 matching lines @@
     work_requested_ = true;
     scoped_refptr<Sequence> sequence(new Sequence);
     std::unique_ptr<Task> task(new Task(
         FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&work_processed_)),
         TaskTraits(), TimeDelta()));
     EXPECT_TRUE(task_tracker_->WillPostTask(task.get()));
     sequence->PushTask(std::move(task));
     return sequence;
   }
 
-  void DidRunTask(const Task* task, const TimeDelta& task_latency) override {}
+  void DidRunTaskWithPriority(TaskPriority task,
+                              const TimeDelta& task_latency) override {}
 
   bool CanDetach(SchedulerWorker* worker) override {
     detach_requested_.Signal();
     return can_detach_;
   }
 
   void WaitForWorkToRun() {
     work_processed_.Wait();
   }
 
@@ skipping 192 matching lines @@
   // OnMainEntry() and GetWork() are called.
   worker->WakeUp();
   delegate_raw->WaitForPriorityVerifiedInGetWork();
 
   worker->JoinForTesting();
 }
 
 }  // namespace
 }  // namespace internal
 }  // namespace base