scheduler: Maintain a constant enqueue order for every task

third_party/WebKit/Source/platform/scheduler/base/task_queue_selector_unittest.cc

 // Copyright 2015 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 "platform/scheduler/base/task_queue_selector.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 48 matching lines @@
   }
   WorkQueueSets* immediate_work_queue_sets() {
     return enabled_selector()->immediate_work_queue_sets();
   }
 
   void PushTasks(const size_t queue_indices[], size_t num_tasks) {
     std::set<size_t> changed_queue_set;
     for (size_t i = 0; i < num_tasks; i++) {
       changed_queue_set.insert(queue_indices[i]);
       task_queues_[queue_indices[i]]->immediate_work_queue()->Push(
-          TaskQueueImpl::Task(FROM_HERE, test_closure_, base::TimeTicks(), 0,
-                              true, i));
+          TaskQueueImpl::Task(FROM_HERE, test_closure_, {base::TimeTicks(), i},
+                              true));
     }
   }
 
   void PushTasksWithEnqueueOrder(const size_t queue_indices[],
                                  const size_t enqueue_orders[],
                                  size_t num_tasks) {
     std::set<size_t> changed_queue_set;
     for (size_t i = 0; i < num_tasks; i++) {
       changed_queue_set.insert(queue_indices[i]);
       task_queues_[queue_indices[i]]->immediate_work_queue()->Push(
-          TaskQueueImpl::Task(FROM_HERE, test_closure_, base::TimeTicks(), 0,
-                              true, enqueue_orders[i]));
+          TaskQueueImpl::Task(FROM_HERE, test_closure_,
+                              {base::TimeTicks(), enqueue_orders[i]}, true));
     }
   }
 
   std::vector<size_t> PopTasks() {
     std::vector<size_t> order;
     WorkQueue* chosen_work_queue;
     while (selector_.SelectWorkQueueToService(&chosen_work_queue)) {
       size_t chosen_queue_index =
           queue_to_index_map_.find(chosen_work_queue->task_queue())->second;
       order.push_back(chosen_queue_index);
@@ skipping 278 matching lines @@
 TEST_F(TaskQueueSelectorTest, ChooseOldestWithPriority_Empty) {
   WorkQueue* chosen_work_queue = nullptr;
   bool chose_delayed_over_immediate = false;
   EXPECT_FALSE(enabled_selector()->ChooseOldestWithPriority(
       TaskQueue::NORMAL_PRIORITY, &chose_delayed_over_immediate,
       &chosen_work_queue));
   EXPECT_FALSE(chose_delayed_over_immediate);
 }
 
 TEST_F(TaskQueueSelectorTest, ChooseOldestWithPriority_OnlyDelayed) {
-  task_queues_[0]->delayed_work_queue()->Push(TaskQueueImpl::Task(
-      FROM_HERE, test_closure_, base::TimeTicks(), 0, true, 0));
+  task_queues_[0]->delayed_work_queue()->Push(
+      TaskQueueImpl::Task(FROM_HERE, test_closure_, EnqueueOrder(), true));
 
   WorkQueue* chosen_work_queue = nullptr;
   bool chose_delayed_over_immediate = false;
   EXPECT_TRUE(enabled_selector()->ChooseOldestWithPriority(
       TaskQueue::NORMAL_PRIORITY, &chose_delayed_over_immediate,
       &chosen_work_queue));
   EXPECT_EQ(chosen_work_queue, task_queues_[0]->delayed_work_queue());
   EXPECT_FALSE(chose_delayed_over_immediate);
 }
 
 TEST_F(TaskQueueSelectorTest, ChooseOldestWithPriority_OnlyImmediate) {
-  task_queues_[0]->immediate_work_queue()->Push(TaskQueueImpl::Task(
-      FROM_HERE, test_closure_, base::TimeTicks(), 0, true, 0));
+  task_queues_[0]->immediate_work_queue()->Push(
+      TaskQueueImpl::Task(FROM_HERE, test_closure_, EnqueueOrder(), true));
 
   WorkQueue* chosen_work_queue = nullptr;
   bool chose_delayed_over_immediate = false;
   EXPECT_TRUE(enabled_selector()->ChooseOldestWithPriority(
       TaskQueue::NORMAL_PRIORITY, &chose_delayed_over_immediate,
       &chosen_work_queue));
   EXPECT_EQ(chosen_work_queue, task_queues_[0]->immediate_work_queue());
   EXPECT_FALSE(chose_delayed_over_immediate);
 }
 
 TEST_F(TaskQueueSelectorTest, TestObserverWithOneBlockedQueue) {
   TaskQueueSelectorForTest selector;
   MockObserver mock_observer;
   selector.SetTaskQueueSelectorObserver(&mock_observer);
 
   EXPECT_CALL(mock_observer, OnTaskQueueEnabled(_)).Times(1);
 
   scoped_refptr<TaskQueueImpl> task_queue(NewTaskQueueWithBlockReporting());
   selector.AddQueue(task_queue.get());
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
       task_queue->CreateQueueEnabledVoter();
 
   voter->SetQueueEnabled(false);
   selector.DisableQueue(task_queue.get());
 
-  TaskQueueImpl::Task task(FROM_HERE, test_closure_, base::TimeTicks(), 0,
-                           true);
-  task.set_enqueue_order(0);
+  TaskQueueImpl::Task task(FROM_HERE, test_closure_, EnqueueOrder(), true);
   task_queue->immediate_work_queue()->Push(std::move(task));
 
   WorkQueue* chosen_work_queue;
   EXPECT_CALL(mock_observer, OnTriedToSelectBlockedWorkQueue(_)).Times(1);
   EXPECT_FALSE(selector.SelectWorkQueueToService(&chosen_work_queue));
 
   voter.reset();
   selector.EnableQueue(task_queue.get());
   task_queue->UnregisterTaskQueue();
   selector.RemoveQueue(task_queue.get());
@@ skipping 13 matching lines @@
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter2 =
       task_queue2->CreateQueueEnabledVoter();
 
   voter->SetQueueEnabled(false);
   voter2->SetQueueEnabled(false);
   selector.DisableQueue(task_queue.get());
   selector.DisableQueue(task_queue2.get());
 
   selector.SetQueuePriority(task_queue2.get(), TaskQueue::CONTROL_PRIORITY);
 
-  TaskQueueImpl::Task task1(FROM_HERE, test_closure_, base::TimeTicks(), 0,
+  TaskQueueImpl::Task task1(FROM_HERE, test_closure_, EnqueueOrder(), true);
+  TaskQueueImpl::Task task2(FROM_HERE, test_closure_, {base::TimeTicks(), 1},
                             true);
-  TaskQueueImpl::Task task2(FROM_HERE, test_closure_, base::TimeTicks(), 1,
-                            true);
-  task1.set_enqueue_order(0);
-  task2.set_enqueue_order(1);
   task_queue->immediate_work_queue()->Push(std::move(task1));
   task_queue2->immediate_work_queue()->Push(std::move(task2));
 
   // Should still only see one call to OnTriedToSelectBlockedWorkQueue.
   WorkQueue* chosen_work_queue;
   EXPECT_CALL(mock_observer, OnTriedToSelectBlockedWorkQueue(_)).Times(1);
   EXPECT_FALSE(selector.SelectWorkQueueToService(&chosen_work_queue));
   testing::Mock::VerifyAndClearExpectations(&mock_observer);
 
   EXPECT_CALL(mock_observer, OnTaskQueueEnabled(_)).Times(2);
@@ skipping 28 matching lines @@
         {1, 2, 2, "delayed", true},    {1, 2, 3, "immediate", false},
         {1, 2, 4, "immediate", false}, {2, 1, 4, "immediate", false},
         {2, 1, 4, "immediate", false},
 };
 
 class ChooseOldestWithPriorityTest
     : public TaskQueueSelectorTest,
       public testing::WithParamInterface<ChooseOldestWithPriorityTestParam> {};
 
 TEST_P(ChooseOldestWithPriorityTest, RoundRobinTest) {
-  task_queues_[0]->immediate_work_queue()->Push(
-      TaskQueueImpl::Task(FROM_HERE, test_closure_, base::TimeTicks(),
-                          GetParam().immediate_task_enqueue_order, true,
-                          GetParam().immediate_task_enqueue_order));
+  task_queues_[0]->immediate_work_queue()->Push(TaskQueueImpl::Task(
+      FROM_HERE, test_closure_,
+      {base::TimeTicks(), GetParam().immediate_task_enqueue_order}, true));
 
-  task_queues_[0]->delayed_work_queue()->Push(
-      TaskQueueImpl::Task(FROM_HERE, test_closure_, base::TimeTicks(),
-                          GetParam().delayed_task_enqueue_order, true,
-                          GetParam().delayed_task_enqueue_order));
+  task_queues_[0]->delayed_work_queue()->Push(TaskQueueImpl::Task(
+      FROM_HERE, test_closure_,
+      {base::TimeTicks(), GetParam().delayed_task_enqueue_order}, true));
 
   selector_.SetImmediateStarvationCountForTest(
       GetParam().immediate_starvation_count);
 
   WorkQueue* chosen_work_queue = nullptr;
   bool chose_delayed_over_immediate = false;
   EXPECT_TRUE(enabled_selector()->ChooseOldestWithPriority(
       TaskQueue::NORMAL_PRIORITY, &chose_delayed_over_immediate,
       &chosen_work_queue));
   EXPECT_EQ(chosen_work_queue->task_queue(), task_queues_[0].get());
   EXPECT_STREQ(chosen_work_queue->GetName(),
                GetParam().expected_work_queue_name);
   EXPECT_EQ(chose_delayed_over_immediate,
             GetParam().expected_did_starve_immediate_queue);
 }
 
 INSTANTIATE_TEST_CASE_P(ChooseOldestWithPriorityTest,
                         ChooseOldestWithPriorityTest,
                         testing::ValuesIn(kChooseOldestWithPriorityTestCases));
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink