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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 2705703002: Revert of [Reland] Dont post delayed DoWork for disabled queues. (Closed)
Patch Set: 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 ed91bfac1b981f370ca3091b44057560d31c0ed8..fc290a3c42e06a279c3382b291972f903b04caba 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,32 +32,15 @@
#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;
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:
@@ -102,7 +85,7 @@
test_task_runner_.get(),
base::MakeUnique<TestTimeSource>(now_src_.get()));
- manager_ = base::MakeUnique<TaskQueueManagerForTest>(
+ manager_ = base::MakeUnique<TaskQueueManager>(
main_task_runner_, "test.scheduler", "test.scheduler",
"test.scheduler.debug");
@@ -123,7 +106,7 @@
message_loop_.reset(new base::MessageLoop());
// A null clock triggers some assertions.
now_src_->Advance(base::TimeDelta::FromMicroseconds(1000));
- manager_ = base::MakeUnique<TaskQueueManagerForTest>(
+ manager_ = base::MakeUnique<TaskQueueManager>(
MessageLoopTaskRunner::Create(
base::WrapUnique(new TestTimeSource(now_src_.get()))),
"test.scheduler", "test.scheduler", "test.scheduler.debug");
@@ -137,14 +120,12 @@
manager_->WakeupReadyDelayedQueues(&lazy_now);
}
- using NextTaskDelay = TaskQueueManagerForTest::NextTaskDelay;
-
- base::Optional<NextTaskDelay> ComputeDelayTillNextTask(LazyNow* lazy_now) {
+ base::Optional<base::TimeDelta> ComputeDelayTillNextTask(LazyNow* lazy_now) {
base::AutoLock lock(manager_->any_thread_lock_);
return manager_->ComputeDelayTillNextTaskLocked(lazy_now);
}
- void PostDoWorkContinuation(base::Optional<NextTaskDelay> next_delay,
+ void PostDoWorkContinuation(base::Optional<base::TimeDelta> next_delay,
LazyNow* lazy_now) {
MoveableAutoLock lock(manager_->any_thread_lock_);
return manager_->PostDoWorkContinuationLocked(next_delay, lazy_now,
@@ -156,8 +137,8 @@
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();
+ base::TimeTicks next_scheduled_delayed_do_work_time() const {
+ return manager_->next_scheduled_delayed_do_work_time_;
}
EnqueueOrder GetNextSequenceNumber() const {
@@ -194,7 +175,7 @@
std::unique_ptr<base::SimpleTestTickClock> now_src_;
scoped_refptr<TaskQueueManagerDelegateForTest> main_task_runner_;
scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_;
- std::unique_ptr<TaskQueueManagerForTest> manager_;
+ std::unique_ptr<TaskQueueManager> manager_;
std::vector<scoped_refptr<internal::TaskQueueImpl>> runners_;
TestTaskTimeObserver test_task_time_observer_;
};
@@ -223,7 +204,7 @@
TestCountUsesTimeSource* test_count_uses_time_source =
new TestCountUsesTimeSource();
- manager_ = base::MakeUnique<TaskQueueManagerForTest>(
+ manager_ = base::MakeUnique<TaskQueueManager>(
MessageLoopTaskRunner::Create(
base::WrapUnique(test_count_uses_time_source)),
"test.scheduler", "test.scheduler", "test.scheduler.debug");
@@ -256,7 +237,7 @@
TestCountUsesTimeSource* test_count_uses_time_source =
new TestCountUsesTimeSource();
- manager_ = base::MakeUnique<TaskQueueManagerForTest>(
+ manager_ = base::MakeUnique<TaskQueueManager>(
MessageLoopTaskRunner::Create(
base::WrapUnique(test_count_uses_time_source)),
"test.scheduler", "test.scheduler", "test.scheduler.debug");
@@ -401,11 +382,16 @@
EXPECT_TRUE(runners_[0]->HasPendingImmediateWork());
// Move the task into the |delayed_work_queue|.
- WakeupReadyDelayedQueues(LazyNow(now_src_.get()));
+ EXPECT_TRUE(runners_[0]->delayed_work_queue()->Empty());
+ std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
+ runners_[0]->CreateQueueEnabledVoter();
+ voter->SetQueueEnabled(false);
+ test_task_runner_->RunUntilIdle();
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());
}
@@ -1687,137 +1673,6 @@
manager_->UnregisterTimeDomain(domain_a.get());
manager_->UnregisterTimeDomain(domain_b.get());
-}
-
-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 {
@@ -2466,6 +2321,10 @@
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)));
@@ -2473,23 +2332,27 @@
base::TimeDelta::FromSeconds(10));
EXPECT_EQ(base::TimeDelta::FromSeconds(10),
- ComputeDelayTillNextTask(&lazy_now)->delay());
+ ComputeDelayTillNextTask(&lazy_now).value());
runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
base::TimeDelta::FromSeconds(15));
EXPECT_EQ(base::TimeDelta::FromSeconds(10),
- ComputeDelayTillNextTask(&lazy_now)->delay());
+ ComputeDelayTillNextTask(&lazy_now).value());
runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
base::TimeDelta::FromSeconds(5));
EXPECT_EQ(base::TimeDelta::FromSeconds(5),
- ComputeDelayTillNextTask(&lazy_now)->delay());
+ ComputeDelayTillNextTask(&lazy_now).value());
runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
- EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->delay());
+ EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now).value());
+
+ // Tidy up.
+ runners_[1]->UnregisterTaskQueue();
+ manager_->UnregisterTimeDomain(domain2.get());
}
TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_Disabled) {
@@ -2522,7 +2385,7 @@
runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
LazyNow lazy_now(now_src_.get());
- EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->delay());
+ EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now).value());
}
TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_DelayedTaskReady) {
@@ -2534,63 +2397,44 @@
now_src_->Advance(base::TimeDelta::FromSeconds(10));
LazyNow lazy_now(now_src_.get());
- EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->delay());
+ EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now).value());
}
TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_NoMoreWork) {
Initialize(1u);
LazyNow lazy_now(now_src_.get());
- PostDoWorkContinuation(base::Optional<NextTaskDelay>(), &lazy_now);
+ PostDoWorkContinuation(base::Optional<base::TimeDelta>(), &lazy_now);
EXPECT_EQ(0u, test_task_runner_->NumPendingTasks());
EXPECT_EQ(0, immediate_do_work_posted_count());
- EXPECT_TRUE(next_delayed_do_work_time().is_null());
+ EXPECT_TRUE(next_scheduled_delayed_do_work_time().is_null());
}
TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_ImmediateWork) {
Initialize(1u);
LazyNow lazy_now(now_src_.get());
- PostDoWorkContinuation(NextTaskDelay(), &lazy_now);
+ PostDoWorkContinuation(base::TimeDelta(), &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_DelayedWorkInThePast) {
+ EXPECT_TRUE(next_scheduled_delayed_do_work_time().is_null());
+}
+
+TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_DelayedWork) {
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(NextTaskDelay(base::TimeDelta::FromSeconds(1),
- runners_[0]->GetTimeDomain()),
- &lazy_now);
+ PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &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_delayed_do_work_time());
+ next_scheduled_delayed_do_work_time());
}
TEST_F(TaskQueueManagerTest,
@@ -2603,35 +2447,29 @@
EXPECT_EQ(1, immediate_do_work_posted_count());
LazyNow lazy_now(now_src_.get());
- PostDoWorkContinuation(NextTaskDelay(base::TimeDelta::FromSeconds(1),
- runners_[0]->GetTimeDomain()),
- &lazy_now);
+ PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &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_delayed_do_work_time().is_null());
+ EXPECT_TRUE(next_scheduled_delayed_do_work_time().is_null());
}
TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_DelayedWorkTimeChanges) {
Initialize(1u);
LazyNow lazy_now(now_src_.get());
- PostDoWorkContinuation(NextTaskDelay(base::TimeDelta::FromSeconds(1),
- runners_[0]->GetTimeDomain()),
- &lazy_now);
+ PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &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_delayed_do_work_time());
-
- PostDoWorkContinuation(NextTaskDelay(base::TimeDelta::FromSeconds(10),
- runners_[0]->GetTimeDomain()),
- &lazy_now);
+ next_scheduled_delayed_do_work_time());
+
+ PostDoWorkContinuation(base::TimeDelta::FromSeconds(10), &lazy_now);
// This should have resulted in the previous task getting canceled and a new
// one getting posted.
@@ -2642,7 +2480,7 @@
test_task_runner_->DelayToNextTaskTime());
EXPECT_EQ(0, immediate_do_work_posted_count());
EXPECT_EQ(lazy_now.Now() + base::TimeDelta::FromSeconds(10),
- next_delayed_do_work_time());
+ next_scheduled_delayed_do_work_time());
}
TEST_F(TaskQueueManagerTest,
@@ -2650,20 +2488,18 @@
Initialize(1u);
LazyNow lazy_now(now_src_.get());
- PostDoWorkContinuation(NextTaskDelay(base::TimeDelta::FromSeconds(1),
- runners_[0]->GetTimeDomain()),
- &lazy_now);
+ PostDoWorkContinuation(base::TimeDelta::FromSeconds(1), &lazy_now);
now_src_->Advance(base::TimeDelta::FromSeconds(1));
lazy_now = LazyNow(now_src_.get());
- PostDoWorkContinuation(NextTaskDelay(), &lazy_now);
+ PostDoWorkContinuation(base::TimeDelta(), &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_delayed_do_work_time());
+ EXPECT_EQ(lazy_now.Now(), next_scheduled_delayed_do_work_time());
}
namespace {
@@ -2764,98 +2600,5 @@
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());
-}
-
} // 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