Index: components/scheduler/child/idle_helper_unittest.cc |
diff --git a/components/scheduler/child/idle_helper_unittest.cc b/components/scheduler/child/idle_helper_unittest.cc |
index ad8ea26b0d5fe71dd5e36fa1ebb7668f2f4a05ed..0058687aa9398b0b23d32299cfc3fa4f20492831 100644 |
--- a/components/scheduler/child/idle_helper_unittest.cc |
+++ b/components/scheduler/child/idle_helper_unittest.cc |
@@ -5,8 +5,8 @@ |
#include "components/scheduler/child/idle_helper.h" |
#include "base/callback.h" |
+#include "base/test/simple_test_tick_clock.h" |
#include "cc/test/ordered_simple_task_runner.h" |
-#include "cc/test/test_now_source.h" |
#include "components/scheduler/child/nestable_task_runner_for_test.h" |
#include "components/scheduler/child/scheduler_helper.h" |
#include "components/scheduler/child/scheduler_message_loop_delegate.h" |
@@ -85,11 +85,11 @@ void RepeatingTask(base::SingleThreadTaskRunner* task_runner, |
} |
void UpdateClockToDeadlineIdleTestTask( |
- scoped_refptr<cc::TestNowSource> clock, |
+ base::SimpleTestTickClock* clock, |
base::SingleThreadTaskRunner* task_runner, |
int* run_count, |
base::TimeTicks deadline) { |
- clock->SetNow(deadline); |
+ clock->Advance(deadline - clock->NowTicks()); |
// Due to the way in which OrderedSimpleTestRunner orders tasks and the fact |
// that we updated the time within a task, the delayed pending task to call |
// EndIdlePeriod will not happen until after a TaskQueueManager DoWork, so |
@@ -138,28 +138,26 @@ class BaseIdleHelperTest : public testing::Test { |
BaseIdleHelperTest( |
base::MessageLoop* message_loop, |
base::TimeDelta required_quiescence_duration_before_long_idle_period) |
- : clock_(cc::TestNowSource::Create(5000)), |
- mock_task_runner_(message_loop |
- ? nullptr |
- : new cc::OrderedSimpleTaskRunner(clock_, false)), |
- message_loop_(message_loop), |
- nestable_task_runner_( |
- CreateNestableSingleThreadTaskRunner(message_loop, |
- mock_task_runner_)), |
- scheduler_helper_( |
- new SchedulerHelper(nestable_task_runner_, |
- "test.idle", |
- TRACE_DISABLED_BY_DEFAULT("test.idle"), |
- SchedulerHelper::TASK_QUEUE_COUNT + 1)), |
- idle_helper_(new IdleHelperForTest( |
- scheduler_helper_.get(), |
- required_quiescence_duration_before_long_idle_period)), |
- default_task_runner_(scheduler_helper_->DefaultTaskRunner()), |
- idle_task_runner_(idle_helper_->IdleTaskRunner()) { |
+ : clock_(new base::SimpleTestTickClock()), message_loop_(message_loop) { |
+ clock_->Advance(base::TimeDelta::FromInternalValue(5000)); |
+ mock_task_runner_ = |
+ message_loop ? nullptr |
+ : new cc::OrderedSimpleTaskRunner(clock_.get(), false); |
+ nestable_task_runner_ = |
+ CreateNestableSingleThreadTaskRunner(message_loop, mock_task_runner_); |
+ scheduler_helper_ = make_scoped_ptr( |
+ new SchedulerHelper(nestable_task_runner_, "test.idle", |
+ TRACE_DISABLED_BY_DEFAULT("test.idle"), |
+ SchedulerHelper::TASK_QUEUE_COUNT + 1)); |
+ idle_helper_ = make_scoped_ptr(new IdleHelperForTest( |
+ scheduler_helper_.get(), |
+ required_quiescence_duration_before_long_idle_period)); |
+ default_task_runner_ = scheduler_helper_->DefaultTaskRunner(); |
+ idle_task_runner_ = idle_helper_->IdleTaskRunner(); |
scheduler_helper_->SetTimeSourceForTesting( |
- make_scoped_ptr(new TestTimeSource(clock_))); |
+ make_scoped_ptr(new TestTimeSource(clock_.get()))); |
scheduler_helper_->GetTaskQueueManagerForTesting()->SetTimeSourceForTesting( |
- make_scoped_ptr(new TestTimeSource(clock_))); |
+ make_scoped_ptr(new TestTimeSource(clock_.get()))); |
} |
~BaseIdleHelperTest() override {} |
@@ -214,7 +212,7 @@ class BaseIdleHelperTest : public testing::Test { |
return deadline; |
} |
- scoped_refptr<cc::TestNowSource> clock_; |
+ scoped_ptr<base::SimpleTestTickClock> clock_; |
// Only one of mock_task_runner_ or message_loop_ will be set. |
scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_; |
scoped_ptr<base::MessageLoop> message_loop_; |
@@ -245,10 +243,10 @@ class IdleHelperTest : public BaseIdleHelperTest { |
TEST_F(IdleHelperTest, TestPostIdleTask) { |
int run_count = 0; |
base::TimeTicks expected_deadline = |
- clock_->Now() + base::TimeDelta::FromMilliseconds(2300); |
+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds(2300); |
base::TimeTicks deadline_in_task; |
- clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(100)); |
+ clock_->Advance(base::TimeDelta::FromMilliseconds(100)); |
idle_task_runner_->PostIdleTask( |
FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
@@ -256,7 +254,7 @@ TEST_F(IdleHelperTest, TestPostIdleTask) { |
EXPECT_EQ(0, run_count); |
idle_helper_->StartIdlePeriod( |
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), |
+ IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
expected_deadline, true); |
RunUntilIdle(); |
EXPECT_EQ(1, run_count); |
@@ -267,7 +265,7 @@ TEST_F(IdleHelperTest, TestPostIdleTask_EndIdlePeriod) { |
int run_count = 0; |
base::TimeTicks deadline_in_task; |
- clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(100)); |
+ clock_->Advance(base::TimeDelta::FromMilliseconds(100)); |
idle_task_runner_->PostIdleTask( |
FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
@@ -275,8 +273,8 @@ TEST_F(IdleHelperTest, TestPostIdleTask_EndIdlePeriod) { |
EXPECT_EQ(0, run_count); |
idle_helper_->StartIdlePeriod( |
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), |
- clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); |
+ IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
idle_helper_->EndIdlePeriod(); |
RunUntilIdle(); |
EXPECT_EQ(0, run_count); |
@@ -290,8 +288,8 @@ TEST_F(IdleHelperTest, TestRepostingIdleTask) { |
FROM_HERE, |
base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count)); |
idle_helper_->StartIdlePeriod( |
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), |
- clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); |
+ IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
RunUntilIdle(); |
EXPECT_EQ(1, run_count); |
@@ -300,8 +298,8 @@ TEST_F(IdleHelperTest, TestRepostingIdleTask) { |
EXPECT_EQ(1, run_count); |
idle_helper_->StartIdlePeriod( |
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), |
- clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); |
+ IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
RunUntilIdle(); |
EXPECT_EQ(2, run_count); |
} |
@@ -311,23 +309,23 @@ TEST_F(IdleHelperTest, TestIdleTaskExceedsDeadline) { |
// Post two UpdateClockToDeadlineIdleTestTask tasks. |
idle_task_runner_->PostIdleTask( |
- FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_, |
+ FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_.get(), |
default_task_runner_, &run_count)); |
idle_task_runner_->PostIdleTask( |
- FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_, |
+ FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_.get(), |
default_task_runner_, &run_count)); |
idle_helper_->StartIdlePeriod( |
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), |
- clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); |
+ IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
RunUntilIdle(); |
// Only the first idle task should execute since it's used up the deadline. |
EXPECT_EQ(1, run_count); |
idle_helper_->EndIdlePeriod(); |
idle_helper_->StartIdlePeriod( |
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), |
- clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); |
+ IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
RunUntilIdle(); |
// Second task should be run on the next idle period. |
EXPECT_EQ(2, run_count); |
@@ -341,8 +339,8 @@ TEST_F(IdleHelperTest, TestPostIdleTaskAfterWakeup) { |
FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
idle_helper_->StartIdlePeriod( |
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), |
- clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); |
+ IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
RunUntilIdle(); |
// Shouldn't run yet as no other task woke up the scheduler. |
EXPECT_EQ(0, run_count); |
@@ -351,8 +349,8 @@ TEST_F(IdleHelperTest, TestPostIdleTaskAfterWakeup) { |
FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
idle_helper_->StartIdlePeriod( |
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), |
- clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); |
+ IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
RunUntilIdle(); |
// Another after wakeup idle task shouldn't wake the scheduler. |
EXPECT_EQ(0, run_count); |
@@ -362,8 +360,8 @@ TEST_F(IdleHelperTest, TestPostIdleTaskAfterWakeup) { |
RunUntilIdle(); |
// Must start a new idle period before idle task runs. |
idle_helper_->StartIdlePeriod( |
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), |
- clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); |
+ IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
RunUntilIdle(); |
// Execution of default task queue task should trigger execution of idle task. |
EXPECT_EQ(2, run_count); |
@@ -380,8 +378,8 @@ TEST_F(IdleHelperTest, TestPostIdleTaskAfterWakeupWhileAwake) { |
RunUntilIdle(); |
// Must start a new idle period before idle task runs. |
idle_helper_->StartIdlePeriod( |
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), |
- clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); |
+ IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
RunUntilIdle(); |
// Should run as the scheduler was already awakened by the normal task. |
EXPECT_EQ(1, run_count); |
@@ -397,13 +395,13 @@ TEST_F(IdleHelperTest, TestPostIdleTaskWakesAfterWakeupIdleTask) { |
FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
idle_helper_->StartIdlePeriod( |
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), |
- clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); |
+ IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
RunUntilIdle(); |
// Must start a new idle period before after-wakeup idle task runs. |
idle_helper_->StartIdlePeriod( |
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), |
- clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); |
+ IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
RunUntilIdle(); |
// Normal idle task should wake up after-wakeup idle task. |
EXPECT_EQ(2, run_count); |
@@ -475,8 +473,8 @@ class IdleHelperWithMessageLoopTest : public BaseIdleHelperTest { |
} |
} |
idle_helper_->StartIdlePeriod( |
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), |
- clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); |
+ IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
message_loop_->RunUntilIdle(); |
} |
@@ -511,8 +509,8 @@ TEST_F(IdleHelperWithMessageLoopTest, |
base::Unretained(&tasks_to_post_from_nested_loop))); |
idle_helper_->StartIdlePeriod( |
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), |
- clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); |
+ IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
RunUntilIdle(); |
// Note we expect task 3 to run last because it's non-nestable. |
EXPECT_THAT(order, testing::ElementsAre(std::string("1"), std::string("2"), |
@@ -522,7 +520,7 @@ TEST_F(IdleHelperWithMessageLoopTest, |
TEST_F(IdleHelperTest, TestLongIdlePeriod) { |
base::TimeTicks expected_deadline = |
- clock_->Now() + maximum_idle_period_duration(); |
+ clock_->NowTicks() + maximum_idle_period_duration(); |
base::TimeTicks deadline_in_task; |
int run_count = 0; |
@@ -544,7 +542,7 @@ TEST_F(IdleHelperTest, TestLongIdlePeriod) { |
TEST_F(IdleHelperTest, TestLongIdlePeriodWithPendingDelayedTask) { |
base::TimeDelta pending_task_delay = base::TimeDelta::FromMilliseconds(30); |
- base::TimeTicks expected_deadline = clock_->Now() + pending_task_delay; |
+ base::TimeTicks expected_deadline = clock_->NowTicks() + pending_task_delay; |
base::TimeTicks deadline_in_task; |
int run_count = 0; |
@@ -576,7 +574,7 @@ TEST_F(IdleHelperTest, TestLongIdlePeriodWithLatePendingDelayedTask) { |
pending_task_delay); |
// Advance clock until after delayed task was meant to be run. |
- clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(20)); |
+ clock_->Advance(base::TimeDelta::FromMilliseconds(20)); |
// Post an idle task and then EnableLongIdlePeriod. Since there is a late |
// pending delayed task this shouldn't actually start an idle period. |
@@ -587,7 +585,7 @@ TEST_F(IdleHelperTest, TestLongIdlePeriodWithLatePendingDelayedTask) { |
EXPECT_EQ(0, run_count); |
// After the delayed task has been run we should trigger an idle period. |
- clock_->AdvanceNow(maximum_idle_period_duration()); |
+ clock_->Advance(maximum_idle_period_duration()); |
RunUntilIdle(); |
EXPECT_EQ(1, run_count); |
} |
@@ -610,13 +608,13 @@ TEST_F(IdleHelperTest, TestLongIdlePeriodRepeating) { |
// Advance time to start of next long idle period and check task reposted task |
// gets run. |
- clock_->AdvanceNow(maximum_idle_period_duration()); |
+ clock_->Advance(maximum_idle_period_duration()); |
RunUntilIdle(); |
EXPECT_EQ(2, run_count); |
// Advance time to start of next long idle period then end the idle period and |
// check the task doesn't get run. |
- clock_->AdvanceNow(maximum_idle_period_duration()); |
+ clock_->Advance(maximum_idle_period_duration()); |
idle_helper_->EndIdlePeriod(); |
RunUntilIdle(); |
EXPECT_EQ(2, run_count); |
@@ -637,7 +635,7 @@ TEST_F(IdleHelperTest, TestLongIdlePeriodDoesNotWakeScheduler) { |
// the idle period deadline shouldn't update at the end of the current long |
// idle period. |
base::TimeTicks idle_period_deadline = CurrentIdleTaskDeadlineForTesting(); |
- clock_->AdvanceNow(maximum_idle_period_duration()); |
+ clock_->Advance(maximum_idle_period_duration()); |
RunUntilIdle(); |
base::TimeTicks new_idle_period_deadline = |
@@ -666,7 +664,7 @@ TEST_F(IdleHelperTest, TestLongIdlePeriodDoesNotWakeScheduler) { |
TEST_F(IdleHelperTest, TestLongIdlePeriodWhenNotCanEnterLongIdlePeriod) { |
base::TimeDelta delay = base::TimeDelta::FromMilliseconds(1000); |
base::TimeDelta halfDelay = base::TimeDelta::FromMilliseconds(500); |
- base::TimeTicks delayOver = clock_->Now() + delay; |
+ base::TimeTicks delayOver = clock_->NowTicks() + delay; |
base::TimeTicks deadline_in_task; |
int run_count = 0; |
@@ -690,12 +688,12 @@ TEST_F(IdleHelperTest, TestLongIdlePeriodWhenNotCanEnterLongIdlePeriod) { |
RunUntilIdle(); |
EXPECT_EQ(0, run_count); |
- clock_->AdvanceNow(halfDelay); |
+ clock_->Advance(halfDelay); |
RunUntilIdle(); |
EXPECT_EQ(0, run_count); |
// Delay is finished, idle task should run. |
- clock_->AdvanceNow(halfDelay); |
+ clock_->Advance(halfDelay); |
RunUntilIdle(); |
EXPECT_EQ(1, run_count); |
} |
@@ -726,8 +724,8 @@ TEST_F(IdleHelperTest, CanExceedIdleDeadlineIfRequired) { |
base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, idle_helper_.get(), |
&can_exceed_idle_deadline, &run_count)); |
idle_helper_->StartIdlePeriod( |
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(), |
- clock_->Now() + base::TimeDelta::FromMilliseconds(10), true); |
+ IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(), |
+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10), true); |
RunUntilIdle(); |
EXPECT_EQ(1, run_count); |
EXPECT_FALSE(can_exceed_idle_deadline); |
@@ -747,7 +745,7 @@ TEST_F(IdleHelperTest, CanExceedIdleDeadlineIfRequired) { |
// Next long idle period will be for the maximum time, so |
// CanExceedIdleDeadlineIfRequired should return true. |
- clock_->AdvanceNow(maximum_idle_period_duration()); |
+ clock_->Advance(maximum_idle_period_duration()); |
idle_task_runner_->PostIdleTask( |
FROM_HERE, |
base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, idle_helper_.get(), |
@@ -836,8 +834,8 @@ TEST_F(IdleHelperWithQuiescencePeriodTest, |
// In this scenario EnableLongIdlePeriod deems us not to be quiescent 5x in |
// a row. |
base::TimeTicks expected_deadline = |
- clock_->Now() + base::TimeDelta::FromMilliseconds(5 * kQuiescenceDelayMs + |
- kLongIdlePeriodMs); |
+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds( |
+ 5 * kQuiescenceDelayMs + kLongIdlePeriodMs); |
base::TimeTicks deadline_in_task; |
idle_task_runner_->PostIdleTask( |
FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task)); |
@@ -872,7 +870,7 @@ TEST_F(IdleHelperWithQuiescencePeriodTest, |
// immediately because the system isn't judged to be quiescent until the |
// second time EnableLongIdlePeriod is run. |
base::TimeTicks expected_deadline = |
- clock_->Now() + |
+ clock_->NowTicks() + |
base::TimeDelta::FromMilliseconds(kQuiescenceDelayMs + kLongIdlePeriodMs); |
default_task_runner_->PostTask(FROM_HERE, base::Bind(NullTask)); |
RunUntilIdle(); |