DevTools: allow setting initial virtual time when enabling emulation.

Change-Id: I193440a6de9252e239d91a1028e02be141d5f32b
Reviewed-on: https://chromium-review.googlesource.com/1038690
Commit-Queue: Pavel Feldman <pfeldman@chromium.org>
Reviewed-by: Eric Seckler <eseckler@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Reviewed-by: Alex Clarke <alexclarke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#555429}

third_party/WebKit/LayoutTests/inspector-protocol/emulation/set-initial-virtual-time-expected.txt

+Tests that passing initial virtual time works.
+1234567890000
+1234567890000
+1234567890000
+

third_party/WebKit/LayoutTests/inspector-protocol/emulation/set-initial-virtual-time.js

+(async function(testRunner) {
+  const {page, session, dp} = await testRunner.startBlank('Tests that passing initial virtual time works.');
+
+  await dp.Emulation.setVirtualTimePolicy({policy: 'pause', initialVirtualTime: 1234567890});
+  let now = await session.evaluate(`Date.now()`);
+  testRunner.log(now);
+  now = await session.evaluate(`Date.now()`);
+  testRunner.log(now);
+  now = await session.evaluate(`Date.now()`);
+  testRunner.log(now);
+  testRunner.completeTest();
+})

third_party/blink/renderer/core/inspector/browser_protocol.pdl

@@ -2379,6 +2379,8 @@ domain Emulation
       # If set the virtual time policy change should be deferred until any frame starts navigating.
       # Note any previous deferred policy change is superseded.
       optional boolean waitForNavigation
+      # If set, base::Time::Now will be overriden to initially return this value.
+      optional Network.TimeSinceEpoch initialVirtualTime
     returns
       # Absolute timestamp at which virtual time was first enabled (milliseconds since epoch).
       Runtime.Timestamp virtualTimeBase

third_party/blink/renderer/core/inspector/inspector_emulation_agent.cc

@@ -37,6 +37,7 @@ static const char kNavigatorPlatform[] = "navigatorPlatform";
 static const char kVirtualTimeBudget[] = "virtualTimeBudget";
 static const char kVirtualTimeBudgetInitalOffset[] =
     "virtualTimeBudgetInitalOffset";
+static const char kInitialVirtualTime[] = "initialVirtualTime";
 static const char kVirtualTimeOffset[] = "virtualTimeOffset";
 static const char kVirtualTimePolicy[] = "virtualTimePolicy";
 static const char kVirtualTimeTaskStarvationCount[] =
@@ -97,6 +98,9 @@ void InspectorEmulationAgent::Restore() {
 
     // Tell the scheduler about the saved virtual time progress to ensure that
     // virtual time monotonically advances despite the cross origin navigation.
+    double initial_virtual_time = 0;
+    bool has_initial_time = state_->getDouble(
+        EmulationAgentState::kInitialVirtualTime, &initial_virtual_time);
     web_local_frame_->View()->Scheduler()->SetInitialVirtualTimeOffset(
         base::TimeDelta::FromMillisecondsD(offset));
 
@@ -107,6 +111,8 @@ void InspectorEmulationAgent::Restore() {
         virtual_time_policy, budget_remaining, starvation_count,
         virtual_time_policy == protocol::Emulation::VirtualTimePolicyEnum::
                                    PauseIfNetworkFetchesPending,
+        has_initial_time ? protocol::Maybe<double>()
+                         : protocol::Maybe<double>(initial_virtual_time),
         &virtual_time_base_ms, &virtual_time_ticks_base_ms);
   }
 }
@@ -174,6 +180,7 @@ Response InspectorEmulationAgent::setVirtualTimePolicy(
     Maybe<double> virtual_time_budget_ms,
     protocol::Maybe<int> max_virtual_time_task_starvation_count,
     protocol::Maybe<bool> wait_for_navigation,
+    protocol::Maybe<double> initial_virtual_time,
     double* virtual_time_base_ms,
     double* virtual_time_ticks_base_ms) {
   state_->setString(EmulationAgentState::kVirtualTimePolicy, policy);
@@ -215,6 +222,14 @@ Response InspectorEmulationAgent::setVirtualTimePolicy(
     virtual_time_setup_ = true;
   }
 
+  // This needs to happen before we apply virtual time.
+  if (initial_virtual_time.isJust()) {
+    state_->setDouble(EmulationAgentState::kInitialVirtualTime,
+                      initial_virtual_time.fromJust());
+    web_local_frame_->View()->Scheduler()->SetInitialVirtualTime(
+        base::Time::FromDoubleT(initial_virtual_time.fromJust()));
+  }
+
   if (wait_for_navigation.fromMaybe(false)) {
     pending_virtual_time_policy_ = std::move(new_policy);
   } else {

third_party/blink/renderer/core/inspector/inspector_emulation_agent.h

@@ -46,6 +46,7 @@ class CORE_EXPORT InspectorEmulationAgent final
       protocol::Maybe<double> virtual_time_budget_ms,
       protocol::Maybe<int> max_virtual_time_task_starvation_count,
       protocol::Maybe<bool> wait_for_navigation,
+      protocol::Maybe<double> initial_virtual_time,
       double* virtual_time_base_ms,
       double* virtual_time_ticks_base_ms) override;
   protocol::Response setNavigatorOverrides(const String& platform) override;

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.cc

@@ -1784,6 +1784,12 @@ WakeUpBudgetPool* MainThreadSchedulerImpl::GetWakeUpBudgetPoolForTesting() {
   return main_thread_only().wake_up_budget_pool;
 }
 
+base::TimeTicks MainThreadSchedulerImpl::EnableVirtualTime() {
+  return EnableVirtualTime(main_thread_only().initial_virtual_time.is_null()
+                               ? BaseTimeOverridePolicy::DO_NOT_OVERRIDE
+                               : BaseTimeOverridePolicy::OVERRIDE);
+}
+
 base::TimeTicks MainThreadSchedulerImpl::EnableVirtualTime(
     BaseTimeOverridePolicy policy) {
   if (main_thread_only().use_virtual_time)
@@ -1921,6 +1927,10 @@ void MainThreadSchedulerImpl::SetVirtualTimePolicy(VirtualTimePolicy policy) {
   ApplyVirtualTimePolicy();
 }
 
+void MainThreadSchedulerImpl::SetInitialVirtualTime(base::Time time) {
+  main_thread_only().initial_virtual_time = time;
+}
+
 void MainThreadSchedulerImpl::SetInitialVirtualTimeOffset(
     base::TimeDelta offset) {
   main_thread_only().initial_virtual_time_offset = offset;

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h

@@ -192,6 +192,10 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
   using BaseTimeOverridePolicy =
       AutoAdvancingVirtualTimeDomain::BaseTimeOverridePolicy;
 
+  // Tells the scheduler that all TaskQueues should use virtual time. Depending
+  // on the initial time, picks the policy to be either overriding or not.
+  base::TimeTicks EnableVirtualTime();
+
   // Tells the scheduler that all TaskQueues should use virtual time. Returns
   // the TimeTicks that virtual time offsets will be relative to.
   base::TimeTicks EnableVirtualTime(BaseTimeOverridePolicy policy);
@@ -203,6 +207,7 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
   // Returns true if virtual time is not paused.
   bool VirtualTimeAllowedToAdvance() const;
   void SetVirtualTimePolicy(VirtualTimePolicy virtual_time_policy);
+  void SetInitialVirtualTime(base::Time time);
   void SetInitialVirtualTimeOffset(base::TimeDelta offset);
   void SetMaxVirtualTimeTaskStarvationCount(int max_task_starvation_count);
   void AddVirtualTimeObserver(VirtualTimeObserver*);

third_party/blink/renderer/platform/scheduler/main_thread/page_scheduler_impl.cc

@@ -201,8 +201,7 @@ void PageSchedulerImpl::ReportIntervention(const std::string& message) {
 }
 
 base::TimeTicks PageSchedulerImpl::EnableVirtualTime() {
-  return main_thread_scheduler_->EnableVirtualTime(
-      MainThreadSchedulerImpl::BaseTimeOverridePolicy::DO_NOT_OVERRIDE);
+  return main_thread_scheduler_->EnableVirtualTime();
 }
 
 void PageSchedulerImpl::DisableVirtualTimeForTesting() {
@@ -213,6 +212,10 @@ void PageSchedulerImpl::SetVirtualTimePolicy(VirtualTimePolicy policy) {
   main_thread_scheduler_->SetVirtualTimePolicy(policy);
 }
 
+void PageSchedulerImpl::SetInitialVirtualTime(base::Time time) {
+  main_thread_scheduler_->SetInitialVirtualTime(time);
+}
+
 void PageSchedulerImpl::SetInitialVirtualTimeOffset(base::TimeDelta offset) {
   main_thread_scheduler_->SetInitialVirtualTimeOffset(offset);
 }

third_party/blink/renderer/platform/scheduler/main_thread/page_scheduler_impl.h

@@ -56,6 +56,7 @@ class PLATFORM_EXPORT PageSchedulerImpl : public PageScheduler {
   void DisableVirtualTimeForTesting() override;
   bool VirtualTimeAllowedToAdvance() const override;
   void SetVirtualTimePolicy(VirtualTimePolicy) override;
+  void SetInitialVirtualTime(base::Time time) override;
   void SetInitialVirtualTimeOffset(base::TimeDelta offset) override;
   void GrantVirtualTimeBudget(
       base::TimeDelta budget,

third_party/blink/renderer/platform/scheduler/public/page_scheduler.h

@@ -94,6 +94,11 @@ class PLATFORM_EXPORT PageScheduler {
     kDeterministicLoading,
   };
 
+  // This is used to set initial Date.now() while in virtual time mode.
+  virtual void SetInitialVirtualTime(base::Time time) = 0;
+
+  // This is used for cross origin navigations to account for virtual time
+  // advancing in the previous renderer.
   virtual void SetInitialVirtualTimeOffset(base::TimeDelta offset) = 0;
 
   // Sets the virtual time policy, which is applied imemdiatly to all child

third_party/blink/renderer/platform/scheduler/test/fake_page_scheduler.h

@@ -66,6 +66,7 @@ class FakePageScheduler final : public PageScheduler {
   void SetVirtualTimePolicy(VirtualTimePolicy policy) override {}
   void AddVirtualTimeObserver(VirtualTimeObserver* observer) override {}
   void RemoveVirtualTimeObserver(VirtualTimeObserver* observer) override {}
+  void SetInitialVirtualTime(base::Time time) override {}
   void SetInitialVirtualTimeOffset(base::TimeDelta offset) override {}
   void GrantVirtualTimeBudget(base::TimeDelta budget,
                               base::OnceClosure callback) override {}