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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 2674903003: Revert of 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/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 3955b20522054e52e7c37b6f05ef2d9a6271256f..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
@@ -42,21 +42,6 @@
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(
@@ -100,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");
@@ -121,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");
@@ -135,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,
@@ -154,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 {
@@ -192,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_;
};
@@ -221,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");
@@ -254,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");
@@ -399,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());
}
@@ -2333,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)));
@@ -2340,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) {
@@ -2389,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) {
@@ -2401,46 +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());
+ EXPECT_TRUE(next_scheduled_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,
@@ -2453,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.
@@ -2492,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,
@@ -2500,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 {
@@ -2614,65 +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());
-}
-
} // 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/time_domain.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698