Remove dependency on cc::TestNowSource from scheduler code

content/renderer/scheduler/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 "content/renderer/scheduler/renderer_scheduler_impl.h"
 
 #include "base/callback.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/test/ordered_simple_task_runner.h"
+#include "cc/test/test_now_source.h"
 #include "content/child/scheduler/nestable_task_runner_for_test.h"
 #include "content/child/scheduler/scheduler_message_loop_delegate.h"
+#include "content/test/test_time_source.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 class FakeInputEvent : public blink::WebInputEvent {
  public:
   explicit FakeInputEvent(blink::WebInputEvent::Type event_type)
       : WebInputEvent(sizeof(FakeInputEvent)) {
@@ skipping 107 matching lines @@
       : 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()) {
-    scheduler_->SetTimeSourceForTesting(clock_);
+    scheduler_->SetTimeSourceForTesting(
+        make_scoped_ptr(new TestTimeSource(clock_)));
   }
 
   RendererSchedulerImplTest(base::MessageLoop* message_loop)
       : clock_(cc::TestNowSource::Create(5000)),
         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()) {
-    scheduler_->SetTimeSourceForTesting(clock_);
+    scheduler_->SetTimeSourceForTesting(
+        make_scoped_ptr(new TestTimeSource(clock_)));
   }
   ~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()) {
       }
@@ skipping 783 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_->SetTimeSourceForTesting(clock_);
+  scheduler_->SetTimeSourceForTesting(
+      make_scoped_ptr(new TestTimeSource(clock_)));
   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_->SetTimeSourceForTesting(clock_);
+  scheduler_->SetTimeSourceForTesting(
+      make_scoped_ptr(new TestTimeSource(clock_)));
   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_->SetTimeSourceForTesting(clock_);
+  scheduler_->SetTimeSourceForTesting(
+      make_scoped_ptr(new TestTimeSource(clock_)));
   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_->SetTimeSourceForTesting(clock_);
+  scheduler_->SetTimeSourceForTesting(
+      make_scoped_ptr(new TestTimeSource(clock_)));
   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_->SetTimeSourceForTesting(clock_);
+  scheduler_->SetTimeSourceForTesting(
+      make_scoped_ptr(new TestTimeSource(clock_)));
   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 354 matching lines @@
   RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
   scheduler_->ResumeTimerQueue();
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("T1"), std::string("T2")));
 }
 
 }  // namespace content