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

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: Fix compile Created 3 years, 10 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
« no previous file with comments | « third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_perftest.cc ('k') | third_party/WebKit/Source/platform/scheduler/base/task_queue_selector_unittest.cc » ('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..238d8305ee93585d50479670607657a4c59d1b0f 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
@@ -32,9 +32,11 @@
#include "platform/scheduler/base/work_queue_sets.h"
#include "testing/gmock/include/gmock/gmock.h"
+using testing::AnyNumber;
using testing::Contains;
using testing::ElementsAre;
using testing::ElementsAreArray;
+using testing::Mock;
using testing::Not;
using testing::_;
using blink::scheduler::internal::EnqueueOrder;
@@ -42,6 +44,21 @@ using blink::scheduler::internal::EnqueueOrder;
namespace blink {
namespace scheduler {
+class TaskQueueManagerForTest : public TaskQueueManager {
+ public:
+ TaskQueueManagerForTest(
+ scoped_refptr<TaskQueueManagerDelegate> delegate,
+ const char* tracing_category,
+ const char* disabled_by_default_tracing_category,
+ const char* disabled_by_default_verbose_tracing_category)
+ : TaskQueueManager(delegate,
+ tracing_category,
+ disabled_by_default_tracing_category,
+ disabled_by_default_verbose_tracing_category) {}
+
+ using TaskQueueManager::NextTaskDelay;
+};
+
class MessageLoopTaskRunner : public TaskQueueManagerDelegateForTest {
public:
static scoped_refptr<MessageLoopTaskRunner> Create(
@@ -85,7 +102,7 @@ class TaskQueueManagerTest : public testing::Test {
test_task_runner_.get(),
base::MakeUnique<TestTimeSource>(now_src_.get()));
- manager_ = base::MakeUnique<TaskQueueManager>(
+ manager_ = base::MakeUnique<TaskQueueManagerForTest>(
main_task_runner_, "test.scheduler", "test.scheduler",
"test.scheduler.debug");
@@ -106,7 +123,7 @@ class TaskQueueManagerTest : public testing::Test {
message_loop_.reset(new base::MessageLoop());
// A null clock triggers some assertions.
now_src_->Advance(base::TimeDelta::FromMicroseconds(1000));
- manager_ = base::MakeUnique<TaskQueueManager>(
+ manager_ = base::MakeUnique<TaskQueueManagerForTest>(
MessageLoopTaskRunner::Create(
base::WrapUnique(new TestTimeSource(now_src_.get()))),
"test.scheduler", "test.scheduler", "test.scheduler.debug");
@@ -120,12 +137,14 @@ class TaskQueueManagerTest : public testing::Test {
manager_->WakeupReadyDelayedQueues(&lazy_now);
}
- base::Optional<base::TimeDelta> ComputeDelayTillNextTask(LazyNow* lazy_now) {
+ using NextTaskDelay = TaskQueueManagerForTest::NextTaskDelay;
+
+ base::Optional<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,
+ void PostDoWorkContinuation(base::Optional<NextTaskDelay> next_delay,
LazyNow* lazy_now) {
MoveableAutoLock lock(manager_->any_thread_lock_);
return manager_->PostDoWorkContinuationLocked(next_delay, lazy_now,
@@ -137,8 +156,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 {
@@ -175,7 +194,7 @@ class TaskQueueManagerTest : public testing::Test {
std::unique_ptr<base::SimpleTestTickClock> now_src_;
scoped_refptr<TaskQueueManagerDelegateForTest> main_task_runner_;
scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_;
- std::unique_ptr<TaskQueueManager> manager_;
+ std::unique_ptr<TaskQueueManagerForTest> manager_;
std::vector<scoped_refptr<internal::TaskQueueImpl>> runners_;
TestTaskTimeObserver test_task_time_observer_;
};
@@ -204,7 +223,7 @@ TEST_F(TaskQueueManagerTest,
TestCountUsesTimeSource* test_count_uses_time_source =
new TestCountUsesTimeSource();
- manager_ = base::MakeUnique<TaskQueueManager>(
+ manager_ = base::MakeUnique<TaskQueueManagerForTest>(
MessageLoopTaskRunner::Create(
base::WrapUnique(test_count_uses_time_source)),
"test.scheduler", "test.scheduler", "test.scheduler.debug");
@@ -237,7 +256,7 @@ TEST_F(TaskQueueManagerTest, NowNotCalledForNestedTasks) {
TestCountUsesTimeSource* test_count_uses_time_source =
new TestCountUsesTimeSource();
- manager_ = base::MakeUnique<TaskQueueManager>(
+ manager_ = base::MakeUnique<TaskQueueManagerForTest>(
MessageLoopTaskRunner::Create(
base::WrapUnique(test_count_uses_time_source)),
"test.scheduler", "test.scheduler", "test.scheduler.debug");
@@ -382,16 +401,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());
}
@@ -1676,6 +1690,137 @@ TEST_F(TaskQueueManagerTest,
}
namespace {
+class MockTimeDomainObserver : public TimeDomain::Observer {
+ public:
+ ~MockTimeDomainObserver() override {}
+
+ MOCK_METHOD1(OnTimeDomainHasImmediateWork, void(TaskQueue*));
+ MOCK_METHOD1(OnTimeDomainHasDelayedWork, void(TaskQueue*));
+};
+} // namespace
+
+TEST_F(TaskQueueManagerTest, TimeDomainObserver_ImmediateTask) {
+ Initialize(1u);
+
+ MockTimeDomainObserver observer;
+ std::unique_ptr<VirtualTimeDomain> domain(
+ new VirtualTimeDomain(&observer, manager_->delegate()->NowTicks()));
+ manager_->RegisterTimeDomain(domain.get());
+ runners_[0]->SetTimeDomain(domain.get());
+
+ // We should get a notification when a task is posted on an empty queue.
+ EXPECT_CALL(observer, OnTimeDomainHasImmediateWork(runners_[0].get()));
+ runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
+ Mock::VerifyAndClearExpectations(&observer);
+
+ // But not subsequently.
+ EXPECT_CALL(observer, OnTimeDomainHasImmediateWork(_)).Times(0);
+ runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
+ Mock::VerifyAndClearExpectations(&observer);
+
+ // Unless the immediate work queue is emptied.
+ runners_[0]->ReloadImmediateWorkQueueIfEmpty();
+ EXPECT_CALL(observer, OnTimeDomainHasImmediateWork(runners_[0].get()));
+ runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
+
+ // Tidy up.
+ runners_[0]->UnregisterTaskQueue();
+ manager_->UnregisterTimeDomain(domain.get());
+}
+
+TEST_F(TaskQueueManagerTest, TimeDomainObserver_DelayedTask) {
+ Initialize(1u);
+
+ MockTimeDomainObserver observer;
+ std::unique_ptr<VirtualTimeDomain> domain(
+ new VirtualTimeDomain(&observer, manager_->delegate()->NowTicks()));
+ manager_->RegisterTimeDomain(domain.get());
+ runners_[0]->SetTimeDomain(domain.get());
+
+ // We should get a notification when a delayed task is posted on an empty
+ // queue.
+ EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[0].get()));
+ runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+ base::TimeDelta::FromSeconds(10));
+ Mock::VerifyAndClearExpectations(&observer);
+
+ // We should not get a notification for a longer delay.
+ EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(_)).Times(0);
+ runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+ base::TimeDelta::FromSeconds(100));
+ Mock::VerifyAndClearExpectations(&observer);
+
+ // We should get a notification for a shorter delay.
+ EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[0].get()));
+ runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+ base::TimeDelta::FromSeconds(1));
+ Mock::VerifyAndClearExpectations(&observer);
+
+ std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
+ runners_[0]->CreateQueueEnabledVoter();
+ voter->SetQueueEnabled(false);
+
+ // When a queue has been enabled, we may get a notification if the
+ // TimeDomain's next scheduled wakeup has changed.
+ EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[0].get()));
+ voter->SetQueueEnabled(true);
+
+ // Tidy up.
+ runners_[0]->UnregisterTaskQueue();
+ manager_->UnregisterTimeDomain(domain.get());
+}
+
+TEST_F(TaskQueueManagerTest, TimeDomainObserver_DelayedTaskMultipleQueues) {
+ Initialize(2u);
+
+ MockTimeDomainObserver observer;
+ std::unique_ptr<VirtualTimeDomain> domain(
+ new VirtualTimeDomain(&observer, manager_->delegate()->NowTicks()));
+ manager_->RegisterTimeDomain(domain.get());
+ runners_[0]->SetTimeDomain(domain.get());
+ runners_[1]->SetTimeDomain(domain.get());
+
+ EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[0].get())).Times(1);
+ EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[1].get())).Times(1);
+ runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+ base::TimeDelta::FromSeconds(1));
+ runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+ base::TimeDelta::FromSeconds(10));
+ testing::Mock::VerifyAndClearExpectations(&observer);
+
+ std::unique_ptr<TaskQueue::QueueEnabledVoter> voter0 =
+ runners_[0]->CreateQueueEnabledVoter();
+ std::unique_ptr<TaskQueue::QueueEnabledVoter> voter1 =
+ runners_[1]->CreateQueueEnabledVoter();
+
+ // Disabling a queue should not trigger a notification.
+ EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(_)).Times(0);
+ voter0->SetQueueEnabled(false);
+ Mock::VerifyAndClearExpectations(&observer);
+
+ // Re-enabling it should should also trigger a notification.
+ EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[0].get()));
+ voter0->SetQueueEnabled(true);
+ Mock::VerifyAndClearExpectations(&observer);
+
+ // Disabling a queue should not trigger a notification.
+ EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(_)).Times(0);
+ voter1->SetQueueEnabled(false);
+ Mock::VerifyAndClearExpectations(&observer);
+
+ // Re-enabling it should should trigger a notification.
+ EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(runners_[1].get()));
+ voter1->SetQueueEnabled(true);
+ Mock::VerifyAndClearExpectations(&observer);
+
+ // Tidy up.
+ EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(_)).Times(AnyNumber());
+ runners_[0]->UnregisterTaskQueue();
+ runners_[1]->UnregisterTaskQueue();
+ manager_->UnregisterTimeDomain(domain.get());
+}
+
+namespace {
void ChromiumRunloopInspectionTask(
scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner) {
EXPECT_EQ(1u, test_task_runner->NumPendingTasks());
@@ -2321,10 +2466,6 @@ TEST_F(TaskQueueManagerTest, SweepCanceledDelayedTasks) {
TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask) {
Initialize(2u);
- std::unique_ptr<RealTimeDomain> domain2(new RealTimeDomain("test"));
- manager_->RegisterTimeDomain(domain2.get());
- runners_[1]->SetTimeDomain(domain2.get());
-
LazyNow lazy_now(now_src_.get());
EXPECT_FALSE(static_cast<bool>(ComputeDelayTillNextTask(&lazy_now)));
@@ -2332,27 +2473,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());
-
- // Tidy up.
- runners_[1]->UnregisterTaskQueue();
- manager_->UnregisterTimeDomain(domain2.get());
+ EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->delay());
}
TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_Disabled) {
@@ -2385,7 +2522,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 +2534,63 @@ 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<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(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_DelayedWorkInThePast) {
+ Initialize(1u);
+
+ LazyNow lazy_now(now_src_.get());
+ // Note this isn't supposed to happen in practice.
+ PostDoWorkContinuation(
+ NextTaskDelay(base::TimeDelta::FromSeconds(-1),
+ runners_[0]->GetTimeDomain(),
+ NextTaskDelay::AllowAnyDelayForTesting()),
+ &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_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(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 +2603,35 @@ 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(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(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(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 +2642,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 +2650,20 @@ TEST_F(TaskQueueManagerTest,
Initialize(1u);
LazyNow lazy_now(now_src_.get());
- PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &lazy_now);
+ PostDoWorkContinuation(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(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 +2764,122 @@ 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());
+}
+
+TEST_F(TaskQueueManagerTest, GetNextScheduledWakeUp) {
+ Initialize(1u);
+
+ EXPECT_EQ(base::nullopt, runners_[0]->GetNextScheduledWakeUp());
+
+ base::TimeTicks start_time = manager_->delegate()->NowTicks();
+ base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(10);
+ base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(2);
+
+ runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1);
+ EXPECT_EQ(start_time + delay1, runners_[0]->GetNextScheduledWakeUp());
+
+ runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2);
+ EXPECT_EQ(start_time + delay2, runners_[0]->GetNextScheduledWakeUp());
+
+ // We don't have wakeups scheduled for disabled queues.
+ std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
+ runners_[0]->CreateQueueEnabledVoter();
+ voter->SetQueueEnabled(false);
+ EXPECT_EQ(base::nullopt, runners_[0]->GetNextScheduledWakeUp());
+
+ voter->SetQueueEnabled(true);
+ EXPECT_EQ(start_time + delay2, runners_[0]->GetNextScheduledWakeUp());
+
+ // Immediate tasks shouldn't make any difference.
+ runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
+ EXPECT_EQ(start_time + delay2, runners_[0]->GetNextScheduledWakeUp());
+
+ // Neither should fences.
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
+ EXPECT_EQ(start_time + delay2, runners_[0]->GetNextScheduledWakeUp());
+}
+
+TEST_F(TaskQueueManagerTest, SetTimeDomainForDisabledQueue) {
+ Initialize(1u);
+
+ runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
+ base::TimeDelta::FromMilliseconds(1));
+
+ std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
+ runners_[0]->CreateQueueEnabledVoter();
+ voter->SetQueueEnabled(false);
+
+ MockTimeDomainObserver observer;
+ // We should not get a notification for a disabled queue.
+ EXPECT_CALL(observer, OnTimeDomainHasDelayedWork(_)).Times(0);
+
+ std::unique_ptr<VirtualTimeDomain> domain(
+ new VirtualTimeDomain(&observer, manager_->delegate()->NowTicks()));
+ manager_->RegisterTimeDomain(domain.get());
+ runners_[0]->SetTimeDomain(domain.get());
+
+ // Tidy up.
+ runners_[0]->UnregisterTaskQueue();
+ manager_->UnregisterTimeDomain(domain.get());
+}
+
} // namespace scheduler
} // namespace blink
« no previous file with comments | « third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_perftest.cc ('k') | third_party/WebKit/Source/platform/scheduler/base/task_queue_selector_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698