Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(733)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc

Issue 2786083005: scheduler: Maintain a constant enqueue order for every task (Closed)
Patch Set: Update VirtualTimeTest Created 3 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc ('K') | « third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc ('k') | third_party/WebKit/Source/platform/scheduler/base/task_queue_selector.cc » ('j') | third_party/WebKit/Source/platform/scheduler/base/work_queue.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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 52fa223c956bde03cb35363958be5501015eaf05..c1115ddc6f67bc540b40a88a90594de378b8b7fa 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"));
@@ -2717,7 +2717,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 =
@@ -2732,7 +2732,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);
@@ -2750,7 +2750,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);
« third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc ('K') | « third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc ('k') | third_party/WebKit/Source/platform/scheduler/base/task_queue_selector.cc » ('j') | third_party/WebKit/Source/platform/scheduler/base/work_queue.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698