Replaced TestNowSource with SimpleTestTickClock.

components/scheduler/child/idle_helper_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #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"
 #include "components/scheduler/child/task_queue_manager.h"
 #include "components/scheduler/child/test_time_source.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::AnyNumber;
@@ skipping 54 matching lines @@
         base::Bind(&RepostingIdleTestTask, base::Unretained(idle_task_runner),
                    run_count, deadline_out));
   }
   *deadline_out = deadline;
   (*run_count)++;
 }
 
 void RepostingUpdateClockIdleTestTask(
     SingleThreadIdleTaskRunner* idle_task_runner,
     int* run_count,
-    scoped_refptr<cc::TestNowSource> clock,
+    base::SimpleTestTickClock* clock,
     base::TimeDelta advance_time,
     std::vector<base::TimeTicks>* deadlines,
     base::TimeTicks deadline) {
   if ((*run_count + 1) < max_idle_task_reposts) {
     idle_task_runner->PostIdleTask(
         FROM_HERE, base::Bind(&RepostingUpdateClockIdleTestTask,
                               base::Unretained(idle_task_runner), run_count,
                               clock, advance_time, deadlines));
   }
   deadlines->push_back(deadline);
   (*run_count)++;
-  clock->AdvanceNow(advance_time);
+  clock->Advance(advance_time);
 }
 
 void RepeatingTask(base::SingleThreadTaskRunner* task_runner,
                    int num_repeats,
                    base::TimeDelta delay) {
   if (num_repeats > 1) {
     task_runner->PostDelayedTask(
         FROM_HERE, base::Bind(&RepeatingTask, base::Unretained(task_runner),
                               num_repeats - 1, delay),
         delay);
   }
 }
 
-void UpdateClockIdleTestTask(scoped_refptr<cc::TestNowSource> clock,
+void UpdateClockIdleTestTask(base::SimpleTestTickClock* clock,
                              int* run_count,
                              base::TimeTicks set_time,
                              base::TimeTicks deadline) {
-  clock->SetNow(set_time);
+  clock->Advance(set_time - clock->NowTicks());
   (*run_count)++;
 }
 
-void UpdateClockToDeadlineIdleTestTask(scoped_refptr<cc::TestNowSource> clock,
+void UpdateClockToDeadlineIdleTestTask(base::SimpleTestTickClock* clock,
                                        int* run_count,
                                        base::TimeTicks deadline) {
   UpdateClockIdleTestTask(clock, run_count, deadline, deadline);
 }
 
 void EndIdlePeriodIdleTask(IdleHelper* idle_helper, base::TimeTicks deadline) {
   idle_helper->EndIdlePeriod();
 }
 
 scoped_refptr<NestableSingleThreadTaskRunner>
@@ skipping 31 matching lines @@
   MOCK_METHOD0(IsNotQuiescent, void());
   MOCK_METHOD0(OnIdlePeriodStarted, void());
   MOCK_METHOD0(OnIdlePeriodEnded, void());
 };
 
 class BaseIdleHelperTest : public testing::Test {
  public:
   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)),
+      : clock_(new base::SimpleTestTickClock()),
+        mock_task_runner_(
+            message_loop
+                ? nullptr
+                : new cc::OrderedSimpleTaskRunner(clock_.get(), 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_->Advance(base::TimeDelta::FromMicroseconds(5000));
     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 {}
 
   void SetUp() override {
     EXPECT_CALL(*idle_helper_, OnIdlePeriodStarted()).Times(AnyNumber());
     EXPECT_CALL(*idle_helper_, OnIdlePeriodEnded()).Times(AnyNumber());
     EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
         .Times(AnyNumber())
         .WillRepeatedly(Return(true));
@@ skipping 60 matching lines @@
 
   base::TimeTicks CurrentIdleTaskDeadline() {
     return idle_helper_->CurrentIdleTaskDeadline();
   }
 
   void CheckIdlePeriodStateIs(const char* expected) {
     EXPECT_STREQ(expected, IdleHelper::IdlePeriodStateToString(
                                idle_helper_->SchedulerIdlePeriodState()));
   }
 
-  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_;
 
   scoped_refptr<NestableSingleThreadTaskRunner> nestable_task_runner_;
   scoped_ptr<SchedulerHelper> scheduler_helper_;
   scoped_ptr<IdleHelperForTest> idle_helper_;
   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
 
@@ skipping 10 matching lines @@
     return scheduler_helper_->GetTaskQueueManagerForTesting();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IdleHelperTest);
 };
 
 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));
 
   RunUntilIdle();
   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);
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 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));
 
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 
   idle_helper_->StartIdlePeriod(
-      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   idle_helper_->EndIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 }
 
 TEST_F(IdleHelperTest, TestRepostingIdleTask) {
   base::TimeTicks actual_deadline;
   int run_count = 0;
 
   max_idle_task_reposts = 2;
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&RepostingIdleTestTask, idle_task_runner_,
                             &run_count, &actual_deadline));
   idle_helper_->StartIdlePeriod(
-      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 
   // Reposted tasks shouldn't run until next idle period.
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 
   idle_helper_->StartIdlePeriod(
-      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
 }
 
 TEST_F(IdleHelperTest, TestIdleTaskExceedsDeadline) {
   int run_count = 0;
 
   // Post two UpdateClockToDeadlineIdleTestTask tasks.
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
-      base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_, &run_count));
+      base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_.get(), &run_count));
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
-      base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_, &run_count));
+      base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_.get(), &run_count));
 
   idle_helper_->StartIdlePeriod(
-      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   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));
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   // Second task should be run on the next idle period.
   EXPECT_EQ(2, run_count);
 }
 
 TEST_F(IdleHelperTest, TestPostIdleTaskAfterWakeup) {
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   idle_task_runner_->PostIdleTaskAfterWakeup(
       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));
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   // Shouldn't run yet as no other task woke up the scheduler.
   EXPECT_EQ(0, run_count);
 
   // Must start a new idle period before idle task runs.
   idle_task_runner_->PostIdleTaskAfterWakeup(
       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));
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   // Another after wakeup idle task shouldn't wake the scheduler.
   EXPECT_EQ(0, run_count);
 
   default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
 
   RunUntilIdle();
   idle_helper_->StartIdlePeriod(
-      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   // Execution of default task queue task should trigger execution of idle task.
   EXPECT_EQ(2, run_count);
 }
 
 TEST_F(IdleHelperTest, TestPostIdleTaskAfterWakeupWhileAwake) {
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   idle_task_runner_->PostIdleTaskAfterWakeup(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
 
   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));
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   // Should run as the scheduler was already awakened by the normal task.
   EXPECT_EQ(1, run_count);
 }
 
 TEST_F(IdleHelperTest, TestPostIdleTaskWakesAfterWakeupIdleTask) {
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   idle_task_runner_->PostIdleTaskAfterWakeup(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   idle_task_runner_->PostIdleTask(
       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));
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   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));
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   // Normal idle task should wake up after-wakeup idle task.
   EXPECT_EQ(2, run_count);
 }
 
 class IdleHelperTestWithIdlePeriodObserver : public BaseIdleHelperTest {
  public:
   IdleHelperTestWithIdlePeriodObserver()
       : BaseIdleHelperTest(nullptr, base::TimeDelta()) {}
 
@@ skipping 18 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IdleHelperTestWithIdlePeriodObserver);
 };
 
 TEST_F(IdleHelperTestWithIdlePeriodObserver, TestEnterButNotExitIdlePeriod) {
   ExpectIdlePeriodStartsButNeverEnds();
 
   idle_helper_->StartIdlePeriod(
-      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
 }
 
 TEST_F(IdleHelperTestWithIdlePeriodObserver, TestEnterAndExitIdlePeriod) {
   BaseIdleHelperTest* fixture = this;
   ON_CALL(*idle_helper_, OnIdlePeriodStarted())
       .WillByDefault(
           Invoke([fixture]() { EXPECT_TRUE(fixture->IsInIdlePeriod()); }));
   ON_CALL(*idle_helper_, OnIdlePeriodEnded())
       .WillByDefault(
           Invoke([fixture]() { EXPECT_FALSE(fixture->IsInIdlePeriod()); }));
 
   ExpectIdlePeriodStartsAndEnds(Exactly(1));
 
   idle_helper_->StartIdlePeriod(
-      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-      clock_->Now() + base::TimeDelta::FromMilliseconds(10));
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   idle_helper_->EndIdlePeriod();
 }
 
 class IdleHelperWithMessageLoopTest : public BaseIdleHelperTest {
  public:
   IdleHelperWithMessageLoopTest()
       : BaseIdleHelperTest(new base::MessageLoop(), base::TimeDelta()) {}
   ~IdleHelperWithMessageLoopTest() override {}
 
   void PostFromNestedRunloop(std::vector<
       std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>>* tasks) {
     base::MessageLoop::ScopedNestableTaskAllower allow(message_loop_.get());
     for (std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>& pair : *tasks) {
       if (pair.second) {
         idle_task_runner_->PostIdleTask(FROM_HERE, pair.first);
       } else {
         idle_task_runner_->PostNonNestableIdleTask(FROM_HERE, pair.first);
       }
     }
     idle_helper_->StartIdlePeriod(
-        IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
-        clock_->Now() + base::TimeDelta::FromMilliseconds(10));
+        IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+        clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
     message_loop_->RunUntilIdle();
   }
 
   void SetUp() override {
     EXPECT_CALL(*idle_helper_, OnIdlePeriodStarted()).Times(AnyNumber());
     EXPECT_CALL(*idle_helper_, OnIdlePeriodEnded()).Times(AnyNumber());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IdleHelperWithMessageLoopTest);
@@ skipping 19 matching lines @@
   tasks_to_post_from_nested_loop.push_back(std::make_pair(
       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("5")), true));
 
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IdleHelperWithMessageLoopTest::PostFromNestedRunloop,
                  base::Unretained(this),
                  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));
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   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"),
                                           std::string("4"), std::string("5"),
                                           std::string("3")));
 }
 
 TEST_F(IdleHelperTestWithIdlePeriodObserver, 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;
 
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
       .Times(1)
       .WillRepeatedly(Return(true));
   ExpectIdlePeriodStartsButNeverEnds();
 
   RunUntilIdle();
   EXPECT_EQ(0, run_count);  // Shouldn't run yet as no idle period.
 
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);  // Should have run in a long idle time.
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 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;
 
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
                                         pending_task_delay);
 
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);  // Should have run in a long idle time.
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 TEST_F(IdleHelperTest, TestLongIdlePeriodWithLatePendingDelayedTask) {
   base::TimeDelta pending_task_delay = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
                                         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.
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   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);
 }
 
 TEST_F(IdleHelperTestWithIdlePeriodObserver, TestLongIdlePeriodRepeating) {
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
   std::vector<base::TimeTicks> actual_deadlines;
   int run_count = 0;
 
   EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
       .Times(4)
       .WillRepeatedly(Return(true));
   ExpectIdlePeriodStartsAndEnds(AtLeast(2));
 
   max_idle_task_reposts = 3;
-  base::TimeTicks clock_before(clock_->Now());
+  base::TimeTicks clock_before(clock_->NowTicks());
   base::TimeDelta idle_task_runtime(base::TimeDelta::FromMilliseconds(10));
   idle_task_runner_->PostIdleTask(
-      FROM_HERE,
-      base::Bind(&RepostingUpdateClockIdleTestTask, idle_task_runner_,
-                 &run_count, clock_, idle_task_runtime, &actual_deadlines));
+      FROM_HERE, base::Bind(&RepostingUpdateClockIdleTestTask,
+                            idle_task_runner_, &run_count, clock_.get(),
+                            idle_task_runtime, &actual_deadlines));
 
   // Check each idle task runs in their own idle period.
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(3, run_count);
   EXPECT_THAT(
       actual_deadlines,
       testing::ElementsAre(
           clock_before + maximum_idle_period_duration(),
           clock_before + idle_task_runtime + maximum_idle_period_duration(),
           clock_before + (2 * idle_task_runtime) +
               maximum_idle_period_duration()));
 
   max_idle_task_reposts = 5;
   idle_task_runner_->PostIdleTask(
-      FROM_HERE,
-      base::Bind(&RepostingUpdateClockIdleTestTask, idle_task_runner_,
-                 &run_count, clock_, idle_task_runtime, &actual_deadlines));
+      FROM_HERE, base::Bind(&RepostingUpdateClockIdleTestTask,
+                            idle_task_runner_, &run_count, clock_.get(),
+                            idle_task_runtime, &actual_deadlines));
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
       base::Bind(&EndIdlePeriodIdleTask, base::Unretained(idle_helper_.get())));
 
   // Ensure that reposting tasks stop after EndIdlePeriod is called.
   RunUntilIdle();
   EXPECT_EQ(4, run_count);
 }
 
 TEST_F(IdleHelperTest, TestLongIdlePeriodDoesNotWakeScheduler) {
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   // Start a long idle period and get the time it should end.
   idle_helper_->EnableLongIdlePeriod();
   // The scheduler should not run the enable_next_long_idle_period task if
   // there are no idle tasks and no other task woke up the scheduler, thus
   // the idle period deadline shouldn't update at the end of the current long
   // idle period.
   base::TimeTicks idle_period_deadline = CurrentIdleTaskDeadline();
-  clock_->AdvanceNow(maximum_idle_period_duration());
+  clock_->Advance(maximum_idle_period_duration());
   RunUntilIdle();
 
   base::TimeTicks new_idle_period_deadline = CurrentIdleTaskDeadline();
   EXPECT_EQ(idle_period_deadline, new_idle_period_deadline);
 
   // Posting a after-wakeup idle task also shouldn't wake the scheduler or
   // initiate the next long idle period.
   idle_task_runner_->PostIdleTaskAfterWakeup(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   RunUntilIdle();
   new_idle_period_deadline = CurrentIdleTaskDeadline();
   EXPECT_EQ(idle_period_deadline, new_idle_period_deadline);
   EXPECT_EQ(0, run_count);
 
   // Running a normal task should initiate a new long idle period though.
   default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
   RunUntilIdle();
   new_idle_period_deadline = CurrentIdleTaskDeadline();
   EXPECT_EQ(idle_period_deadline + maximum_idle_period_duration(),
             new_idle_period_deadline);
 
   EXPECT_EQ(1, run_count);
 }
 
 TEST_F(IdleHelperTestWithIdlePeriodObserver,
        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;
 
   ON_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _))
       .WillByDefault(Invoke(
           [delay, delayOver](base::TimeTicks now,
                              base::TimeDelta* next_long_idle_period_delay_out) {
             if (now >= delayOver)
               return true;
             *next_long_idle_period_delay_out = delay;
             return false;
           }));
 
   EXPECT_CALL(*idle_helper_, CanEnterLongIdlePeriod(_, _)).Times(2);
   EXPECT_CALL(*idle_helper_, OnIdlePeriodStarted()).Times(AnyNumber());
 
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   // Make sure Idle tasks don't run until the delay has occurred.
   idle_helper_->EnableLongIdlePeriod();
   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);
 }
 
 TEST_F(IdleHelperTest, TestLongIdlePeriodImmediatelyRestartsIfMaxDeadline) {
   std::vector<base::TimeTicks> actual_deadlines;
   int run_count = 0;
 
-  base::TimeTicks clock_before(clock_->Now());
+  base::TimeTicks clock_before(clock_->NowTicks());
   base::TimeDelta idle_task_runtime(base::TimeDelta::FromMilliseconds(10));
 
   // The second idle period should happen immediately after the first the
   // they have max deadlines.
   max_idle_task_reposts = 2;
   idle_task_runner_->PostIdleTask(
-      FROM_HERE,
-      base::Bind(&RepostingUpdateClockIdleTestTask, idle_task_runner_,
-                 &run_count, clock_, idle_task_runtime, &actual_deadlines));
+      FROM_HERE, base::Bind(&RepostingUpdateClockIdleTestTask,
+                            idle_task_runner_, &run_count, clock_.get(),
+                            idle_task_runtime, &actual_deadlines));
 
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
   EXPECT_THAT(
       actual_deadlines,
       testing::ElementsAre(
           clock_before + maximum_idle_period_duration(),
           clock_before + idle_task_runtime + maximum_idle_period_duration()));
 }
 
 TEST_F(IdleHelperTest, TestLongIdlePeriodRestartWaitsIfNotMaxDeadline) {
   base::TimeTicks actual_deadline;
   int run_count = 0;
 
   base::TimeDelta pending_task_delay(base::TimeDelta::FromMilliseconds(20));
   base::TimeDelta idle_task_duration(base::TimeDelta::FromMilliseconds(10));
-  base::TimeTicks expected_deadline(clock_->Now() + pending_task_delay +
+  base::TimeTicks expected_deadline(clock_->NowTicks() + pending_task_delay +
                                     maximum_idle_period_duration() +
                                     retry_enable_long_idle_period_delay());
 
   // Post delayed task to ensure idle period doesn't have a max deadline.
   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
                                         pending_task_delay);
 
   max_idle_task_reposts = 2;
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&RepostingIdleTestTask, idle_task_runner_,
                             &run_count, &actual_deadline));
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
-  clock_->AdvanceNow(idle_task_duration);
+  clock_->Advance(idle_task_duration);
 
   // Next idle period shouldn't happen until the pending task has been run.
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 
   // Once the pending task is run the new idle period should start.
-  clock_->AdvanceNow(pending_task_delay - idle_task_duration);
+  clock_->Advance(pending_task_delay - idle_task_duration);
   RunUntilIdle();
   // Since the idle period tried to start before the pending task ran we have to
   // wait for the idle helper to retry starting the long idle period.
-  clock_->AdvanceNow(retry_enable_long_idle_period_delay());
+  clock_->Advance(retry_enable_long_idle_period_delay());
   RunUntilIdle();
 
   EXPECT_EQ(2, run_count);
   EXPECT_EQ(expected_deadline, actual_deadline);
 }
 
 TEST_F(IdleHelperTest, TestLongIdlePeriodPaused) {
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
   std::vector<base::TimeTicks> actual_deadlines;
   int run_count = 0;
 
   // If there are no idle tasks posted we should start in the paused state.
   idle_helper_->EnableLongIdlePeriod();
   CheckIdlePeriodStateIs("in_long_idle_period_paused");
   // There shouldn't be any delayed tasks posted by the idle helper when paused.
   EXPECT_EQ(base::TimeTicks(),
             scheduler_helper_->NextPendingDelayedTaskRunTime());
 
   // Posting a task should transition us to the an active state.
   max_idle_task_reposts = 2;
-  base::TimeTicks clock_before(clock_->Now());
+  base::TimeTicks clock_before(clock_->NowTicks());
   base::TimeDelta idle_task_runtime(base::TimeDelta::FromMilliseconds(10));
   idle_task_runner_->PostIdleTask(
-      FROM_HERE,
-      base::Bind(&RepostingUpdateClockIdleTestTask, idle_task_runner_,
-                 &run_count, clock_, idle_task_runtime, &actual_deadlines));
+      FROM_HERE, base::Bind(&RepostingUpdateClockIdleTestTask,
+                            idle_task_runner_, &run_count, clock_.get(),
+                            idle_task_runtime, &actual_deadlines));
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
   EXPECT_THAT(
       actual_deadlines,
       testing::ElementsAre(
           clock_before + maximum_idle_period_duration(),
           clock_before + idle_task_runtime + maximum_idle_period_duration()));
 
   // Once all task have been run we should go back to the paused state.
   CheckIdlePeriodStateIs("in_long_idle_period_paused");
@@ skipping 34 matching lines @@
 
   // Should return false if not in an idle period.
   EXPECT_FALSE(idle_helper_->CanExceedIdleDeadlineIfRequired());
 
   // Should return false for short idle periods.
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
       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));
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
   EXPECT_FALSE(can_exceed_idle_deadline);
 
   // Should return false for a long idle period which is shortened due to a
   // pending delayed task.
   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
                                         base::TimeDelta::FromMilliseconds(10));
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
       base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, idle_helper_.get(),
                  &can_exceed_idle_deadline, &run_count));
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
   EXPECT_FALSE(can_exceed_idle_deadline);
 
   // 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(),
                  &can_exceed_idle_deadline, &run_count));
   RunUntilIdle();
   EXPECT_EQ(3, run_count);
   EXPECT_TRUE(can_exceed_idle_deadline);
 }
 
 class IdleHelperWithQuiescencePeriodTest : public BaseIdleHelperTest {
@@ skipping 94 matching lines @@
   // Run a repeating task so we're deemed to be busy for the next 400ms.
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RepeatingTask, base::Unretained(default_task_runner_.get()),
                  10, base::TimeDelta::FromMilliseconds(40)));
 
   int run_count = 0;
   // 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));
 
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 TEST_F(IdleHelperWithQuiescencePeriodTest,
        QuescienceCheckedForAfterLongIdlePeriodEnds) {
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   idle_task_runner_->PostIdleTask(FROM_HERE, base::Bind(&NullIdleTask));
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
 
   // Post a normal task to make the scheduler non-quiescent.
   default_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
   RunUntilIdle();
 
   // Post an idle task. The idle task won't run initially because the system is
   // not judged to be quiescent, but should be run after the quiescence delay.
   int run_count = 0;
   base::TimeTicks deadline_in_task;
   base::TimeTicks expected_deadline =
-      clock_->Now() +
+      clock_->NowTicks() +
       base::TimeDelta::FromMilliseconds(kQuiescenceDelayMs + kLongIdlePeriodMs);
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
 
   EXPECT_EQ(1, run_count);
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 TEST_F(IdleHelperTest, NoShortIdlePeriodWhenDeadlineTooClose) {
   int run_count = 0;
   base::TimeTicks deadline_in_task;
 
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   base::TimeDelta half_a_ms(base::TimeDelta::FromMicroseconds(50));
   base::TimeTicks less_than_min_deadline(
-      clock_->Now() + minimum_idle_period_duration() - half_a_ms);
+      clock_->NowTicks() + minimum_idle_period_duration() - half_a_ms);
   base::TimeTicks more_than_min_deadline(
-      clock_->Now() + minimum_idle_period_duration() + half_a_ms);
+      clock_->NowTicks() + minimum_idle_period_duration() + half_a_ms);
 
   idle_helper_->StartIdlePeriod(
-      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
       less_than_min_deadline);
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 
   idle_helper_->StartIdlePeriod(
-      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->Now(),
+      IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
       more_than_min_deadline);
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 }
 
 TEST_F(IdleHelperTest, NoLongIdlePeriodWhenDeadlineTooClose) {
   int run_count = 0;
   base::TimeTicks deadline_in_task;
 
   base::TimeDelta half_a_ms(base::TimeDelta::FromMicroseconds(50));
   base::TimeDelta less_than_min_deadline_duration(
       minimum_idle_period_duration() - half_a_ms);
   base::TimeDelta more_than_min_deadline_duration(
       minimum_idle_period_duration() + half_a_ms);
 
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
                                         less_than_min_deadline_duration);
 
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 
   idle_helper_->EndIdlePeriod();
-  clock_->AdvanceNow(maximum_idle_period_duration());
+  clock_->Advance(maximum_idle_period_duration());
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 
   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
                                         more_than_min_deadline_duration);
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 }
 
 }  // namespace scheduler