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"
 #include "components/scheduler/base/test_time_source.h"
-#include "components/scheduler/child/scheduler_task_runner_delegate_for_test.h"
-#include "components/scheduler/child/scheduler_task_runner_delegate_impl.h"
+#include "components/scheduler/child/scheduler_tqm_delegate_for_test.h"
+#include "components/scheduler/child/scheduler_tqm_delegate_impl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace scheduler {
 
 namespace {
 class FakeInputEvent : public blink::WebInputEvent {
  public:
   explicit FakeInputEvent(blink::WebInputEvent::Type event_type)
       : WebInputEvent(sizeof(FakeInputEvent)) {
@@ skipping 147 matching lines @@
 }
 
 };  // namespace
 
 class RendererSchedulerImplForTest : public RendererSchedulerImpl {
  public:
   using RendererSchedulerImpl::OnIdlePeriodEnded;
   using RendererSchedulerImpl::OnIdlePeriodStarted;
 
   RendererSchedulerImplForTest(
-      scoped_refptr<SchedulerTaskRunnerDelegate> main_task_runner)
+      scoped_refptr<SchedulerTqmDelegate> main_task_runner)
       : RendererSchedulerImpl(main_task_runner), 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");
@@ skipping 37 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_ = SchedulerTqmDelegateImpl::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_ = SchedulerTqmDelegateForTest::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 198 matching lines @@
         RendererSchedulerImpl::UseCase::FIRST_USE_CASE,
         RendererSchedulerImpl::UseCase::USE_CASE_COUNT,
         &RendererSchedulerImpl::UseCaseToString);
   }
 
   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<SchedulerTaskRunnerDelegate> main_task_runner_;
+  scoped_refptr<SchedulerTqmDelegate> main_task_runner_;
   scoped_ptr<RendererSchedulerImplForTest> 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_;
   scoped_refptr<base::SingleThreadTaskRunner> timer_task_runner_;
   bool simulate_timer_task_ran_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererSchedulerImplTest);
 };
@@ skipping 861 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_ = SchedulerTqmDelegateForTest::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 843 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