Remove WebTaskRunner::MonotonicallyIncreasingVirtualTimeSeconds().

This patch removes a method from WebTaskRunner. At this point, WebTask-
Runner is functionally identical to base::SingleThreadTaskRunner, and
we can start working on the actual removal of WebTaskRunner.

WebViewSchedulerImplTest is also modified so it doesn't depend on the
removed function.

Bug: 794845
Change-Id: I2945c890e7e957f7187103f46f71a314c77c90fb
Reviewed-on: https://chromium-review.googlesource.com/888378Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Commit-Queue: Yuta Kitamura <yutak@chromium.org>
Cr-Commit-Position: refs/heads/master@{#532229}

third_party/WebKit/Source/platform/WebTaskRunner.h

@@ -70,12 +70,6 @@ class BLINK_PLATFORM_EXPORT WebTaskRunner
                                base::OnceClosure,
                                base::TimeDelta) = 0;
 
-  // Returns a microsecond resolution platform dependant time source.
-  // This may represent either the real time, or a virtual time depending on
-  // whether or not the WebTaskRunner is associated with a virtual time domain
-  // or a real time domain.
-  virtual double MonotonicallyIncreasingVirtualTimeSeconds() const = 0;
-
   // Helpers for posting bound functions as tasks.
 
   // For same-thread posting. Must be called from the associated WebThread.

third_party/WebKit/Source/platform/scheduler/child/web_task_runner_impl.cc

@@ -10,7 +10,6 @@
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "platform/scheduler/base/task_queue.h"
-#include "platform/scheduler/base/time_domain.h"
 
 namespace blink {
 namespace scheduler {
@@ -26,26 +25,12 @@ bool WebTaskRunnerImpl::RunsTasksInCurrentSequence() const {
   return task_queue_->RunsTasksInCurrentSequence();
 }
 
-double WebTaskRunnerImpl::MonotonicallyIncreasingVirtualTimeSeconds() const {
-  return Now().ToInternalValue() /
-         static_cast<double>(base::Time::kMicrosecondsPerSecond);
-}
-
 WebTaskRunnerImpl::WebTaskRunnerImpl(scoped_refptr<TaskQueue> task_queue,
                                      base::Optional<TaskType> task_type)
     : task_queue_(std::move(task_queue)), task_type_(task_type) {}
 
 WebTaskRunnerImpl::~WebTaskRunnerImpl() = default;
 
-base::TimeTicks WebTaskRunnerImpl::Now() const {
-  TimeDomain* time_domain = task_queue_->GetTimeDomain();
-  // It's possible task_queue_ has been Unregistered which can lead to a null
-  // TimeDomain.  If that happens just return the current real time.
-  if (!time_domain)
-    return base::TimeTicks::Now();
-  return time_domain->Now();
-}
-
 bool WebTaskRunnerImpl::PostDelayedTask(const base::Location& location,
                                         base::OnceClosure task,
                                         base::TimeDelta delay) {

third_party/WebKit/Source/platform/scheduler/child/web_task_runner_impl.h

@@ -29,9 +29,6 @@ class PLATFORM_EXPORT WebTaskRunnerImpl : public WebTaskRunner {
   // base::SingleThreadTaskRunner implementation:
   bool RunsTasksInCurrentSequence() const override;
 
-  // WebTaskRunner implementation:
-  double MonotonicallyIncreasingVirtualTimeSeconds() const override;
-
   TaskQueue* GetTaskQueue() const { return task_queue_.get(); }
 
  protected:
@@ -47,8 +44,6 @@ class PLATFORM_EXPORT WebTaskRunnerImpl : public WebTaskRunner {
                     base::Optional<TaskType> task_type);
   ~WebTaskRunnerImpl() override;
 
-  base::TimeTicks Now() const;
-
   scoped_refptr<TaskQueue> task_queue_;
   base::Optional<TaskType> task_type_;
 

third_party/WebKit/Source/platform/scheduler/renderer/web_view_scheduler_impl_unittest.cc

@@ -203,99 +203,102 @@ TEST_F(WebViewSchedulerImplTest, RepeatingTimers_OneBackgroundOneForeground) {
 
 namespace {
 
-void RunVirtualTimeRecorderTask(base::SimpleTestTickClock* clock,
-                                scoped_refptr<WebTaskRunner> task_runner,
-                                std::vector<base::TimeTicks>* out_real_times,
-                                std::vector<size_t>* out_virtual_times_ms) {
+void RunVirtualTimeRecorderTask(
+    base::SimpleTestTickClock* clock,
+    RendererSchedulerImpl* scheduler,
+    std::vector<base::TimeTicks>* out_real_times,
+    std::vector<base::TimeTicks>* out_virtual_times) {
   out_real_times->push_back(clock->NowTicks());
-  out_virtual_times_ms->push_back(
-      task_runner->MonotonicallyIncreasingVirtualTimeSeconds() * 1000.0);
+  out_virtual_times->push_back(scheduler->GetVirtualTimeDomain()->Now());
 }
 
 base::OnceClosure MakeVirtualTimeRecorderTask(
     base::SimpleTestTickClock* clock,
-    scoped_refptr<WebTaskRunner> task_runner,
+    RendererSchedulerImpl* scheduler,
     std::vector<base::TimeTicks>* out_real_times,
-    std::vector<size_t>* out_virtual_times_ms) {
+    std::vector<base::TimeTicks>* out_virtual_times) {
   return WTF::Bind(&RunVirtualTimeRecorderTask, WTF::Unretained(clock),
-                   WTF::Passed(std::move(task_runner)),
-                   WTF::Unretained(out_real_times),
-                   WTF::Unretained(out_virtual_times_ms));
+                   WTF::Unretained(scheduler), WTF::Unretained(out_real_times),
+                   WTF::Unretained(out_virtual_times));
 }
 }
 
 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 =
-      ThrottleableTaskRunner()->MonotonicallyIncreasingVirtualTimeSeconds() *
-      1000.0;
+  std::vector<base::TimeTicks> virtual_times;
 
   web_view_scheduler_->EnableVirtualTime();
 
+  base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks();
+  base::TimeTicks initial_virtual_time =
+      scheduler_->GetVirtualTimeDomain()->Now();
+
   ThrottleableTaskRunner()->PostDelayedTask(
       FROM_HERE,
-      MakeVirtualTimeRecorderTask(&clock_, ThrottleableTaskRunner(),
-                                  &real_times, &virtual_times_ms),
+      MakeVirtualTimeRecorderTask(&clock_, scheduler_.get(), &real_times,
+                                  &virtual_times),
       TimeDelta::FromMilliseconds(2));
 
   ThrottleableTaskRunner()->PostDelayedTask(
       FROM_HERE,
-      MakeVirtualTimeRecorderTask(&clock_, ThrottleableTaskRunner(),
-                                  &real_times, &virtual_times_ms),
+      MakeVirtualTimeRecorderTask(&clock_, scheduler_.get(), &real_times,
+                                  &virtual_times),
       TimeDelta::FromMilliseconds(20));
 
   ThrottleableTaskRunner()->PostDelayedTask(
       FROM_HERE,
-      MakeVirtualTimeRecorderTask(&clock_, ThrottleableTaskRunner(),
-                                  &real_times, &virtual_times_ms),
+      MakeVirtualTimeRecorderTask(&clock_, scheduler_.get(), &real_times,
+                                  &virtual_times),
       TimeDelta::FromMilliseconds(200));
 
   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));
+  EXPECT_THAT(
+      virtual_times,
+      ElementsAre(initial_virtual_time + TimeDelta::FromMilliseconds(2),
+                  initial_virtual_time + TimeDelta::FromMilliseconds(20),
+                  initial_virtual_time + TimeDelta::FromMilliseconds(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 =
-      ThrottleableTaskRunner()->MonotonicallyIncreasingVirtualTimeSeconds() *
-      1000.0;
+  std::vector<base::TimeTicks> virtual_times;
 
   web_view_scheduler_->EnableVirtualTime();
 
+  base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks();
+  base::TimeTicks initial_virtual_time =
+      scheduler_->GetVirtualTimeDomain()->Now();
+
   LoadingTaskRunner()->PostDelayedTask(
       FROM_HERE,
-      MakeVirtualTimeRecorderTask(&clock_, LoadingTaskRunner(), &real_times,
-                                  &virtual_times_ms),
+      MakeVirtualTimeRecorderTask(&clock_, scheduler_.get(), &real_times,
+                                  &virtual_times),
       TimeDelta::FromMilliseconds(2));
 
   LoadingTaskRunner()->PostDelayedTask(
       FROM_HERE,
-      MakeVirtualTimeRecorderTask(&clock_, LoadingTaskRunner(), &real_times,
-                                  &virtual_times_ms),
+      MakeVirtualTimeRecorderTask(&clock_, scheduler_.get(), &real_times,
+                                  &virtual_times),
       TimeDelta::FromMilliseconds(20));
 
   LoadingTaskRunner()->PostDelayedTask(
       FROM_HERE,
-      MakeVirtualTimeRecorderTask(&clock_, LoadingTaskRunner(), &real_times,
-                                  &virtual_times_ms),
+      MakeVirtualTimeRecorderTask(&clock_, scheduler_.get(), &real_times,
+                                  &virtual_times),
       TimeDelta::FromMilliseconds(200));
 
   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));
+  EXPECT_THAT(
+      virtual_times,
+      ElementsAre(initial_virtual_time + TimeDelta::FromMilliseconds(2),
+                  initial_virtual_time + TimeDelta::FromMilliseconds(20),
+                  initial_virtual_time + TimeDelta::FromMilliseconds(200)));
 }
 
 TEST_F(WebViewSchedulerImplTest,
@@ -602,36 +605,36 @@ TEST_F(WebViewSchedulerImplTest, PauseTimersWhileVirtualTimeIsPaused) {
 
 TEST_F(WebViewSchedulerImplTest, VirtualTimeBudgetExhaustedCallback) {
   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 =
-      ThrottleableTaskRunner()->MonotonicallyIncreasingVirtualTimeSeconds() *
-      1000.0;
+  std::vector<base::TimeTicks> virtual_times;
 
   web_view_scheduler_->EnableVirtualTime();
 
+  base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks();
+  base::TimeTicks initial_virtual_time =
+      scheduler_->GetVirtualTimeDomain()->Now();
+
   ThrottleableTaskRunner()->PostDelayedTask(
       FROM_HERE,
-      MakeVirtualTimeRecorderTask(&clock_, ThrottleableTaskRunner(),
-                                  &real_times, &virtual_times_ms),
+      MakeVirtualTimeRecorderTask(&clock_, scheduler_.get(), &real_times,
+                                  &virtual_times),
       TimeDelta::FromMilliseconds(1));
 
   ThrottleableTaskRunner()->PostDelayedTask(
       FROM_HERE,
-      MakeVirtualTimeRecorderTask(&clock_, ThrottleableTaskRunner(),
-                                  &real_times, &virtual_times_ms),
+      MakeVirtualTimeRecorderTask(&clock_, scheduler_.get(), &real_times,
+                                  &virtual_times),
       TimeDelta::FromMilliseconds(2));
 
   ThrottleableTaskRunner()->PostDelayedTask(
       FROM_HERE,
-      MakeVirtualTimeRecorderTask(&clock_, ThrottleableTaskRunner(),
-                                  &real_times, &virtual_times_ms),
+      MakeVirtualTimeRecorderTask(&clock_, scheduler_.get(), &real_times,
+                                  &virtual_times),
       TimeDelta::FromMilliseconds(5));
 
   ThrottleableTaskRunner()->PostDelayedTask(
       FROM_HERE,
-      MakeVirtualTimeRecorderTask(&clock_, ThrottleableTaskRunner(),
-                                  &real_times, &virtual_times_ms),
+      MakeVirtualTimeRecorderTask(&clock_, scheduler_.get(), &real_times,
+                                  &virtual_times),
       TimeDelta::FromMilliseconds(7));
 
   web_view_scheduler_->GrantVirtualTimeBudget(
@@ -648,9 +651,11 @@ TEST_F(WebViewSchedulerImplTest, VirtualTimeBudgetExhaustedCallback) {
   // expires will not run.
   EXPECT_THAT(real_times, ElementsAre(initial_real_time, initial_real_time,
                                       initial_real_time));
-  EXPECT_THAT(virtual_times_ms, ElementsAre(initial_virtual_time_ms + 1,
-                                            initial_virtual_time_ms + 2,
-                                            initial_virtual_time_ms + 5));
+  EXPECT_THAT(
+      virtual_times,
+      ElementsAre(initial_virtual_time + base::TimeDelta::FromMilliseconds(1),
+                  initial_virtual_time + base::TimeDelta::FromMilliseconds(2),
+                  initial_virtual_time + base::TimeDelta::FromMilliseconds(5)));
 }
 
 namespace {

third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.cc

@@ -58,10 +58,6 @@ bool FakeWebTaskRunner::RunsTasksInCurrentSequence() const {
   return true;
 }
 
-double FakeWebTaskRunner::MonotonicallyIncreasingVirtualTimeSeconds() const {
-  return (data_->time_ - base::TimeTicks()).InSecondsF();
-}
-
 void FakeWebTaskRunner::RunUntilIdle() {
   while (!data_->task_queue_.empty()) {
     // Move the task to run into a local variable in case it touches the

third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.h

@@ -29,9 +29,6 @@ class FakeWebTaskRunner : public WebTaskRunner {
   // base::SingleThreadTaskRunner implementation:
   bool RunsTasksInCurrentSequence() const override;
 
-  // WebTaskRunner implementation:
-  double MonotonicallyIncreasingVirtualTimeSeconds() const override;
-
   void RunUntilIdle();
   void AdvanceTimeAndRun(base::TimeDelta delta);
   void AdvanceTimeAndRun(double delta_seconds) {

third_party/WebKit/Source/platform/scheduler/test/renderer_scheduler_test_support.cc

@@ -43,10 +43,6 @@ class WebTaskRunnerProxy : public WebTaskRunner {
         location, std::move(closure), time_delta);
   }
 
-  double MonotonicallyIncreasingVirtualTimeSeconds() const override {
-    return 0.0;
-  }
-
   bool RunsTasksInCurrentSequence() const override {
     return task_runner_->RunsTasksInCurrentSequence();
   }