Replaced TestNowSource with SimpleTestTickClock.

components/scheduler/child/idle_helper_unittest.cc

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..5b10c2e5e775373cfefdd4b4e4ed0315095d1681 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,24 +138,21 @@ 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));

[Sami, 2015/05/29 14:00:58]

Do any of the tests fail if we start the clock at zero? I'm not sure we actually
need to start at a non-zero time here.

[mithro-old, 2015/06/01 03:37:37]

Actually yes, a zero time is considered "null" and there are a bunch of checks
that the time given is not null.

[Ankur Verma, 2015/06/01 05:30:44]

A quick check here with zero, crashes IdleHelperTest.TestRepostingIdleTask in
TaskQueue::ScheduleDelayedWorkLocked() since LazyNow would contain
TaskQueueManager as null for 0 TimeTicks.

[mithro-old, 2015/06/01 07:32:15]

I wonder is the default SimpleTestTickClock should actually start a non-zero for
this very reason?

[Ankur Verma, 2015/06/01 09:21:40]

I'd wait for a response on
https://code.google.com/p/chromium/issues/detail?id=494894 for this.

[mithro-old, 2015/06/01 11:31:20]

I don't think you need to wait for that bug to be fixed. 

If we decide that issue should be fixed after this patch lands then we can
remove the clock_->Advance() from these tests.

[Ankur Verma, 2015/06/03 14:56:10]

Acknowledged.

+    mock_task_runner_ =
+        message_loop ? nullptr : new cc::OrderedSimpleTaskRunner(clock_, 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_)));
     scheduler_helper_->GetTaskQueueManagerForTesting()->SetTimeSourceForTesting(
@@ -214,7 +211,7 @@ class BaseIdleHelperTest : public testing::Test {
     return deadline;
   }
 
-  scoped_refptr<cc::TestNowSource> clock_;
+  base::SimpleTestTickClock* clock_;

[Sami, 2015/05/29 14:00:57]

Why isn't this a scoped_ptr? Looks like we're leaking the allocation now.

[Ankur Verma, 2015/06/01 05:30:44]

I will get on to this and update patch accordingly.

[Ankur Verma, 2015/06/03 14:56:10]

Done.

   // 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 +242,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 +253,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 +264,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 +272,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 +287,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 +297,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);
 }
@@ -318,16 +315,16 @@ TEST_F(IdleHelperTest, TestIdleTaskExceedsDeadline) {
                             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 +338,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 +348,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 +359,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 +377,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 +394,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 +472,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 +508,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 +519,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 +541,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 +573,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 +584,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 +607,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 +634,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 +663,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 +687,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 +723,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 +744,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 +833,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 +869,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();