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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 2572893002: [Reland] Dont post delayed DoWork for disabled queues. (Closed)
Patch Set: Keep track of which TimeDomain the delayed do works are associated with. Created 3 years, 11 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_manager.cc ('K') | « third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_perftest.cc ('k') | third_party/WebKit/Source/platform/scheduler/base/time_domain.h » ('j') | no next file with comments »
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 fc290a3c42e06a279c3382b291972f903b04caba..4449d8d7a7d042a86db7b44b9e82fd78f54945f9 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
@@ -120,13 +120,15 @@ class TaskQueueManagerTest : public testing::Test {
manager_->WakeupReadyDelayedQueues(&lazy_now);
}
- base::Optional<base::TimeDelta> ComputeDelayTillNextTask(LazyNow* lazy_now) {
+ base::Optional<TaskQueueManager::NextTaskDelay> ComputeDelayTillNextTask(
+ LazyNow* lazy_now) {
base::AutoLock lock(manager_->any_thread_lock_);
return manager_->ComputeDelayTillNextTaskLocked(lazy_now);
}
- void PostDoWorkContinuation(base::Optional<base::TimeDelta> next_delay,
- LazyNow* lazy_now) {
+ void PostDoWorkContinuation(
+ base::Optional<TaskQueueManager::NextTaskDelay> next_delay,
+ LazyNow* lazy_now) {
MoveableAutoLock lock(manager_->any_thread_lock_);
return manager_->PostDoWorkContinuationLocked(next_delay, lazy_now,
std::move(lock));
@@ -137,8 +139,8 @@ class TaskQueueManagerTest : public testing::Test {
return manager_->any_thread().immediate_do_work_posted_count;
}
- base::TimeTicks next_scheduled_delayed_do_work_time() const {
- return manager_->next_scheduled_delayed_do_work_time_;
+ base::TimeTicks next_delayed_do_work_time() const {
+ return manager_->next_delayed_do_work_.run_time();
}
EnqueueOrder GetNextSequenceNumber() const {
@@ -382,16 +384,11 @@ TEST_F(TaskQueueManagerTest, HasPendingImmediateWork_DelayedTask) {
EXPECT_TRUE(runners_[0]->HasPendingImmediateWork());
// Move the task into the |delayed_work_queue|.
- EXPECT_TRUE(runners_[0]->delayed_work_queue()->Empty());
- std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
- runners_[0]->CreateQueueEnabledVoter();
- voter->SetQueueEnabled(false);
- test_task_runner_->RunUntilIdle();
+ 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.
- voter->SetQueueEnabled(true);
test_task_runner_->RunUntilIdle();
EXPECT_FALSE(runners_[0]->HasPendingImmediateWork());
}
@@ -2332,23 +2329,23 @@ TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask) {
base::TimeDelta::FromSeconds(10));
EXPECT_EQ(base::TimeDelta::FromSeconds(10),
- ComputeDelayTillNextTask(&lazy_now).value());
+ ComputeDelayTillNextTask(&lazy_now)->delay());
runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
base::TimeDelta::FromSeconds(15));
EXPECT_EQ(base::TimeDelta::FromSeconds(10),
- ComputeDelayTillNextTask(&lazy_now).value());
+ ComputeDelayTillNextTask(&lazy_now)->delay());
runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
base::TimeDelta::FromSeconds(5));
EXPECT_EQ(base::TimeDelta::FromSeconds(5),
- ComputeDelayTillNextTask(&lazy_now).value());
+ ComputeDelayTillNextTask(&lazy_now)->delay());
runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
- EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now).value());
+ EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->delay());
// Tidy up.
runners_[1]->UnregisterTaskQueue();
@@ -2385,7 +2382,7 @@ TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_FenceUnblocking) {
runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
LazyNow lazy_now(now_src_.get());
- EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now).value());
+ EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->delay());
}
TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_DelayedTaskReady) {
@@ -2397,44 +2394,48 @@ TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_DelayedTaskReady) {
now_src_->Advance(base::TimeDelta::FromSeconds(10));
LazyNow lazy_now(now_src_.get());
- EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now).value());
+ EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->delay());
}
TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_NoMoreWork) {
Initialize(1u);
LazyNow lazy_now(now_src_.get());
- PostDoWorkContinuation(base::Optional<base::TimeDelta>(), &lazy_now);
+ PostDoWorkContinuation(base::Optional<TaskQueueManager::NextTaskDelay>(),
+ &lazy_now);
EXPECT_EQ(0u, test_task_runner_->NumPendingTasks());
EXPECT_EQ(0, immediate_do_work_posted_count());
- EXPECT_TRUE(next_scheduled_delayed_do_work_time().is_null());
+ EXPECT_TRUE(next_delayed_do_work_time().is_null());
}
TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_ImmediateWork) {
Initialize(1u);
LazyNow lazy_now(now_src_.get());
- PostDoWorkContinuation(base::TimeDelta(), &lazy_now);
+ PostDoWorkContinuation(TaskQueueManager::NextTaskDelay(), &lazy_now);
EXPECT_EQ(1u, test_task_runner_->NumPendingTasks());
EXPECT_EQ(base::TimeDelta(), test_task_runner_->DelayToNextTaskTime());
EXPECT_EQ(1, immediate_do_work_posted_count());
- EXPECT_TRUE(next_scheduled_delayed_do_work_time().is_null());
+ EXPECT_TRUE(next_delayed_do_work_time().is_null());
}
TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_DelayedWork) {
Initialize(1u);
LazyNow lazy_now(now_src_.get());
- PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &lazy_now);
+ PostDoWorkContinuation(
+ TaskQueueManager::NextTaskDelay(base::TimeDelta::FromSeconds(1),
+ runners_[0]->GetTimeDomain()),
+ &lazy_now);
EXPECT_EQ(1u, test_task_runner_->NumPendingTasks());
EXPECT_EQ(base::TimeDelta::FromSeconds(1),
test_task_runner_->DelayToNextTaskTime());
EXPECT_EQ(0, immediate_do_work_posted_count());
EXPECT_EQ(lazy_now.Now() + base::TimeDelta::FromSeconds(1),
- next_scheduled_delayed_do_work_time());
+ next_delayed_do_work_time());
}
TEST_F(TaskQueueManagerTest,
@@ -2447,29 +2448,38 @@ TEST_F(TaskQueueManagerTest,
EXPECT_EQ(1, immediate_do_work_posted_count());
LazyNow lazy_now(now_src_.get());
- PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &lazy_now);
+ PostDoWorkContinuation(
+ TaskQueueManager::NextTaskDelay(base::TimeDelta::FromSeconds(1),
+ runners_[0]->GetTimeDomain()),
+ &lazy_now);
// Test that a delayed task didn't get posted.
EXPECT_EQ(1u, test_task_runner_->NumPendingTasks());
EXPECT_EQ(base::TimeDelta(), test_task_runner_->DelayToNextTaskTime());
EXPECT_EQ(1, immediate_do_work_posted_count());
- EXPECT_TRUE(next_scheduled_delayed_do_work_time().is_null());
+ EXPECT_TRUE(next_delayed_do_work_time().is_null());
}
TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_DelayedWorkTimeChanges) {
Initialize(1u);
LazyNow lazy_now(now_src_.get());
- PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &lazy_now);
+ PostDoWorkContinuation(
+ TaskQueueManager::NextTaskDelay(base::TimeDelta::FromSeconds(1),
+ runners_[0]->GetTimeDomain()),
+ &lazy_now);
EXPECT_TRUE(test_task_runner_->HasPendingTasks());
EXPECT_EQ(0, immediate_do_work_posted_count());
EXPECT_EQ(base::TimeDelta::FromSeconds(1),
test_task_runner_->DelayToNextTaskTime());
EXPECT_EQ(lazy_now.Now() + base::TimeDelta::FromSeconds(1),
- next_scheduled_delayed_do_work_time());
+ next_delayed_do_work_time());
- PostDoWorkContinuation(base::TimeDelta::FromSeconds(10), &lazy_now);
+ PostDoWorkContinuation(
+ TaskQueueManager::NextTaskDelay(base::TimeDelta::FromSeconds(10),
+ runners_[0]->GetTimeDomain()),
+ &lazy_now);
// This should have resulted in the previous task getting canceled and a new
// one getting posted.
@@ -2480,7 +2490,7 @@ TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_DelayedWorkTimeChanges) {
test_task_runner_->DelayToNextTaskTime());
EXPECT_EQ(0, immediate_do_work_posted_count());
EXPECT_EQ(lazy_now.Now() + base::TimeDelta::FromSeconds(10),
- next_scheduled_delayed_do_work_time());
+ next_delayed_do_work_time());
}
TEST_F(TaskQueueManagerTest,
@@ -2488,18 +2498,21 @@ TEST_F(TaskQueueManagerTest,
Initialize(1u);
LazyNow lazy_now(now_src_.get());
- PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &lazy_now);
+ PostDoWorkContinuation(
+ TaskQueueManager::NextTaskDelay(base::TimeDelta::FromSeconds(1),
+ runners_[0]->GetTimeDomain()),
+ &lazy_now);
now_src_->Advance(base::TimeDelta::FromSeconds(1));
lazy_now = LazyNow(now_src_.get());
- PostDoWorkContinuation(base::TimeDelta(), &lazy_now);
+ PostDoWorkContinuation(TaskQueueManager::NextTaskDelay(), &lazy_now);
// Because the delayed DoWork was pending we don't expect an immediate DoWork
// to get posted.
EXPECT_EQ(1u, test_task_runner_->NumPendingTasks());
EXPECT_EQ(base::TimeDelta(), test_task_runner_->DelayToNextTaskTime());
EXPECT_EQ(0, immediate_do_work_posted_count());
- EXPECT_EQ(lazy_now.Now(), next_scheduled_delayed_do_work_time());
+ EXPECT_EQ(lazy_now.Now(), next_delayed_do_work_time());
}
namespace {
@@ -2600,5 +2613,65 @@ TEST_F(TaskQueueManagerTest, CouldTaskRun_FenceBeforeThenAfter) {
EXPECT_TRUE(runners_[0]->CouldTaskRun(enqueue_order));
}
+TEST_F(TaskQueueManagerTest, DelayedDoWorkNotPostedForDisabledQueue) {
+ Initialize(1u);
+
+ runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+ base::TimeDelta::FromMilliseconds(1));
+ ASSERT_TRUE(test_task_runner_->HasPendingTasks());
+ EXPECT_EQ(base::TimeDelta::FromMilliseconds(1),
+ test_task_runner_->DelayToNextTaskTime());
+
+ std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
+ runners_[0]->CreateQueueEnabledVoter();
+ voter->SetQueueEnabled(false);
+
+ EXPECT_TRUE(test_task_runner_->HasPendingTasks());
+ test_task_runner_->RemoveCancelledTasks();
+ EXPECT_FALSE(test_task_runner_->HasPendingTasks());
+
+ voter->SetQueueEnabled(true);
+ ASSERT_TRUE(test_task_runner_->HasPendingTasks());
+ EXPECT_EQ(base::TimeDelta::FromMilliseconds(1),
+ test_task_runner_->DelayToNextTaskTime());
+}
+
+TEST_F(TaskQueueManagerTest, DisablingQueuesChangesDelayTillNextDoWork) {
+ Initialize(3u);
+ runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+ base::TimeDelta::FromMilliseconds(1));
+ runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+ base::TimeDelta::FromMilliseconds(10));
+ runners_[2]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+ base::TimeDelta::FromMilliseconds(100));
+
+ std::unique_ptr<TaskQueue::QueueEnabledVoter> voter0 =
+ runners_[0]->CreateQueueEnabledVoter();
+ std::unique_ptr<TaskQueue::QueueEnabledVoter> voter1 =
+ runners_[1]->CreateQueueEnabledVoter();
+ std::unique_ptr<TaskQueue::QueueEnabledVoter> voter2 =
+ runners_[2]->CreateQueueEnabledVoter();
+
+ ASSERT_TRUE(test_task_runner_->HasPendingTasks());
+ EXPECT_EQ(base::TimeDelta::FromMilliseconds(1),
+ test_task_runner_->DelayToNextTaskTime());
+
+ voter0->SetQueueEnabled(false);
+ test_task_runner_->RemoveCancelledTasks();
+ ASSERT_TRUE(test_task_runner_->HasPendingTasks());
+ EXPECT_EQ(base::TimeDelta::FromMilliseconds(10),
+ test_task_runner_->DelayToNextTaskTime());
+
+ voter1->SetQueueEnabled(false);
+ test_task_runner_->RemoveCancelledTasks();
+ ASSERT_TRUE(test_task_runner_->HasPendingTasks());
+ EXPECT_EQ(base::TimeDelta::FromMilliseconds(100),
+ test_task_runner_->DelayToNextTaskTime());
+
+ voter2->SetQueueEnabled(false);
+ test_task_runner_->RemoveCancelledTasks();
+ EXPECT_FALSE(test_task_runner_->HasPendingTasks());
+}
+
} // namespace scheduler
} // namespace blink
« third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc ('K') | « third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_perftest.cc ('k') | third_party/WebKit/Source/platform/scheduler/base/time_domain.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698