Replaced TestNowSource with SimpleTestTickClock.

components/scheduler/renderer/renderer_scheduler_impl_unittest.cc

 // Copyright 2014 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/renderer/renderer_scheduler_impl.h"
 
 #include "base/callback.h"
+#include "base/test/simple_test_tick_clock.h"
 #include "cc/output/begin_frame_args.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_message_loop_delegate.h"
 #include "components/scheduler/child/test_time_source.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace scheduler {
 
 namespace {
 class FakeInputEvent : public blink::WebInputEvent {
@@ skipping 51 matching lines @@
                            base::TimeTicks deadline) {
   if ((*run_count + 1) < max_idle_task_reposts) {
     idle_task_runner->PostIdleTask(
         FROM_HERE, base::Bind(&RepostingIdleTestTask,
                               base::Unretained(idle_task_runner), run_count));
   }
   (*run_count)++;
 }
 
 void UpdateClockToDeadlineIdleTestTask(
-    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
   // post a normal task here to ensure it runs before the next idle task.
   task_runner->PostTask(FROM_HERE, base::Bind(NullTask));
   (*run_count)++;
 }
 
 void PostingYieldingTestTask(RendererSchedulerImpl* scheduler,
                              base::SingleThreadTaskRunner* task_runner,
@@ skipping 19 matching lines @@
         FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
   }
   *is_anticipated_after = scheduler->IsHighPriorityWorkAnticipated();
 }
 };  // namespace
 
 class RendererSchedulerImplTest : public testing::Test {
  public:
   using Policy = RendererSchedulerImpl::Policy;
 
-  RendererSchedulerImplTest()
-      : clock_(cc::TestNowSource::Create(5000)),
-        mock_task_runner_(new cc::OrderedSimpleTaskRunner(clock_, false)),
-        nestable_task_runner_(
-            NestableTaskRunnerForTest::Create(mock_task_runner_)),
-        scheduler_(new RendererSchedulerImpl(nestable_task_runner_)),
-        default_task_runner_(scheduler_->DefaultTaskRunner()),
-        compositor_task_runner_(scheduler_->CompositorTaskRunner()),
-        loading_task_runner_(scheduler_->LoadingTaskRunner()),
-        idle_task_runner_(scheduler_->IdleTaskRunner()),
-        timer_task_runner_(scheduler_->TimerTaskRunner()) {
+  RendererSchedulerImplTest() : clock_(new base::SimpleTestTickClock()) {
+    clock_->Advance(base::TimeDelta::FromInternalValue(5000));
+    mock_task_runner_ = new cc::OrderedSimpleTaskRunner(clock_.get(), false);
+    nestable_task_runner_ =
+        NestableTaskRunnerForTest::Create(mock_task_runner_);
+    scheduler_ =
+        make_scoped_ptr(new RendererSchedulerImpl(nestable_task_runner_));
+    default_task_runner_ = scheduler_->DefaultTaskRunner();
+    compositor_task_runner_ = scheduler_->CompositorTaskRunner();
+    loading_task_runner_ = scheduler_->LoadingTaskRunner();
+    idle_task_runner_ = scheduler_->IdleTaskRunner();
+    timer_task_runner_ = scheduler_->TimerTaskRunner();
     scheduler_->GetSchedulerHelperForTesting()->SetTimeSourceForTesting(
-        make_scoped_ptr(new TestTimeSource(clock_)));
+        make_scoped_ptr(new TestTimeSource(clock_.get())));
     scheduler_->GetSchedulerHelperForTesting()
         ->GetTaskQueueManagerForTesting()
-        ->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock_)));
+        ->SetTimeSourceForTesting(
+            make_scoped_ptr(new TestTimeSource(clock_.get())));
   }
 
   RendererSchedulerImplTest(base::MessageLoop* message_loop)
-      : clock_(cc::TestNowSource::Create(5000)),
+      : clock_(new base::SimpleTestTickClock()),
         message_loop_(message_loop),
         nestable_task_runner_(
             SchedulerMessageLoopDelegate::Create(message_loop)),
         scheduler_(new RendererSchedulerImpl(nestable_task_runner_)),
         default_task_runner_(scheduler_->DefaultTaskRunner()),
         compositor_task_runner_(scheduler_->CompositorTaskRunner()),
         loading_task_runner_(scheduler_->LoadingTaskRunner()),
         idle_task_runner_(scheduler_->IdleTaskRunner()),
         timer_task_runner_(scheduler_->TimerTaskRunner()) {
+    clock_->Advance(base::TimeDelta::FromInternalValue(5000));
     scheduler_->GetSchedulerHelperForTesting()->SetTimeSourceForTesting(
-        make_scoped_ptr(new TestTimeSource(clock_)));
+        make_scoped_ptr(new TestTimeSource(clock_.get())));
     scheduler_->GetSchedulerHelperForTesting()
         ->GetTaskQueueManagerForTesting()
-        ->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock_)));
+        ->SetTimeSourceForTesting(
+            make_scoped_ptr(new TestTimeSource(clock_.get())));
   }
   ~RendererSchedulerImplTest() override {}
 
   void TearDown() override {
     DCHECK(!mock_task_runner_.get() || !message_loop_.get());
     if (mock_task_runner_.get()) {
       // Check that all tests stop posting tasks.
       mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
       while (mock_task_runner_->RunUntilIdle()) {
       }
     } else {
       message_loop_->RunUntilIdle();
     }
   }
 
   void RunUntilIdle() {
     // Only one of mock_task_runner_ or message_loop_ should be set.
     DCHECK(!mock_task_runner_.get() || !message_loop_.get());
     if (mock_task_runner_.get())
       mock_task_runner_->RunUntilIdle();
     else
       message_loop_->RunUntilIdle();
   }
 
   void DoMainFrame() {
     scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
-        BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
+        BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
         base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
     scheduler_->DidCommitFrameToCompositor();
   }
 
   void EnableIdleTasks() { DoMainFrame(); }
 
   Policy CurrentPolicy() { return scheduler_->current_policy_; }
 
   void EnsureUrgentPolicyUpdatePostedOnMainThread() {
     base::AutoLock lock(scheduler_->incoming_signals_lock_);
     scheduler_->EnsureUrgentPolicyUpdatePostedOnMainThread(FROM_HERE);
   }
 
   void ScheduleDelayedPolicyUpdate(base::TimeDelta delay) {
     scheduler_->delayed_update_policy_runner_.SetDeadline(FROM_HERE, delay,
-                                                          clock_->Now());
+                                                          clock_->NowTicks());
   }
 
   // Helper for posting several tasks of specific types. |task_descriptor| is a
   // string with space delimited task identifiers. The first letter of each
   // task identifier specifies the task type:
   // - 'D': Default task
   // - 'C': Compositor task
   // - 'L': Loading task
   // - 'I': Idle task
   // - 'T': Timer task
@@ skipping 71 matching lines @@
         &RendererSchedulerImpl::PolicyToString);
   }
 
   static void CheckAllInputStreamStateToString() {
     CallForEachEnumValue<RendererSchedulerImpl::InputStreamState>(
         RendererSchedulerImpl::InputStreamState::FIRST_INPUT_STREAM_STATE,
         RendererSchedulerImpl::InputStreamState::INPUT_STREAM_STATE_COUNT,
         &RendererSchedulerImpl::InputStreamStateToString);
   }
 
-  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<RendererSchedulerImpl> scheduler_;
   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> loading_task_runner_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
@@ skipping 27 matching lines @@
       FROM_HERE, base::Bind(AppendToVectorReentrantTask, default_task_runner_,
                             &run_order, &count, 5));
   RunUntilIdle();
 
   EXPECT_THAT(run_order, testing::ElementsAre(0, 1, 2, 3, 4));
 }
 
 TEST_F(RendererSchedulerImplTest, 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);  // Shouldn't run yet as no WillBeginFrame.
 
   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
-      BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
+      BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
       base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
   RunUntilIdle();
   EXPECT_EQ(0, run_count);  // Shouldn't run as no DidCommitFrameToCompositor.
 
-  clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(1200));
+  clock_->Advance(base::TimeDelta::FromMilliseconds(1200));
   scheduler_->DidCommitFrameToCompositor();
   RunUntilIdle();
   EXPECT_EQ(0, run_count);  // We missed the deadline.
 
   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
-      BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
+      BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
       base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
-  clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(800));
+  clock_->Advance(base::TimeDelta::FromMilliseconds(800));
   scheduler_->DidCommitFrameToCompositor();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 TEST_F(RendererSchedulerImplTest, TestRepostingIdleTask) {
   int run_count = 0;
 
   max_idle_task_reposts = 2;
@@ skipping 12 matching lines @@
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
 }
 
 TEST_F(RendererSchedulerImplTest, TestIdleTaskExceedsDeadline) {
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
   int run_count = 0;
 
   // 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));
 
   EnableIdleTasks();
   RunUntilIdle();
   // Only the first idle task should execute since it's used up the deadline.
   EXPECT_EQ(1, run_count);
 
   EnableIdleTasks();
   RunUntilIdle();
   // Second task should be run on the next idle period.
@@ skipping 64 matching lines @@
 
 TEST_F(RendererSchedulerImplTest, TestDelayedEndIdlePeriodCanceled) {
   int run_count = 0;
 
   base::TimeTicks deadline_in_task;
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   // Trigger the beginning of an idle period for 1000ms.
   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
-      BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
+      BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
       base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
   DoMainFrame();
 
   // End the idle period early (after 500ms), and send a WillBeginFrame which
   // specifies that the next idle period should end 1000ms from now.
-  clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(500));
+  clock_->Advance(base::TimeDelta::FromMilliseconds(500));
   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
-      BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
+      BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
       base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
 
   RunUntilIdle();
   EXPECT_EQ(0, run_count);  // Not currently in an idle period.
 
   // Trigger the start of the idle period before the task to end the previous
   // idle period has been triggered.
-  clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(400));
+  clock_->Advance(base::TimeDelta::FromMilliseconds(400));
   scheduler_->DidCommitFrameToCompositor();
 
   // Post a task which simulates running until after the previous end idle
   // period delayed task was scheduled for
   scheduler_->DefaultTaskRunner()->PostTask(FROM_HERE, base::Bind(NullTask));
-  clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(300));
+  clock_->Advance(base::TimeDelta::FromMilliseconds(300));
 
   RunUntilIdle();
   EXPECT_EQ(1, run_count);  // We should still be in the new idle period.
 }
 
 TEST_F(RendererSchedulerImplTest, TestDefaultPolicy) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2");
 
   EnableIdleTasks();
@@ skipping 153 matching lines @@
 
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
   DoMainFrame();
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("C1"), std::string("C2"),
                                    std::string("D1"), std::string("D2")));
 
   run_order.clear();
-  clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(1000));
+  clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
   PostTestTasks(&run_order, "D1 C1 D2 C2");
 
   // Compositor policy mode should have ended now that the clock has advanced.
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("D1"), std::string("C1"),
                                    std::string("D2"), std::string("C2")));
 }
 
 TEST_F(RendererSchedulerImplTest, TestTouchstartPolicyEndsAfterTimeout) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "L1 D1 C1 D2 C2");
 
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchStart));
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("C1"), std::string("C2"),
                                    std::string("D1"), std::string("D2")));
 
   run_order.clear();
-  clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(1000));
+  clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
 
   // Don't post any compositor tasks to simulate a very long running event
   // handler.
   PostTestTasks(&run_order, "D1 D2");
 
   // Touchstart policy mode should have ended now that the clock has advanced.
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("L1"), std::string("D1"),
                                    std::string("D2")));
@@ skipping 48 matching lines @@
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AnticipationTestTask, scheduler_.get(), simulate_input,
                  &is_anticipated_before, &is_anticipated_after));
   RunUntilIdle();
   // When input is received, the scheduler should indicate that high-priority
   // work is anticipated.
   EXPECT_FALSE(is_anticipated_before);
   EXPECT_TRUE(is_anticipated_after);
 
-  clock_->AdvanceNow(priority_escalation_after_input_duration() * 2);
+  clock_->Advance(priority_escalation_after_input_duration() * 2);
   simulate_input = false;
   default_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AnticipationTestTask, scheduler_.get(), simulate_input,
                  &is_anticipated_before, &is_anticipated_after));
   RunUntilIdle();
   // Without additional input, the scheduler should indicate that high-priority
   // work is no longer anticipated.
   EXPECT_FALSE(is_anticipated_before);
   EXPECT_FALSE(is_anticipated_after);
@@ skipping 43 matching lines @@
   EXPECT_EQ(Policy::NORMAL, CurrentPolicy());
 
   // An input event should bump us into input priority.
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
   RunUntilIdle();
   EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());
 
   // Simulate the input event being queued for a very long time. The compositor
   // task we post here represents the enqueued input task.
-  clock_->AdvanceNow(priority_escalation_after_input_duration() * 2);
+  clock_->Advance(priority_escalation_after_input_duration() * 2);
   compositor_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
   RunUntilIdle();
 
   // Even though we exceeded the input priority escalation period, we should
   // still be in compositor priority since the input remains queued.
   EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());
 
   // Simulate the input event triggering a composition. This should start the
   // countdown for going back into normal policy.
   DoMainFrame();
   RunUntilIdle();
   EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());
 
   // After the escalation period ends we should go back into normal mode.
-  clock_->AdvanceNow(priority_escalation_after_input_duration() * 2);
+  clock_->Advance(priority_escalation_after_input_duration() * 2);
   RunUntilIdle();
   EXPECT_EQ(Policy::NORMAL, CurrentPolicy());
 }
 
 TEST_F(RendererSchedulerImplTest, SlowNoOpInputEvent) {
   EXPECT_EQ(Policy::NORMAL, CurrentPolicy());
 
   // An input event should bump us into input priority.
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
   RunUntilIdle();
   EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());
 
   // Simulate the input event being queued for a very long time. The compositor
   // task we post here represents the enqueued input task.
-  clock_->AdvanceNow(priority_escalation_after_input_duration() * 2);
+  clock_->Advance(priority_escalation_after_input_duration() * 2);
   compositor_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
   RunUntilIdle();
 
   // Even though we exceeded the input priority escalation period, we should
   // still be in compositor priority since the input remains queued.
   EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());
 
   // If we let the compositor queue drain, we should fall out of input
   // priority.
-  clock_->AdvanceNow(priority_escalation_after_input_duration() * 2);
+  clock_->Advance(priority_escalation_after_input_duration() * 2);
   RunUntilIdle();
   EXPECT_EQ(Policy::NORMAL, CurrentPolicy());
 }
 
 TEST_F(RendererSchedulerImplTest, NoOpInputEvent) {
   EXPECT_EQ(Policy::NORMAL, CurrentPolicy());
 
   // An input event should bump us into input priority.
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
   RunUntilIdle();
   EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());
 
   // If nothing else happens after this, we should drop out of compositor
   // priority after the escalation period ends and stop polling.
-  clock_->AdvanceNow(priority_escalation_after_input_duration() * 2);
+  clock_->Advance(priority_escalation_after_input_duration() * 2);
   RunUntilIdle();
   EXPECT_EQ(Policy::NORMAL, CurrentPolicy());
   EXPECT_FALSE(mock_task_runner_->HasPendingTasks());
 }
 
 TEST_F(RendererSchedulerImplTest, NoOpInputEventExtendsEscalationPeriod) {
   EXPECT_EQ(Policy::NORMAL, CurrentPolicy());
 
   // Simulate one handled input event.
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureScrollBegin));
   RunUntilIdle();
   DoMainFrame();
   EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());
 
   // Send a no-op input event in the middle of the escalation period.
-  clock_->AdvanceNow(priority_escalation_after_input_duration() / 2);
+  clock_->Advance(priority_escalation_after_input_duration() / 2);
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureScrollUpdate));
   RunUntilIdle();
   EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());
 
   // The escalation period should have been extended by the new input event.
-  clock_->AdvanceNow(3 * priority_escalation_after_input_duration() / 4);
+  clock_->Advance(3 * priority_escalation_after_input_duration() / 4);
   RunUntilIdle();
   EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());
 
-  clock_->AdvanceNow(priority_escalation_after_input_duration() / 2);
+  clock_->Advance(priority_escalation_after_input_duration() / 2);
   RunUntilIdle();
   EXPECT_EQ(Policy::NORMAL, CurrentPolicy());
 }
 
 TEST_F(RendererSchedulerImplTest, InputArrivesAfterBeginFrame) {
   EXPECT_EQ(Policy::NORMAL, CurrentPolicy());
 
   cc::BeginFrameArgs args = cc::BeginFrameArgs::Create(
-      BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
+      BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
       base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL);
-  clock_->AdvanceNow(priority_escalation_after_input_duration() / 2);
+  clock_->Advance(priority_escalation_after_input_duration() / 2);
 
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureScrollBegin));
 
   // Simulate a BeginMainFrame task from the past.
-  clock_->AdvanceNow(2 * priority_escalation_after_input_duration());
+  clock_->Advance(2 * priority_escalation_after_input_duration());
   scheduler_->WillBeginFrame(args);
   scheduler_->DidCommitFrameToCompositor();
 
   // This task represents the queued-up input event.
   compositor_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
 
   // Should remain in input priority policy since the input event hasn't been
   // processed yet.
-  clock_->AdvanceNow(2 * priority_escalation_after_input_duration());
+  clock_->Advance(2 * priority_escalation_after_input_duration());
   RunUntilIdle();
   EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());
 
   // Process the input event with a new BeginMainFrame.
   DoMainFrame();
-  clock_->AdvanceNow(2 * priority_escalation_after_input_duration());
+  clock_->Advance(2 * priority_escalation_after_input_duration());
   RunUntilIdle();
   EXPECT_EQ(Policy::NORMAL, CurrentPolicy());
 }
 
 class RendererSchedulerImplForTest : public RendererSchedulerImpl {
  public:
   RendererSchedulerImplForTest(
       scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner)
       : RendererSchedulerImpl(main_task_runner), update_policy_count_(0) {}
 
@@ skipping 18 matching lines @@
   RunUntilIdle();
 
   EXPECT_EQ(1, mock_scheduler->update_policy_count_);
 }
 
 TEST_F(RendererSchedulerImplTest, OnePendingDelayedAndOneUrgentUpdatePolicy) {
   RendererSchedulerImplForTest* mock_scheduler =
       new RendererSchedulerImplForTest(nestable_task_runner_);
   scheduler_.reset(mock_scheduler);
   scheduler_->GetSchedulerHelperForTesting()->SetTimeSourceForTesting(
-      make_scoped_ptr(new TestTimeSource(clock_)));
+      make_scoped_ptr(new TestTimeSource(clock_.get())));
   scheduler_->GetSchedulerHelperForTesting()
       ->GetTaskQueueManagerForTesting()
-      ->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock_)));
+      ->SetTimeSourceForTesting(
+          make_scoped_ptr(new TestTimeSource(clock_.get())));
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   ScheduleDelayedPolicyUpdate(base::TimeDelta::FromMilliseconds(1));
   EnsureUrgentPolicyUpdatePostedOnMainThread();
 
   RunUntilIdle();
 
   // We expect both the urgent and the delayed updates to run.
   EXPECT_EQ(2, mock_scheduler->update_policy_count_);
 }
 
 TEST_F(RendererSchedulerImplTest, OneUrgentAndOnePendingDelayedUpdatePolicy) {
   RendererSchedulerImplForTest* mock_scheduler =
       new RendererSchedulerImplForTest(nestable_task_runner_);
   scheduler_.reset(mock_scheduler);
   scheduler_->GetSchedulerHelperForTesting()->SetTimeSourceForTesting(
-      make_scoped_ptr(new TestTimeSource(clock_)));
+      make_scoped_ptr(new TestTimeSource(clock_.get())));
   scheduler_->GetSchedulerHelperForTesting()
       ->GetTaskQueueManagerForTesting()
-      ->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock_)));
+      ->SetTimeSourceForTesting(
+          make_scoped_ptr(new TestTimeSource(clock_.get())));
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   EnsureUrgentPolicyUpdatePostedOnMainThread();
   ScheduleDelayedPolicyUpdate(base::TimeDelta::FromMilliseconds(1));
 
   RunUntilIdle();
 
   // We expect both the urgent and the delayed updates to run.
   EXPECT_EQ(2, mock_scheduler->update_policy_count_);
 }
 
 TEST_F(RendererSchedulerImplTest, UpdatePolicyCountTriggeredByOneInputEvent) {
   RendererSchedulerImplForTest* mock_scheduler =
       new RendererSchedulerImplForTest(nestable_task_runner_);
   scheduler_.reset(mock_scheduler);
   scheduler_->GetSchedulerHelperForTesting()->SetTimeSourceForTesting(
-      make_scoped_ptr(new TestTimeSource(clock_)));
+      make_scoped_ptr(new TestTimeSource(clock_.get())));
   scheduler_->GetSchedulerHelperForTesting()
       ->GetTaskQueueManagerForTesting()
-      ->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock_)));
+      ->SetTimeSourceForTesting(
+          make_scoped_ptr(new TestTimeSource(clock_.get())));
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchStart));
 
   RunUntilIdle();
 
   // We expect an urgent policy update followed by a delayed one 100ms later.
   EXPECT_EQ(2, mock_scheduler->update_policy_count_);
 }
 
 TEST_F(RendererSchedulerImplTest, UpdatePolicyCountTriggeredByTwoInputEvents) {
   RendererSchedulerImplForTest* mock_scheduler =
       new RendererSchedulerImplForTest(nestable_task_runner_);
   scheduler_.reset(mock_scheduler);
   scheduler_->GetSchedulerHelperForTesting()->SetTimeSourceForTesting(
-      make_scoped_ptr(new TestTimeSource(clock_)));
+      make_scoped_ptr(new TestTimeSource(clock_.get())));
   scheduler_->GetSchedulerHelperForTesting()
       ->GetTaskQueueManagerForTesting()
-      ->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock_)));
+      ->SetTimeSourceForTesting(
+          make_scoped_ptr(new TestTimeSource(clock_.get())));
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchStart));
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchMove));
 
   RunUntilIdle();
 
   // We expect an urgent policy update followed by a delayed one 100ms later.
   EXPECT_EQ(2, mock_scheduler->update_policy_count_);
 }
 
 TEST_F(RendererSchedulerImplTest, EnsureUpdatePolicyNotTriggeredTooOften) {
   RendererSchedulerImplForTest* mock_scheduler =
       new RendererSchedulerImplForTest(nestable_task_runner_);
   scheduler_.reset(mock_scheduler);
   scheduler_->GetSchedulerHelperForTesting()->SetTimeSourceForTesting(
-      make_scoped_ptr(new TestTimeSource(clock_)));
+      make_scoped_ptr(new TestTimeSource(clock_.get())));
   scheduler_->GetSchedulerHelperForTesting()
       ->GetTaskQueueManagerForTesting()
-      ->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock_)));
+      ->SetTimeSourceForTesting(
+          make_scoped_ptr(new TestTimeSource(clock_.get())));
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchStart));
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchMove));
 
   // We expect the first call to IsHighPriorityWorkAnticipated to be called
   // after recieving an input event (but before the UpdateTask was processed) to
   // call UpdatePolicy.
@@ skipping 72 matching lines @@
   EnableIdleTasks();
   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(RendererSchedulerImplTest, 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));
 
   RunUntilIdle();
   EXPECT_EQ(0, run_count);  // Shouldn't run yet as no idle period.
 
   scheduler_->BeginFrameNotExpectedSoon();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);  // Should have run in a long idle time.
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 TEST_F(RendererSchedulerImplTest, 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);
 
   scheduler_->BeginFrameNotExpectedSoon();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);  // Should have run in a long idle time.
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 TEST_F(RendererSchedulerImplTest,
        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 BeginFrameNotExpectedSoon to initiate a long idle
   // period. 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));
   scheduler_->BeginFrameNotExpectedSoon();
   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(RendererSchedulerImplTest, TestLongIdlePeriodRepeating) {
   int run_count = 0;
 
   max_idle_task_reposts = 3;
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
       base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count));
 
   scheduler_->BeginFrameNotExpectedSoon();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);  // Should only run once per idle period.
 
   // 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 idle period with a
   // new BeginMainFrame and check idle task doesn't run.
-  clock_->AdvanceNow(maximum_idle_period_duration());
+  clock_->Advance(maximum_idle_period_duration());
   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
-      BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
+      BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
       base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
 }
 
 TEST_F(RendererSchedulerImplTest, TestLongIdlePeriodDoesNotWakeScheduler) {
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   // Start a long idle period and get the time it should end.
   scheduler_->BeginFrameNotExpectedSoon();
   // The scheduler should not run the initiate_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 =
       scheduler_->CurrentIdleTaskDeadlineForTesting();
-  clock_->AdvanceNow(maximum_idle_period_duration());
+  clock_->Advance(maximum_idle_period_duration());
   RunUntilIdle();
 
   base::TimeTicks new_idle_period_deadline =
       scheduler_->CurrentIdleTaskDeadlineForTesting();
   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));
@@ skipping 20 matching lines @@
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   // Observation of touchstart should defer the start of the long idle period.
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchStart));
   scheduler_->BeginFrameNotExpectedSoon();
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 
   // The long idle period should start after the touchstart policy has finished.
-  clock_->AdvanceNow(priority_escalation_after_input_duration());
+  clock_->Advance(priority_escalation_after_input_duration());
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 }
 
 void TestCanExceedIdleDeadlineIfRequiredTask(RendererScheduler* scheduler,
                                              bool* can_exceed_idle_deadline_out,
                                              int* run_count,
                                              base::TimeTicks deadline) {
   *can_exceed_idle_deadline_out = scheduler->CanExceedIdleDeadlineIfRequired();
   (*run_count)++;
@@ skipping 24 matching lines @@
       FROM_HERE,
       base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, scheduler_.get(),
                  &can_exceed_idle_deadline, &run_count));
   scheduler_->BeginFrameNotExpectedSoon();
   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, scheduler_.get(),
                  &can_exceed_idle_deadline, &run_count));
   RunUntilIdle();
   EXPECT_EQ(3, run_count);
   EXPECT_TRUE(can_exceed_idle_deadline);
 
   // Next long idle period will be for the maximum time, so
   // CanExceedIdleDeadlineIfRequired should return true.
   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
-      BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
+      BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
       base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
   EXPECT_FALSE(scheduler_->CanExceedIdleDeadlineIfRequired());
 }
 
 TEST_F(RendererSchedulerImplTest, TestRendererHiddenIdlePeriod) {
   int run_count = 0;
 
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
       base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count));
 
   // Renderer should start in visible state.
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 
   // When we hide the renderer it should start an idle period.
   scheduler_->OnRendererHidden();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 
   // 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 by amount of time by the maximum amount of time we execute
   // idle tasks when hidden (plus some slack) - idle period should have ended.
-  clock_->AdvanceNow(end_idle_when_hidden_delay() +
-                     base::TimeDelta::FromMilliseconds(10));
+  clock_->Advance(end_idle_when_hidden_delay() +
+                  base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
 }
 
 TEST_F(RendererSchedulerImplTest, TimerQueueEnabledByDefault) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "T1 T2");
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("T1"), std::string("T2")));
@@ skipping 43 matching lines @@
 
 TEST_F(RendererSchedulerImplTest, PolicyToString) {
   CheckAllTaskQueueIdToString();
 }
 
 TEST_F(RendererSchedulerImplTest, InputStreamStateToString) {
   CheckAllInputStreamStateToString();
 }
 
 }  // namespace scheduler