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

base/task_scheduler/scheduler_worker_unittest.cc

Index: base/task_scheduler/scheduler_worker_unittest.cc
diff --git a/base/task_scheduler/scheduler_worker_unittest.cc b/base/task_scheduler/scheduler_worker_unittest.cc
index 47a35cbecac7d672156b7dcd555fabb24ca475e1..cf6c8781268b0af013b6a427b6ac09e8c53f35fd 100644
--- a/base/task_scheduler/scheduler_worker_unittest.cc
+++ b/base/task_scheduler/scheduler_worker_unittest.cc
@@ -46,7 +46,8 @@ class SchedulerWorkerDefaultDelegate : public SchedulerWorker::Delegate {
   scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override {
     return nullptr;
   }
-  void DidRunTask(const Task* task, const TimeDelta& task_latency) override {
+  void DidRunTask(TaskPriority task_priority,
+                  const TimeDelta& task_latency) override {
     ADD_FAILURE() << "Unexpected call to DidRunTask()";
   }
   void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override {
@@ -174,7 +175,7 @@ class TaskSchedulerWorkerTest : public testing::TestWithParam<size_t> {
         sequence->PushTask(std::move(task));
       }
 
-      ExpectCallToDidRunTask(sequence->PeekTask());
+      ExpectCallToDidRunTask(sequence->PeekTaskTraits().priority());
 
       {
         // Add the Sequence to the vector of created Sequences.
@@ -185,11 +186,13 @@ class TaskSchedulerWorkerTest : public testing::TestWithParam<size_t> {
       return sequence;
     }
 
-    void DidRunTask(const Task* task, const TimeDelta& task_latency) override {
+    void DidRunTask(TaskPriority task_priority,
+                    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;
+      EXPECT_TRUE(expect_did_run_task_);
+      EXPECT_EQ(expect_did_run_task_with_priority_, task_priority);
       EXPECT_FALSE(task_latency.is_max());
+      expect_did_run_task_ = false;
     }
 
     // This override verifies that |sequence| contains the expected number of
@@ -202,10 +205,9 @@ class TaskSchedulerWorkerTest : public testing::TestWithParam<size_t> {
 
       // 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_);
@@ -215,27 +217,31 @@ class TaskSchedulerWorkerTest : public testing::TestWithParam<size_t> {
     }
 
    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) {
+    // Expect a call to DidRunTask() with |task_priority| as argument before the
+    // next call to any other method of this delegate.
+    void ExpectCallToDidRunTask(TaskPriority task_priority) {
       AutoSchedulerLock auto_lock(expect_did_run_task_lock_);
-      expect_did_run_task_ = task;
+      expect_did_run_task_ = true;
+      expect_did_run_task_with_priority_ = task_priority;
     }
 
     bool IsCallToDidRunTaskExpected() const {
       AutoSchedulerLock auto_lock(expect_did_run_task_lock_);
-      return expect_did_run_task_ != nullptr;
+      return expect_did_run_task_;
     }
 
     TaskSchedulerWorkerTest* outer_;
 
-    // Synchronizes access to |expect_did_run_task_|.
+    // Synchronizes access to |expect_did_run_task_| and
+    // |expect_did_run_task_with_priority_|.
     mutable SchedulerLock expect_did_run_task_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;
+    // When this is true, the next method called on this delegate should be

[robliao, 2016/10/07 20:57:11]

Instead: Whether the next method called on this delegate should be DidRunTask()

[fdoray, 2016/10/11 12:29:19]

Done.

+    // DidRunTask().
+    bool expect_did_run_task_ = false;
+
+    // Expected priority for the next call to DidRunTask().
+    TaskPriority expect_did_run_task_with_priority_ = TaskPriority::BACKGROUND;
   };
 
   void RunTaskCallback() {
@@ -384,7 +390,7 @@ class ControllableDetachDelegate : public SchedulerWorkerDefaultDelegate {
     return sequence;
   }
 
-  void DidRunTask(const Task* task, const TimeDelta& task_latency) override {}
+  void DidRunTask(TaskPriority task, const TimeDelta& task_latency) override {}
 
   bool CanDetach(SchedulerWorker* worker) override {
     detach_requested_.Signal();