Index: third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc |
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc |
index 8befec1209593698d3eca668836756947c11d581..13c30fc3643bee4b2882cbb13b6011b2f3399311 100644 |
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc |
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc |
@@ -160,8 +160,8 @@ class TaskQueueManagerTest : public testing::Test { |
return manager_->next_delayed_do_work_.run_time(); |
} |
- EnqueueOrder GetNextSequenceNumber() const { |
- return manager_->GetNextSequenceNumber(); |
+ EnqueueOrder GetNextEnqueueOrder() const { |
+ return manager_->GetNextEnqueueOrder(base::TimeTicks()); |
} |
void MaybeScheduleImmediateWorkLocked( |
@@ -284,14 +284,14 @@ TEST_F(TaskQueueManagerTest, NowNotCalledForNestedTasks) { |
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)); |
@@ -303,7 +303,7 @@ TEST_F(TaskQueueManagerTest, SingleQueuePosting) { |
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)); |
@@ -318,7 +318,7 @@ TEST_F(TaskQueueManagerTest, MultiQueuePosting) { |
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)); |
@@ -329,7 +329,7 @@ TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) { |
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)); |
@@ -344,7 +344,7 @@ TEST_F(TaskQueueManagerTest, NonNestableTaskExecutesInExpectedOrder) { |
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)); |
@@ -369,7 +369,7 @@ TEST_F(TaskQueueManagerTest, NonNestableTaskDoesntExecuteInNestedLoop) { |
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()); |
@@ -392,7 +392,7 @@ TEST_F(TaskQueueManagerTest, HasPendingImmediateWork_ImmediateTask) { |
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); |
@@ -413,7 +413,7 @@ TEST_F(TaskQueueManagerTest, HasPendingImmediateWork_DelayedTask) { |
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); |
@@ -451,7 +451,7 @@ TEST_F(TaskQueueManagerTest, DelayedTaskExecutedInOneMessageLoopTask) { |
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)); |
@@ -481,7 +481,7 @@ TEST_F(TaskQueueManagerTest, DelayedTaskPosting_MultipleTasks_DecendingOrder) { |
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)); |
@@ -511,7 +511,7 @@ TEST_F(TaskQueueManagerTest, DelayedTaskPosting_MultipleTasks_AscendingOrder) { |
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); |
@@ -555,7 +555,7 @@ 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)); |
@@ -574,7 +574,7 @@ TEST_F(TaskQueueManagerTest, InsertAndRemoveFence) { |
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); |
@@ -588,7 +588,7 @@ TEST_F(TaskQueueManagerTest, RemovingFenceForDisabledQueueDoesNotPostDoWork) { |
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); |
@@ -602,7 +602,7 @@ TEST_F(TaskQueueManagerTest, EnablingFencedQueueDoesNotPostDoWork) { |
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); |
@@ -620,7 +620,7 @@ TEST_F(TaskQueueManagerTest, DenyRunning_BeforePosting) { |
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(); |
@@ -638,7 +638,7 @@ TEST_F(TaskQueueManagerTest, DenyRunning_AfterPosting) { |
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(); |
@@ -658,7 +658,7 @@ 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)); |
@@ -680,7 +680,7 @@ 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)); |
@@ -707,7 +707,7 @@ 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); |
@@ -719,7 +719,7 @@ TEST_F(TaskQueueManagerTest, InsertFencePreventsDelayedTasksFromRunning) { |
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); |
@@ -740,7 +740,7 @@ TEST_F(TaskQueueManagerTest, InsertFenceThenImmediatlyRemoveDoesNotBlock) { |
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)); |
@@ -752,7 +752,7 @@ 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(); |
@@ -765,7 +765,7 @@ 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)); |
@@ -808,7 +808,7 @@ TEST_F(TaskQueueManagerTest, BlockedByFence_BothTypesOfFence) { |
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, |
@@ -819,7 +819,7 @@ void ReentrantTestTask(scoped_refptr<base::SingleThreadTaskRunner> runner, |
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)); |
@@ -830,7 +830,7 @@ TEST_F(TaskQueueManagerTest, ReentrantPosting) { |
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)); |
@@ -840,14 +840,14 @@ TEST_F(TaskQueueManagerTest, NoTasksAfterShutdown) { |
} |
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( |
@@ -882,7 +882,7 @@ TEST_F(TaskQueueManagerTest, DoWorkCantPostItselfMultipleTimes) { |
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)); |
@@ -904,7 +904,7 @@ TEST_F(TaskQueueManagerTest, WorkBatching) { |
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)); |
@@ -935,7 +935,7 @@ TEST_F(TaskQueueManagerTest, TaskObserverAdding) { |
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)); |
@@ -951,7 +951,7 @@ TEST_F(TaskQueueManagerTest, TaskObserverRemoving) { |
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); |
@@ -986,7 +986,7 @@ TEST_F(TaskQueueManagerTest, QueueTaskObserverAdding) { |
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)); |
@@ -1002,7 +1002,7 @@ TEST_F(TaskQueueManagerTest, QueueTaskObserverRemoving) { |
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); |
@@ -1177,7 +1177,7 @@ TEST_F(TaskQueueManagerTest, HasPendingImmediateWork_DelayedTasks) { |
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)); |
} |
@@ -1185,7 +1185,7 @@ void ExpensiveTestTask(int value, |
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( |
@@ -1214,7 +1214,7 @@ 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)); |
@@ -1231,7 +1231,7 @@ 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)); |
@@ -1247,7 +1247,7 @@ TEST_F(TaskQueueManagerTest, |
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), |
@@ -1301,37 +1301,37 @@ class SequenceNumberCapturingTaskObserver |
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); |
} |
@@ -1350,7 +1350,7 @@ TEST_F(TaskQueueManagerTest, NewTaskQueues) { |
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)); |
@@ -1373,7 +1373,7 @@ TEST_F(TaskQueueManagerTest, UnregisterTaskQueue) { |
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)); |
@@ -1388,7 +1388,7 @@ 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), |
@@ -1412,7 +1412,7 @@ void UnregisterQueue(scoped_refptr<internal::TaskQueueImpl> queue) { |
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])); |
@@ -1553,7 +1553,7 @@ TEST_F(TaskQueueManagerTest, TimeDomainsAreIndependant) { |
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), |
@@ -1596,7 +1596,7 @@ TEST_F(TaskQueueManagerTest, TimeDomainMigration) { |
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), |
@@ -1640,7 +1640,7 @@ TEST_F(TaskQueueManagerTest, TimeDomainMigrationWithIncomingImmediateTasks) { |
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()); |
@@ -1657,7 +1657,7 @@ 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")); |
@@ -2765,7 +2765,7 @@ TEST_F(TaskQueueManagerTest, |
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 = |
@@ -2780,7 +2780,7 @@ TEST_F(TaskQueueManagerTest, CouldTaskRun_DisableAndReenable) { |
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); |
@@ -2798,7 +2798,7 @@ TEST_F(TaskQueueManagerTest, CouldTaskRun_FenceBeforeThenAfter) { |
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); |