scheduler: Maintain a constant enqueue order for every task

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

 // Copyright 2014 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_manager.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 142 matching lines @@
 
   int immediate_do_work_posted_count() const {
     base::AutoLock lock(manager_->any_thread_lock_);
     return manager_->any_thread().immediate_do_work_posted_count;
   }
 
   base::TimeTicks next_delayed_do_work_time() const {
     return manager_->next_delayed_do_work_.run_time();
   }
 
-  EnqueueOrder GetNextSequenceNumber() const {
-    return manager_->GetNextSequenceNumber();
+  EnqueueOrder GetNextEnqueueOrder() const {
+    return manager_->GetNextEnqueueOrder(base::TimeTicks());
   }
 
   void MaybeScheduleImmediateWorkLocked(
       const tracked_objects::Location& from_here) {
     MoveableAutoLock lock(manager_->any_thread_lock_);
     manager_->MaybeScheduleImmediateWorkLocked(from_here, std::move(lock));
   }
 
   // Runs all immediate tasks until there is no more work to do and advances
   // time if there is a pending delayed task. |per_run_time_callback| is called
@@ skipping 102 matching lines @@
                             base::Unretained(&tasks_to_post_from_nested_loop)));
 
   base::RunLoop().RunUntilIdle();
   // We need to call Now twice, to measure the start and end of the outermost
   // task. We shouldn't call it for any of the nested tasks.
   EXPECT_EQ(2, test_count_uses_time_source->now_calls_count());
 }
 
 void NullTask() {}
 
-void TestTask(EnqueueOrder value, std::vector<EnqueueOrder>* out_result) {
+void TestTask(int value, std::vector<int>* out_result) {
   out_result->push_back(value);
 }
 
 TEST_F(TaskQueueManagerTest, SingleQueuePosting) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
 
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1, 2, 3));
 }
 
 TEST_F(TaskQueueManagerTest, MultiQueuePosting) {
   Initialize(3u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
   runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order));
   runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order));
   runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order));
 
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5, 6));
 }
 
 TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) {
   InitializeWithRealMessageLoop(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostNonNestableTask(FROM_HERE,
                                    base::Bind(&TestTask, 1, &run_order));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(TaskQueueManagerTest, NonNestableTaskExecutesInExpectedOrder) {
   InitializeWithRealMessageLoop(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order));
   runners_[0]->PostNonNestableTask(FROM_HERE,
                                    base::Bind(&TestTask, 5, &run_order));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5));
 }
 
 TEST_F(TaskQueueManagerTest, NonNestableTaskDoesntExecuteInNestedLoop) {
   InitializeWithRealMessageLoop(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 
   std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop;
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 3, &run_order), false));
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 4, &run_order), true));
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 5, &run_order), true));
 
   runners_[0]->PostTask(
       FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(),
                             base::RetainedRef(runners_[0]),
                             base::Unretained(&tasks_to_post_from_nested_loop)));
 
   base::RunLoop().RunUntilIdle();
   // Note we expect task 3 to run last because it's non-nestable.
   EXPECT_THAT(run_order, ElementsAre(1, 2, 4, 5, 3));
 }
 
 TEST_F(TaskQueueManagerTest, HasPendingImmediateWork_ImmediateTask) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   EXPECT_FALSE(runners_[0]->HasPendingImmediateWork());
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   EXPECT_TRUE(runners_[0]->HasPendingImmediateWork());
 
   // Move the task into the |immediate_work_queue|.
   EXPECT_TRUE(runners_[0]->immediate_work_queue()->Empty());
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
       runners_[0]->CreateQueueEnabledVoter();
   voter->SetQueueEnabled(false);
   test_task_runner_->RunUntilIdle();
   EXPECT_FALSE(runners_[0]->immediate_work_queue()->Empty());
   EXPECT_TRUE(runners_[0]->HasPendingImmediateWork());
 
   // Run the task, making the queue empty.
   voter->SetQueueEnabled(true);
   test_task_runner_->RunUntilIdle();
   EXPECT_FALSE(runners_[0]->HasPendingImmediateWork());
 }
 
 TEST_F(TaskQueueManagerTest, HasPendingImmediateWork_DelayedTask) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                delay);
   EXPECT_FALSE(runners_[0]->HasPendingImmediateWork());
   now_src_->Advance(delay);
   EXPECT_TRUE(runners_[0]->HasPendingImmediateWork());
 
   // Move the task into the |delayed_work_queue|.
   WakeUpReadyDelayedQueues(LazyNow(now_src_.get()));
   EXPECT_FALSE(runners_[0]->delayed_work_queue()->Empty());
   EXPECT_TRUE(runners_[0]->HasPendingImmediateWork());
 
   // Run the task, making the queue empty.
   test_task_runner_->RunUntilIdle();
   EXPECT_FALSE(runners_[0]->HasPendingImmediateWork());
 }
 
 TEST_F(TaskQueueManagerTest, DelayedTaskPosting) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                delay);
   EXPECT_EQ(delay, test_task_runner_->DelayToNextTaskTime());
   EXPECT_FALSE(runners_[0]->HasPendingImmediateWork());
   EXPECT_TRUE(run_order.empty());
 
   // The task doesn't run before the delay has completed.
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(9));
   EXPECT_TRUE(run_order.empty());
@@ skipping 17 matching lines @@
 
   size_t task_count = 0;
   test_task_runner_->RunTasksWhile(
       base::Bind(&MessageLoopTaskCounter, &task_count));
   EXPECT_EQ(1u, task_count);
 }
 
 TEST_F(TaskQueueManagerTest, DelayedTaskPosting_MultipleTasks_DecendingOrder) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                base::TimeDelta::FromMilliseconds(10));
 
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
                                base::TimeDelta::FromMilliseconds(8));
 
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order),
                                base::TimeDelta::FromMilliseconds(5));
 
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(5),
             test_task_runner_->DelayToNextTaskTime());
 
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(5));
   EXPECT_THAT(run_order, ElementsAre(3));
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(3),
             test_task_runner_->DelayToNextTaskTime());
 
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(3));
   EXPECT_THAT(run_order, ElementsAre(3, 2));
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(2),
             test_task_runner_->DelayToNextTaskTime());
 
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(2));
   EXPECT_THAT(run_order, ElementsAre(3, 2, 1));
 }
 
 TEST_F(TaskQueueManagerTest, DelayedTaskPosting_MultipleTasks_AscendingOrder) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                base::TimeDelta::FromMilliseconds(1));
 
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
                                base::TimeDelta::FromMilliseconds(5));
 
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order),
                                base::TimeDelta::FromMilliseconds(10));
 
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(1),
             test_task_runner_->DelayToNextTaskTime());
 
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1));
   EXPECT_THAT(run_order, ElementsAre(1));
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(4),
             test_task_runner_->DelayToNextTaskTime());
 
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(4));
   EXPECT_THAT(run_order, ElementsAre(1, 2));
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(5),
             test_task_runner_->DelayToNextTaskTime());
 
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(5));
   EXPECT_THAT(run_order, ElementsAre(1, 2, 3));
 }
 
 TEST_F(TaskQueueManagerTest, PostDelayedTask_SharesUnderlyingDelayedTasks) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                delay);
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
                                delay);
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order),
                                delay);
 
   EXPECT_EQ(1u, test_task_runner_->NumPendingTasks());
 }
@@ skipping 23 matching lines @@
 
   manager_.reset();
 
   EXPECT_EQ(2, TestObject::destructor_count__);
 }
 
 TEST_F(TaskQueueManagerTest, InsertAndRemoveFence) {
   Initialize(1u);
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   // Posting a task when pumping is disabled doesn't result in work getting
   // posted.
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   EXPECT_FALSE(test_task_runner_->HasPendingTasks());
 
   // However polling still works.
   EXPECT_TRUE(runners_[0]->HasPendingImmediateWork());
 
   // After removing the fence the task runs normally.
   runners_[0]->RemoveFence();
   EXPECT_TRUE(test_task_runner_->HasPendingTasks());
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(TaskQueueManagerTest, RemovingFenceForDisabledQueueDoesNotPostDoWork) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
       runners_[0]->CreateQueueEnabledVoter();
   voter->SetQueueEnabled(false);
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 
   runners_[0]->RemoveFence();
   EXPECT_FALSE(test_task_runner_->HasPendingTasks());
 }
 
 TEST_F(TaskQueueManagerTest, EnablingFencedQueueDoesNotPostDoWork) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
       runners_[0]->CreateQueueEnabledVoter();
   voter->SetQueueEnabled(false);
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 
   voter->SetQueueEnabled(true);
   EXPECT_FALSE(test_task_runner_->HasPendingTasks());
 }
 
 TEST_F(TaskQueueManagerTest, DenyRunning_BeforePosting) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
       runners_[0]->CreateQueueEnabledVoter();
   voter->SetQueueEnabled(false);
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   EXPECT_FALSE(test_task_runner_->HasPendingTasks());
 
   test_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
   voter->SetQueueEnabled(true);
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(TaskQueueManagerTest, DenyRunning_AfterPosting) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
       runners_[0]->CreateQueueEnabledVoter();
   EXPECT_TRUE(test_task_runner_->HasPendingTasks());
   voter->SetQueueEnabled(false);
 
   test_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
   voter->SetQueueEnabled(true);
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(TaskQueueManagerTest, DenyRunning_AfterRemovingFence) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
       runners_[0]->CreateQueueEnabledVoter();
   voter->SetQueueEnabled(false);
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 
   test_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
   runners_[0]->RemoveFence();
   voter->SetQueueEnabled(true);
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(TaskQueueManagerTest, RemovingFenceWithDelayedTask) {
   Initialize(1u);
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   // Posting a delayed task when fenced will apply the delay, but won't cause
   // work to executed afterwards.
   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                delay);
 
   // The task does not run even though it's delay is up.
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(10));
   EXPECT_TRUE(run_order.empty());
 
   // Removing the fence causes the task to run.
   runners_[0]->RemoveFence();
   EXPECT_TRUE(test_task_runner_->HasPendingTasks());
   test_task_runner_->RunPendingTasks();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(TaskQueueManagerTest, RemovingFenceWithMultipleDelayedTasks) {
   Initialize(1u);
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   // Posting a delayed task when fenced will apply the delay, but won't cause
   // work to executed afterwards.
   base::TimeDelta delay1(base::TimeDelta::FromMilliseconds(1));
   base::TimeDelta delay2(base::TimeDelta::FromMilliseconds(10));
   base::TimeDelta delay3(base::TimeDelta::FromMilliseconds(20));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                delay1);
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
                                delay2);
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order),
                                delay3);
 
   now_src_->Advance(base::TimeDelta::FromMilliseconds(15));
   test_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
   // Removing the fence causes the ready tasks to run.
   runners_[0]->RemoveFence();
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1, 2));
 }
 
 TEST_F(TaskQueueManagerTest, InsertFencePreventsDelayedTasksFromRunning) {
   Initialize(1u);
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                delay);
 
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(10));
   EXPECT_TRUE(run_order.empty());
 }
 
 TEST_F(TaskQueueManagerTest, MultipleFences) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
 
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1, 2));
 
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
   // Subsequent tasks should be blocked.
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order));
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1, 2, 3));
 }
 
 TEST_F(TaskQueueManagerTest, InsertFenceThenImmediatlyRemoveDoesNotBlock) {
   Initialize(1u);
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
   runners_[0]->RemoveFence();
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1, 2));
 }
 
 TEST_F(TaskQueueManagerTest, InsertFencePostThenRemoveDoesNotBlock) {
   Initialize(1u);
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   runners_[0]->RemoveFence();
 
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1, 2));
 }
 
 TEST_F(TaskQueueManagerTest, MultipleFencesWithInitiallyEmptyQueue) {
   Initialize(1u);
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(TaskQueueManagerTest, BlockedByFence) {
   Initialize(1u);
   EXPECT_FALSE(runners_[0]->BlockedByFence());
@@ skipping 22 matching lines @@
 
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
   EXPECT_FALSE(runners_[0]->BlockedByFence());
 
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
   EXPECT_TRUE(runners_[0]->BlockedByFence());
 }
 
 void ReentrantTestTask(scoped_refptr<base::SingleThreadTaskRunner> runner,
                        int countdown,
-                       std::vector<EnqueueOrder>* out_result) {
+                       std::vector<int>* out_result) {
   out_result->push_back(countdown);
   if (--countdown) {
     runner->PostTask(FROM_HERE,
                      Bind(&ReentrantTestTask, runner, countdown, out_result));
   }
 }
 
 TEST_F(TaskQueueManagerTest, ReentrantPosting) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE,
                         Bind(&ReentrantTestTask, runners_[0], 3, &run_order));
 
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(3, 2, 1));
 }
 
 TEST_F(TaskQueueManagerTest, NoTasksAfterShutdown) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   manager_.reset();
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 
   test_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 }
 
 void PostTaskToRunner(scoped_refptr<base::SingleThreadTaskRunner> runner,
-                      std::vector<EnqueueOrder>* run_order) {
+                      std::vector<int>* run_order) {
   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, run_order));
 }
 
 TEST_F(TaskQueueManagerTest, PostFromThread) {
   InitializeWithRealMessageLoop(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   base::Thread thread("TestThread");
   thread.Start();
   thread.task_runner()->PostTask(
       FROM_HERE, base::Bind(&PostTaskToRunner, runners_[0], &run_order));
   thread.Stop();
 
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
@@ skipping 14 matching lines @@
   test_task_runner_->RunPendingTasks();
   // NOTE without the executing_task_ check in MaybeScheduleDoWork there
   // will be two tasks here.
   EXPECT_EQ(1u, test_task_runner_->NumPendingTasks());
   EXPECT_EQ(1, run_count);
 }
 
 TEST_F(TaskQueueManagerTest, PostFromNestedRunloop) {
   InitializeWithRealMessageLoop(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop;
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 1, &run_order), true));
 
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 0, &run_order));
   runners_[0]->PostTask(
       FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(),
                             base::RetainedRef(runners_[0]),
                             base::Unretained(&tasks_to_post_from_nested_loop)));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(run_order, ElementsAre(0, 2, 1));
 }
 
 TEST_F(TaskQueueManagerTest, WorkBatching) {
   Initialize(1u);
 
   manager_->SetWorkBatchSize(2);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order));
 
   // Running one task in the host message loop should cause two posted tasks to
   // get executed.
   EXPECT_EQ(test_task_runner_->NumPendingTasks(), 1u);
   test_task_runner_->RunPendingTasks();
   EXPECT_THAT(run_order, ElementsAre(1, 2));
@@ skipping 10 matching lines @@
   MOCK_METHOD1(WillProcessTask, void(const base::PendingTask& task));
 };
 
 TEST_F(TaskQueueManagerTest, TaskObserverAdding) {
   InitializeWithRealMessageLoop(1u);
   MockTaskObserver observer;
 
   manager_->SetWorkBatchSize(2);
   manager_->AddTaskObserver(&observer);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 
   EXPECT_CALL(observer, WillProcessTask(_)).Times(2);
   EXPECT_CALL(observer, DidProcessTask(_)).Times(2);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(TaskQueueManagerTest, TaskObserverRemoving) {
   InitializeWithRealMessageLoop(1u);
   MockTaskObserver observer;
   manager_->SetWorkBatchSize(2);
   manager_->AddTaskObserver(&observer);
   manager_->RemoveTaskObserver(&observer);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 
   EXPECT_CALL(observer, WillProcessTask(_)).Times(0);
   EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
 
   base::RunLoop().RunUntilIdle();
 }
 
 void RemoveObserverTask(TaskQueueManager* manager,
                         base::MessageLoop::TaskObserver* observer) {
@@ skipping 14 matching lines @@
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(TaskQueueManagerTest, QueueTaskObserverAdding) {
   InitializeWithRealMessageLoop(2u);
   MockTaskObserver observer;
 
   manager_->SetWorkBatchSize(2);
   runners_[0]->AddTaskObserver(&observer);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 
   EXPECT_CALL(observer, WillProcessTask(_)).Times(1);
   EXPECT_CALL(observer, DidProcessTask(_)).Times(1);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(TaskQueueManagerTest, QueueTaskObserverRemoving) {
   InitializeWithRealMessageLoop(1u);
   MockTaskObserver observer;
   manager_->SetWorkBatchSize(2);
   runners_[0]->AddTaskObserver(&observer);
   runners_[0]->RemoveTaskObserver(&observer);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 
   EXPECT_CALL(observer, WillProcessTask(_)).Times(0);
   EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
 
   base::RunLoop().RunUntilIdle();
 }
 
 void RemoveQueueObserverTask(scoped_refptr<TaskQueue> queue,
                              base::MessageLoop::TaskObserver* observer) {
@@ skipping 154 matching lines @@
   now_src_->Advance(base::TimeDelta::FromMilliseconds(2));
   WakeUpReadyDelayedQueues(LazyNow(now_src_.get()));
   EXPECT_TRUE(runners_[0]->HasPendingImmediateWork());
 
   test_task_runner_->RunUntilIdle();
   EXPECT_FALSE(runners_[0]->HasPendingImmediateWork());
 }
 
 void ExpensiveTestTask(int value,
                        base::SimpleTestTickClock* clock,
-                       std::vector<EnqueueOrder>* out_result) {
+                       std::vector<int>* out_result) {
   out_result->push_back(value);
   clock->Advance(base::TimeDelta::FromMilliseconds(1));
 }
 
 TEST_F(TaskQueueManagerTest, ImmediateAndDelayedTaskInterleaving) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10);
   for (int i = 10; i < 19; i++) {
     runners_[0]->PostDelayedTask(
         FROM_HERE,
         base::Bind(&ExpensiveTestTask, i, now_src_.get(), &run_order), delay);
   }
 
   test_task_runner_->RunForPeriod(delay);
 
   for (int i = 0; i < 9; i++) {
     runners_[0]->PostTask(FROM_HERE, base::Bind(&ExpensiveTestTask, i,
                                                 now_src_.get(), &run_order));
   }
 
   test_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
   test_task_runner_->RunUntilIdle();
 
   // Delayed tasks are not allowed to starve out immediate work which is why
   // some of the immediate tasks run out of order.
   int expected_run_order[] = {10, 11, 12, 13, 0, 14, 15, 16, 1,
                               17, 18, 2,  3,  4, 5,  6,  7,  8};
   EXPECT_THAT(run_order, ElementsAreArray(expected_run_order));
 }
 
 TEST_F(TaskQueueManagerTest,
        DelayedTaskDoesNotSkipAHeadOfNonDelayedTask_SameQueue) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10);
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                delay);
 
   now_src_->Advance(delay * 2);
   test_task_runner_->RunUntilIdle();
 
   EXPECT_THAT(run_order, ElementsAre(2, 3, 1));
 }
 
 TEST_F(TaskQueueManagerTest,
        DelayedTaskDoesNotSkipAHeadOfNonDelayedTask_DifferentQueues) {
   Initialize(2u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10);
   runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                delay);
 
   now_src_->Advance(delay * 2);
   test_task_runner_->RunUntilIdle();
 
   EXPECT_THAT(run_order, ElementsAre(2, 3, 1));
 }
 
 TEST_F(TaskQueueManagerTest, DelayedTaskDoesNotSkipAHeadOfShorterDelayedTask) {
   Initialize(2u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(10);
   base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5);
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                delay1);
   runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
                                delay2);
 
   now_src_->Advance(delay1 * 2);
   test_task_runner_->RunUntilIdle();
 
@@ skipping 33 matching lines @@
 
 class SequenceNumberCapturingTaskObserver
     : public base::MessageLoop::TaskObserver {
  public:
   // MessageLoop::TaskObserver overrides.
   void WillProcessTask(const base::PendingTask& pending_task) override {}
   void DidProcessTask(const base::PendingTask& pending_task) override {
     sequence_numbers_.push_back(pending_task.sequence_num);
   }
 
-  const std::vector<EnqueueOrder>& sequence_numbers() const {
-    return sequence_numbers_;
-  }
+  const std::vector<int>& sequence_numbers() const { return sequence_numbers_; }
 
  private:
-  std::vector<EnqueueOrder> sequence_numbers_;
+  std::vector<int> sequence_numbers_;
 };
 
-TEST_F(TaskQueueManagerTest, SequenceNumSetWhenTaskIsPosted) {
+TEST_F(TaskQueueManagerTest, DelayedTasksRunInOrder) {
   Initialize(1u);
 
   SequenceNumberCapturingTaskObserver observer;
   manager_->AddTaskObserver(&observer);
 
-  // Register four tasks that will run in reverse order.
-  std::vector<EnqueueOrder> run_order;
+  // Register four tasks that will run in reverse order. Note that since we
+  // don't strict guarantees about the relative ordering of immediate and
+  // delayed tasks, in this scenario the immediate task runs last.
+  std::vector<int> run_order;
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                base::TimeDelta::FromMilliseconds(30));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
                                base::TimeDelta::FromMilliseconds(20));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order),
                                base::TimeDelta::FromMilliseconds(10));
-  runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order));
+  runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 0, &run_order));
 
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(40));
-  ASSERT_THAT(run_order, ElementsAre(4, 3, 2, 1));
+  ASSERT_THAT(run_order, ElementsAre(3, 2, 1, 0));
 
-  // The sequence numbers are a one-based monotonically incrememting counter
+  // The sequence numbers are a one-based monotonically incrementing counter
   // which should be set when the task is posted rather than when it's enqueued
   // onto the Incoming queue. This counter starts with 2.
-  EXPECT_THAT(observer.sequence_numbers(), ElementsAre(5, 4, 3, 2));
+  EXPECT_THAT(observer.sequence_numbers(), ElementsAre(4, 3, 2, 5));
 
   manager_->RemoveTaskObserver(&observer);
 }
 
 TEST_F(TaskQueueManagerTest, NewTaskQueues) {
   Initialize(1u);
 
   scoped_refptr<internal::TaskQueueImpl> queue1 =
       manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST));
   scoped_refptr<internal::TaskQueueImpl> queue2 =
       manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST));
   scoped_refptr<internal::TaskQueueImpl> queue3 =
       manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST));
 
   ASSERT_NE(queue1, queue2);
   ASSERT_NE(queue1, queue3);
   ASSERT_NE(queue2, queue3);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   queue1->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   queue2->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   queue3->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
   test_task_runner_->RunUntilIdle();
 
   EXPECT_THAT(run_order, ElementsAre(1, 2, 3));
 }
 
 TEST_F(TaskQueueManagerTest, UnregisterTaskQueue) {
   Initialize(1u);
 
   scoped_refptr<internal::TaskQueueImpl> queue1 =
       manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST));
   scoped_refptr<internal::TaskQueueImpl> queue2 =
       manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST));
   scoped_refptr<internal::TaskQueueImpl> queue3 =
       manager_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::TEST));
 
   ASSERT_NE(queue1, queue2);
   ASSERT_NE(queue1, queue3);
   ASSERT_NE(queue2, queue3);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   queue1->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   queue2->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   queue3->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
 
   queue2->UnregisterTaskQueue();
   test_task_runner_->RunUntilIdle();
 
   EXPECT_THAT(run_order, ElementsAre(1, 3));
 }
 
 TEST_F(TaskQueueManagerTest, UnregisterTaskQueue_WithDelayedTasks) {
   Initialize(2u);
 
   // Register three delayed tasks
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                base::TimeDelta::FromMilliseconds(10));
   runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
                                base::TimeDelta::FromMilliseconds(20));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order),
                                base::TimeDelta::FromMilliseconds(30));
 
   runners_[1]->UnregisterTaskQueue();
   test_task_runner_->RunUntilIdle();
 
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(40));
   ASSERT_THAT(run_order, ElementsAre(1, 3));
 }
 
 namespace {
 void UnregisterQueue(scoped_refptr<internal::TaskQueueImpl> queue) {
   queue->UnregisterTaskQueue();
 }
 }
 
 TEST_F(TaskQueueManagerTest, UnregisterTaskQueue_InTasks) {
   Initialize(3u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&UnregisterQueue, runners_[1]));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&UnregisterQueue, runners_[2]));
   runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
 
   test_task_runner_->RunUntilIdle();
   ASSERT_THAT(run_order, ElementsAre(1));
 }
 
@@ skipping 120 matching lines @@
   base::TimeTicks start_time = manager_->Delegate()->NowTicks();
   std::unique_ptr<VirtualTimeDomain> domain_a(
       new VirtualTimeDomain(start_time));
   std::unique_ptr<VirtualTimeDomain> domain_b(
       new VirtualTimeDomain(start_time));
   manager_->RegisterTimeDomain(domain_a.get());
   manager_->RegisterTimeDomain(domain_b.get());
   runners_[0]->SetTimeDomain(domain_a.get());
   runners_[1]->SetTimeDomain(domain_b.get());
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                base::TimeDelta::FromMilliseconds(10));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
                                base::TimeDelta::FromMilliseconds(20));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order),
                                base::TimeDelta::FromMilliseconds(30));
 
   runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order),
                                base::TimeDelta::FromMilliseconds(10));
   runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order),
@@ skipping 22 matching lines @@
 
 TEST_F(TaskQueueManagerTest, TimeDomainMigration) {
   Initialize(1u);
 
   base::TimeTicks start_time = manager_->Delegate()->NowTicks();
   std::unique_ptr<VirtualTimeDomain> domain_a(
       new VirtualTimeDomain(start_time));
   manager_->RegisterTimeDomain(domain_a.get());
   runners_[0]->SetTimeDomain(domain_a.get());
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                base::TimeDelta::FromMilliseconds(10));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
                                base::TimeDelta::FromMilliseconds(20));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order),
                                base::TimeDelta::FromMilliseconds(30));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order),
                                base::TimeDelta::FromMilliseconds(40));
 
   domain_a->AdvanceTo(start_time + base::TimeDelta::FromMilliseconds(20));
@@ skipping 23 matching lines @@
 
   base::TimeTicks start_time = manager_->Delegate()->NowTicks();
   std::unique_ptr<VirtualTimeDomain> domain_a(
       new VirtualTimeDomain(start_time));
   std::unique_ptr<VirtualTimeDomain> domain_b(
       new VirtualTimeDomain(start_time));
   manager_->RegisterTimeDomain(domain_a.get());
   manager_->RegisterTimeDomain(domain_b.get());
 
   runners_[0]->SetTimeDomain(domain_a.get());
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[0]->SetTimeDomain(domain_b.get());
 
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 
   runners_[0]->UnregisterTaskQueue();
 
   manager_->UnregisterTimeDomain(domain_a.get());
   manager_->UnregisterTimeDomain(domain_b.get());
 }
 
 TEST_F(TaskQueueManagerTest,
        PostDelayedTasksReverseOrderAlternatingTimeDomains) {
   Initialize(1u);
 
-  std::vector<EnqueueOrder> run_order;
+  std::vector<int> run_order;
 
   std::unique_ptr<RealTimeDomain> domain_a(new RealTimeDomain("test"));
   std::unique_ptr<RealTimeDomain> domain_b(new RealTimeDomain("test"));
   manager_->RegisterTimeDomain(domain_a.get());
   manager_->RegisterTimeDomain(domain_b.get());
 
   runners_[0]->SetTimeDomain(domain_a.get());
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                base::TimeDelta::FromMilliseconds(40));
 
@@ skipping 1087 matching lines @@
                  run_loop.QuitClosure(), base::RetainedRef(runners_[0])),
       base::TimeDelta::FromMilliseconds(100));
 
   now_src_->Advance(base::TimeDelta::FromMilliseconds(200));
   run_loop.Run();
 }
 
 TEST_F(TaskQueueManagerTest, CouldTaskRun_DisableAndReenable) {
   Initialize(1u);
 
-  EnqueueOrder enqueue_order = GetNextSequenceNumber();
+  EnqueueOrder enqueue_order = GetNextEnqueueOrder();
   EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order));
 
   std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
       runners_[0]->CreateQueueEnabledVoter();
   voter->SetQueueEnabled(false);
   EXPECT_FALSE(runners_[0]->CouldTaskRun(enqueue_order));
 
   voter->SetQueueEnabled(true);
   EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order));
 }
 
 TEST_F(TaskQueueManagerTest, CouldTaskRun_Fence) {
   Initialize(1u);
 
-  EnqueueOrder enqueue_order = GetNextSequenceNumber();
+  EnqueueOrder enqueue_order = GetNextEnqueueOrder();
   EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order));
 
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
   EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order));
 
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
   EXPECT_FALSE(runners_[0]->CouldTaskRun(enqueue_order));
 
   runners_[0]->RemoveFence();
   EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order));
 }
 
 TEST_F(TaskQueueManagerTest, CouldTaskRun_FenceBeforeThenAfter) {
   Initialize(1u);
 
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
 
-  EnqueueOrder enqueue_order = GetNextSequenceNumber();
+  EnqueueOrder enqueue_order = GetNextEnqueueOrder();
   EXPECT_FALSE(runners_[0]->CouldTaskRun(enqueue_order));
 
   runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
   EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order));
 }
 
 TEST_F(TaskQueueManagerTest, DelayedDoWorkNotPostedForDisabledQueue) {
   Initialize(1u);
 
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
@@ skipping 107 matching lines @@
   manager_->RegisterTimeDomain(domain.get());
   runners_[0]->SetTimeDomain(domain.get());
 
   // Tidy up.
   runners_[0]->UnregisterTaskQueue();
   manager_->UnregisterTimeDomain(domain.get());
 }
 
 }  // namespace scheduler
 }  // namespace blink