[Reland] Per WebViewScheduler virtual time

components/scheduler/renderer/web_view_scheduler_impl_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/renderer/web_view_scheduler_impl.h"
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "cc/test/ordered_simple_task_runner.h"
@@ skipping 140 matching lines @@
       1.0);
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
   EXPECT_EQ(1000, run_count1);
   EXPECT_EQ(1, run_count2);
 }
 
 namespace {
 class VirtualTimeRecorderTask : public blink::WebTaskRunner::Task {
  public:
-  VirtualTimeRecorderTask(RendererSchedulerImpl* scheduler,
+  VirtualTimeRecorderTask(base::SimpleTestTickClock* clock,
+                          blink::WebTaskRunner* web_task_runner,
                           std::vector<base::TimeTicks>* out_real_times,
                           std::vector<size_t>* out_virtual_times_ms)
-      : scheduler_(scheduler),
+      : clock_(clock),
+        web_task_runner_(web_task_runner),
         out_real_times_(out_real_times),
         out_virtual_times_ms_(out_virtual_times_ms) {}
 
   ~VirtualTimeRecorderTask() override {}
 
   void run() override {
-    out_real_times_->push_back(scheduler_->tick_clock()->NowTicks());
+    out_real_times_->push_back(clock_->NowTicks());
     out_virtual_times_ms_->push_back(
-        scheduler_->MonotonicallyIncreasingVirtualTimeSeconds() * 1000.0);
+        web_task_runner_->monotonicallyIncreasingVirtualTimeSeconds() * 1000.0);
   }
 
  private:
-  RendererSchedulerImpl* scheduler_;              // NOT OWNED
+  base::SimpleTestTickClock* clock_;              // NOT OWNED
+  blink::WebTaskRunner* web_task_runner_;         // NOT OWNED
   std::vector<base::TimeTicks>* out_real_times_;  // NOT OWNED
   std::vector<size_t>* out_virtual_times_ms_;     // NOT OWNED
 };
 }
 
 TEST_F(WebViewSchedulerImplTest, VirtualTime_TimerFastForwarding) {
   std::vector<base::TimeTicks> real_times;
   std::vector<size_t> virtual_times_ms;
   base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks();
   size_t initial_virtual_time_ms =
-      scheduler_->MonotonicallyIncreasingVirtualTimeSeconds() * 1000.0;
+      web_frame_scheduler_->timerTaskRunner()
+          ->monotonicallyIncreasingVirtualTimeSeconds() *
+      1000.0;
 
   web_view_scheduler_->enableVirtualTime();
 
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new VirtualTimeRecorderTask(scheduler_.get(), &real_times,
-                                  &virtual_times_ms),
+      new VirtualTimeRecorderTask(clock_.get(),
+                                  web_frame_scheduler_->timerTaskRunner(),
+                                  &real_times, &virtual_times_ms),
       2.0);
 
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new VirtualTimeRecorderTask(scheduler_.get(), &real_times,
-                                  &virtual_times_ms),
+      new VirtualTimeRecorderTask(clock_.get(),
+                                  web_frame_scheduler_->timerTaskRunner(),
+                                  &real_times, &virtual_times_ms),
       20.0);
 
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new VirtualTimeRecorderTask(scheduler_.get(), &real_times,
-                                  &virtual_times_ms),
+      new VirtualTimeRecorderTask(clock_.get(),
+                                  web_frame_scheduler_->timerTaskRunner(),
+                                  &real_times, &virtual_times_ms),
       200.0);
 
   mock_task_runner_->RunUntilIdle();
 
   EXPECT_THAT(real_times, ElementsAre(initial_real_time,
                                       initial_real_time, initial_real_time));
   EXPECT_THAT(virtual_times_ms,
               ElementsAre(initial_virtual_time_ms + 2,
                           initial_virtual_time_ms + 20,
                           initial_virtual_time_ms + 200));
 }
 
 TEST_F(WebViewSchedulerImplTest, VirtualTime_LoadingTaskFastForwarding) {
   std::vector<base::TimeTicks> real_times;
   std::vector<size_t> virtual_times_ms;
   base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks();
   size_t initial_virtual_time_ms =
-      scheduler_->MonotonicallyIncreasingVirtualTimeSeconds() * 1000.0;
+      web_frame_scheduler_->timerTaskRunner()
+          ->monotonicallyIncreasingVirtualTimeSeconds() *
+      1000.0;
 
   web_view_scheduler_->enableVirtualTime();
 
   web_frame_scheduler_->loadingTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new VirtualTimeRecorderTask(scheduler_.get(), &real_times,
-                                  &virtual_times_ms),
+      new VirtualTimeRecorderTask(clock_.get(),
+                                  web_frame_scheduler_->loadingTaskRunner(),
+                                  &real_times, &virtual_times_ms),
       2.0);
 
   web_frame_scheduler_->loadingTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new VirtualTimeRecorderTask(scheduler_.get(), &real_times,
-                                  &virtual_times_ms),
+      new VirtualTimeRecorderTask(clock_.get(),
+                                  web_frame_scheduler_->loadingTaskRunner(),
+                                  &real_times, &virtual_times_ms),
       20.0);
 
   web_frame_scheduler_->loadingTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new VirtualTimeRecorderTask(scheduler_.get(), &real_times,
-                                  &virtual_times_ms),
+      new VirtualTimeRecorderTask(clock_.get(),
+                                  web_frame_scheduler_->loadingTaskRunner(),
+                                  &real_times, &virtual_times_ms),
       200.0);
 
   mock_task_runner_->RunUntilIdle();
 
   EXPECT_THAT(real_times, ElementsAre(initial_real_time,
                                       initial_real_time, initial_real_time));
   EXPECT_THAT(virtual_times_ms,
               ElementsAre(initial_virtual_time_ms + 2,
                           initial_virtual_time_ms + 20,
                           initial_virtual_time_ms + 200));
 }
 
 TEST_F(WebViewSchedulerImplTest,
-       RepeatingTimer_PageInBackground_MeansNothingForFirtualTime) {
+       RepeatingTimer_PageInBackground_MeansNothingForVirtualTime) {
   web_view_scheduler_->enableVirtualTime();
   web_view_scheduler_->setPageVisible(false);
   base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks();
 
   int run_count = 0;
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
       new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count),
       1.0);
 
   mock_task_runner_->RunTasksWhile(mock_task_runner_->TaskRunCountBelow(2000));
+  // Virtual time means page visibility is ignored.
   EXPECT_EQ(1999, run_count);
 
   // The global tick clock has not moved, yet we ran a large number of "delayed"
   // tasks despite calling setPageVisible(false).
   EXPECT_EQ(initial_real_time, scheduler_->tick_clock()->NowTicks());
 }
 
 namespace {
 class RunOrderTask : public blink::WebTaskRunner::Task {
  public:
@@ skipping 175 matching lines @@
   // it will prevent further tasks from running (i.e. the RepeatingTask) by
   // deleting the WebFrameScheduler.
   timer_task_runner->postDelayedTask(BLINK_FROM_HERE, delete_frame_task,
                                      9990.0);
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(100));
   EXPECT_EQ(10, run_count);
 }
 
 }  // namespace scheduler