Reland: Explicitly track the scheduler task enqueueing order in a new field

components/scheduler/child/task_queue_selector_unittest.cc

Index: components/scheduler/child/task_queue_selector_unittest.cc
diff --git a/components/scheduler/child/task_queue_selector_unittest.cc b/components/scheduler/child/task_queue_selector_unittest.cc
index afd90d6731d367d42e1582fe3e910619e5559f3a..6832d7abcb89989d3c75c6d47e0dfadd8ef0683d 100644
--- a/components/scheduler/child/task_queue_selector_unittest.cc
+++ b/components/scheduler/child/task_queue_selector_unittest.cc
@@ -33,17 +33,17 @@ class TaskQueueSelectorTest : public testing::Test {
       : test_closure_(base::Bind(&TaskQueueSelectorTest::TestFunction)) {}
   ~TaskQueueSelectorTest() override {}
 
-  std::vector<base::PendingTask> GetTasks(int count) {
-    std::vector<base::PendingTask> tasks;
+  std::vector<internal::SchedulerTask> GetTasks(int count) {
+    std::vector<internal::SchedulerTask> tasks;
     for (int i = 0; i < count; i++) {
-      base::PendingTask task = base::PendingTask(FROM_HERE, test_closure_);
-      task.sequence_num = i;
+      SchedulerTask task(FROM_HERE, test_closure_, true);
+      task.age = i;
       tasks.push_back(task);
     }
     return tasks;
   }
 
-  void PushTasks(const std::vector<base::PendingTask>& tasks,
+  void PushTasks(const std::vector<SchedulerTask>& tasks,
                  const size_t queue_indices[]) {
     std::set<size_t> changed_queue_set;
     for (size_t i = 0; i < tasks.size(); i++) {
@@ -94,14 +94,14 @@ class TaskQueueSelectorTest : public testing::Test {
 };
 
 TEST_F(TaskQueueSelectorTest, TestDefaultPriority) {
-  std::vector<base::PendingTask> tasks = GetTasks(5);
+  std::vector<SchedulerTask> tasks = GetTasks(5);
   size_t queue_order[] = {4, 3, 2, 1, 0};
   PushTasks(tasks, queue_order);
   EXPECT_THAT(PopTasks(), testing::ElementsAre(4, 3, 2, 1, 0));
 }
 
 TEST_F(TaskQueueSelectorTest, TestHighPriority) {
-  std::vector<base::PendingTask> tasks = GetTasks(5);
+  std::vector<SchedulerTask> tasks = GetTasks(5);
   size_t queue_order[] = {0, 1, 2, 3, 4};
   PushTasks(tasks, queue_order);
   selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::HIGH_PRIORITY);
@@ -109,7 +109,7 @@ TEST_F(TaskQueueSelectorTest, TestHighPriority) {
 }
 
 TEST_F(TaskQueueSelectorTest, TestBestEffortPriority) {
-  std::vector<base::PendingTask> tasks = GetTasks(5);
+  std::vector<SchedulerTask> tasks = GetTasks(5);
   size_t queue_order[] = {0, 1, 2, 3, 4};
   PushTasks(tasks, queue_order);
   selector_.SetQueuePriority(task_queues_[0].get(),
@@ -119,7 +119,7 @@ TEST_F(TaskQueueSelectorTest, TestBestEffortPriority) {
 }
 
 TEST_F(TaskQueueSelectorTest, TestControlPriority) {
-  std::vector<base::PendingTask> tasks = GetTasks(5);
+  std::vector<SchedulerTask> tasks = GetTasks(5);
   size_t queue_order[] = {0, 1, 2, 3, 4};
   PushTasks(tasks, queue_order);
   selector_.SetQueuePriority(task_queues_[4].get(),
@@ -152,7 +152,7 @@ TEST_F(TaskQueueSelectorTest, TestDisableEnable) {
   MockObserver mock_observer;
   selector_.SetTaskQueueSelectorObserver(&mock_observer);
 
-  std::vector<base::PendingTask> tasks = GetTasks(5);
+  std::vector<SchedulerTask> tasks = GetTasks(5);
   size_t queue_order[] = {0, 1, 2, 3, 4};
   PushTasks(tasks, queue_order);
   selector_.SetQueuePriority(task_queues_[2].get(),
@@ -176,7 +176,7 @@ TEST_F(TaskQueueSelectorTest, TestEmptyQueues) {
   EXPECT_FALSE(selector_.SelectQueueToService(&chosen_queue));
 
   // Test only disabled queues.
-  std::vector<base::PendingTask> tasks = GetTasks(1);
+  std::vector<SchedulerTask> tasks = GetTasks(1);
   size_t queue_order[] = {0};
   PushTasks(tasks, queue_order);
   selector_.SetQueuePriority(task_queues_[0].get(),
@@ -185,17 +185,17 @@ TEST_F(TaskQueueSelectorTest, TestEmptyQueues) {
   EXPECT_FALSE(selector_.SelectQueueToService(&chosen_queue));
 }
 
-TEST_F(TaskQueueSelectorTest, TestSequenceNumber) {
-  std::vector<base::PendingTask> tasks = GetTasks(5);
-  tasks[0].sequence_num = 10;
-  tasks[3].sequence_num = 9;
+TEST_F(TaskQueueSelectorTest, TestAge) {
+  std::vector<SchedulerTask> tasks = GetTasks(5);
+  tasks[0].age = 10;
+  tasks[3].age = 9;
   size_t queue_order[] = {0, 1, 2, 3, 4};
   PushTasks(tasks, queue_order);
   EXPECT_THAT(PopTasks(), testing::ElementsAre(1, 2, 4, 3, 0));
 }
 
 TEST_F(TaskQueueSelectorTest, TestControlStarvesOthers) {
-  std::vector<base::PendingTask> tasks = GetTasks(4);
+  std::vector<SchedulerTask> tasks = GetTasks(4);
   size_t queue_order[] = {0, 1, 2, 3};
   PushTasks(tasks, queue_order);
   selector_.SetQueuePriority(task_queues_[3].get(),
@@ -212,7 +212,7 @@ TEST_F(TaskQueueSelectorTest, TestControlStarvesOthers) {
 }
 
 TEST_F(TaskQueueSelectorTest, TestHighPriorityDoesNotStarveNormal) {
-  std::vector<base::PendingTask> tasks = GetTasks(3);
+  std::vector<SchedulerTask> tasks = GetTasks(3);
   size_t queue_order[] = {0, 1, 2};
   PushTasks(tasks, queue_order);
   selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::HIGH_PRIORITY);
@@ -232,7 +232,7 @@ TEST_F(TaskQueueSelectorTest, TestHighPriorityDoesNotStarveNormal) {
 }
 
 TEST_F(TaskQueueSelectorTest, TestBestEffortGetsStarved) {
-  std::vector<base::PendingTask> tasks = GetTasks(2);
+  std::vector<SchedulerTask> tasks = GetTasks(2);
   size_t queue_order[] = {0, 1};
   PushTasks(tasks, queue_order);
   selector_.SetQueuePriority(task_queues_[0].get(),