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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: components/scheduler/child/idle_helper_unittest.cc

Issue 1132753008: Replaced TestNowSource with SimpleTestTickClock. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Incorporated review comments: scoped leaking clocks, refactored num_now_calls_ functionality Created 5 years, 7 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
« components/components_tests.gyp ('K') | « components/scheduler/BUILD.gn ('k') | components/scheduler/child/scheduler_helper_unittest.cc » ('j') | components/scheduler/child/test_always_fail_time_source.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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();
« components/components_tests.gyp ('K') | « components/scheduler/BUILD.gn ('k') | components/scheduler/child/scheduler_helper_unittest.cc » ('j') | components/scheduler/child/test_always_fail_time_source.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698