Adds a flag to support "Virtual Time" to the blink scheduler

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"
@@ skipping 161 matching lines @@
 
 };  // namespace
 
 class RendererSchedulerImplForTest : public RendererSchedulerImpl {
  public:
   using RendererSchedulerImpl::OnIdlePeriodEnded;
   using RendererSchedulerImpl::OnIdlePeriodStarted;
 
   RendererSchedulerImplForTest(
       scoped_refptr<SchedulerTaskRunnerDelegate> main_task_runner)
-      : RendererSchedulerImpl(main_task_runner), update_policy_count_(0) {}
+      : RendererSchedulerImpl(main_task_runner,
+                              RendererSchedulerImpl::TimeSource::NORMAL),
+        update_policy_count_(0) {}
 
   void UpdatePolicyLocked(UpdateType update_type) override {
     update_policy_count_++;
     RendererSchedulerImpl::UpdatePolicyLocked(update_type);
 
     std::string use_case =
         RendererScheduler::UseCaseToString(MainThreadOnly().current_use_case);
     if (MainThreadOnly().touchstart_expected_soon) {
       use_cases_.push_back(use_case + " scroll expected");
     } else {
@@ skipping 36 matching lines @@
 
   RendererSchedulerImplTest(base::MessageLoop* message_loop)
       : clock_(new base::SimpleTestTickClock()), message_loop_(message_loop) {
     clock_->Advance(base::TimeDelta::FromMicroseconds(5000));
   }
 
   ~RendererSchedulerImplTest() override {}
 
   void SetUp() override {
     if (message_loop_) {
-      main_task_runner_ =
-          SchedulerTaskRunnerDelegateImpl::Create(message_loop_.get());
+      main_task_runner_ = SchedulerTaskRunnerDelegateImpl::Create(
+          message_loop_.get(),
+          make_scoped_ptr(new TestTimeSource(clock_.get())));
     } else {
       mock_task_runner_ = make_scoped_refptr(
           new cc::OrderedSimpleTaskRunner(clock_.get(), false));
-      main_task_runner_ =
-          SchedulerTaskRunnerDelegateForTest::Create(mock_task_runner_);
+      main_task_runner_ = SchedulerTaskRunnerDelegateForTest::Create(
+          mock_task_runner_, make_scoped_ptr(new TestTimeSource(clock_.get())));
     }
     Initialize(
         make_scoped_ptr(new RendererSchedulerImplForTest(main_task_runner_)));
   }
 
   void Initialize(scoped_ptr<RendererSchedulerImplForTest> scheduler) {
     scheduler_ = scheduler.Pass();
     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_.get())));
-    scheduler_->GetSchedulerHelperForTesting()
-        ->GetTaskQueueManagerForTesting()
-        ->SetTimeSourceForTesting(
-            make_scoped_ptr(new TestTimeSource(clock_.get())));
-    scheduler_->GetLoadingTaskCostEstimatorForTesting()
-        ->SetTimeSourceForTesting(
-            make_scoped_ptr(new TestTimeSource(clock_.get())));
-    scheduler_->GetTimerTaskCostEstimatorForTesting()->SetTimeSourceForTesting(
-        make_scoped_ptr(new TestTimeSource(clock_.get())));
-    scheduler_->GetIdleTimeEstimatorForTesting()->SetTimeSourceForTesting(
-        make_scoped_ptr(new TestTimeSource(clock_.get())));
   }
 
   void TearDown() override {
     DCHECK(!mock_task_runner_.get() || !message_loop_.get());
     scheduler_->Shutdown();
     if (mock_task_runner_.get()) {
       // Check that all tests stop posting tasks.
       mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
       while (mock_task_runner_->RunUntilIdle()) {
       }
@@ skipping 1080 matching lines @@
   RunUntilIdle();
   EXPECT_EQ(UseCase::NONE, CurrentUseCase());
 }
 
 class RendererSchedulerImplWithMockSchedulerTest
     : public RendererSchedulerImplTest {
  public:
   void SetUp() override {
     mock_task_runner_ = make_scoped_refptr(
         new cc::OrderedSimpleTaskRunner(clock_.get(), false));
-    main_task_runner_ =
-        SchedulerTaskRunnerDelegateForTest::Create(mock_task_runner_);
+    main_task_runner_ = SchedulerTaskRunnerDelegateForTest::Create(
+        mock_task_runner_, make_scoped_ptr(new TestTimeSource(clock_.get())));
     mock_scheduler_ = new RendererSchedulerImplForTest(main_task_runner_);
     Initialize(make_scoped_ptr(mock_scheduler_));
   }
 
  protected:
   RendererSchedulerImplForTest* mock_scheduler_;
 };
 
 TEST_F(RendererSchedulerImplWithMockSchedulerTest,
        OnlyOnePendingUrgentPolicyUpdatey) {
@@ skipping 822 matching lines @@
     }
 
     base::TimeDelta time_till_next_frame =
         EstimatedNextFrameBegin() - clock_->NowTicks();
     if (time_till_next_frame > base::TimeDelta())
       clock_->Advance(time_till_next_frame);
   }
 }
 
 }  // namespace scheduler