devtools: Return correct virtual time base for wait_for_navigation.

Previously, setVirtualTimePolicy was always returning a zero virtual
time base when wait_for_navigation was set. This meant, even if virtual
time was enabled before, the client's known virtual time base could be
overridden with an invalid one. Instead, return the previously
initialized virtual time base when it is known, even if
wait_for_navigation is set.

Change-Id: I391232f7310b81c4fc3b033e7ba4c186b32560d3
Reviewed-on: https://chromium-review.googlesource.com/960761
Commit-Queue: Eric Seckler <eseckler@chromium.org>
Reviewed-by: Alex Clarke <alexclarke@chromium.org>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#543052}

headless/lib/virtual_time_browsertest.cc

@@ -133,6 +133,61 @@ class VirtualTimeObserverTest : public VirtualTimeBrowserTest {
 
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(VirtualTimeObserverTest);
 
+class VirtualTimeBaseTest : public VirtualTimeBrowserTest {
+ public:
+  VirtualTimeBaseTest() {
+    EXPECT_TRUE(embedded_test_server()->Start());
+    SetInitialURL(embedded_test_server()->GetURL("/blank.html").spec());
+  }
+
+  void SetVirtualTimePolicy() override {
+    // Set to paused initially.
+    devtools_client_->GetEmulation()->GetExperimental()->SetVirtualTimePolicy(
+        emulation::SetVirtualTimePolicyParams::Builder()
+            .SetPolicy(emulation::VirtualTimePolicy::PAUSE)
+            .Build(),
+        base::BindRepeating(&VirtualTimeBaseTest::SetFirstVirtualTimePolicyDone,
+                            base::Unretained(this)));
+  }
+
+  void SetFirstVirtualTimePolicyDone(
+      std::unique_ptr<emulation::SetVirtualTimePolicyResult> result) {
+    // Should have enabled virtual time, and returned a valid time base.
+    virtual_time_base_ = result->GetVirtualTimeBase();
+    EXPECT_NE(0, virtual_time_base_);
+
+    // Set with wait_for_navigation, the returned time base shouldn't change.
+    devtools_client_->GetEmulation()->GetExperimental()->SetVirtualTimePolicy(
+        emulation::SetVirtualTimePolicyParams::Builder()
+            .SetPolicy(
+                emulation::VirtualTimePolicy::PAUSE_IF_NETWORK_FETCHES_PENDING)
+            .SetBudget(1000)
+            .SetWaitForNavigation(true)
+            .Build(),
+        base::BindRepeating(
+            &VirtualTimeBaseTest::SetSecondVirtualTimePolicyDone,
+            base::Unretained(this)));
+  }
+
+  void SetSecondVirtualTimePolicyDone(
+      std::unique_ptr<emulation::SetVirtualTimePolicyResult> result) {
+    EXPECT_EQ(virtual_time_base_, result->GetVirtualTimeBase());
+
+    SetVirtualTimePolicyDone(std::move(result));
+  }
+
+  // emulation::Observer implementation:
+  void OnVirtualTimeBudgetExpired(
+      const emulation::VirtualTimeBudgetExpiredParams& params) override {
+    FinishAsynchronousTest();
+  }
+
+ private:
+  double virtual_time_base_ = 0;
+};
+
+HEADLESS_ASYNC_DEVTOOLED_TEST_F(VirtualTimeBaseTest);
+
 class MaxVirtualTimeTaskStarvationCountTest : public VirtualTimeBrowserTest {
  public:
   MaxVirtualTimeTaskStarvationCountTest() {

third_party/WebKit/Source/core/inspector/InspectorEmulationAgent.cpp

@@ -215,24 +215,28 @@ Response InspectorEmulationAgent::setVirtualTimePolicy(
   }
 
   if (wait_for_navigation.fromMaybe(false)) {
-    *virtual_time_base_ms = 0;
     pending_virtual_time_policy_ = std::move(new_policy);
-    return Response::OK();
+  } else {
+    ApplyVirtualTimePolicy(new_policy);
   }
 
-  WTF::TimeDelta virtual_time_base_delta =
-      ApplyVirtualTimePolicy(new_policy) - WTF::TimeTicks::UnixEpoch();
-  *virtual_time_base_ms = virtual_time_base_delta.InMillisecondsF();
+  if (virtual_time_base_ticks_.is_null()) {
+    *virtual_time_base_ms = 0;
+  } else {
+    WTF::TimeDelta virtual_time_base_delta =
+        virtual_time_base_ticks_ - WTF::TimeTicks::UnixEpoch();
+    *virtual_time_base_ms = virtual_time_base_delta.InMillisecondsF();
+  }
 
   return Response::OK();
 }
 
-WTF::TimeTicks InspectorEmulationAgent::ApplyVirtualTimePolicy(
+void InspectorEmulationAgent::ApplyVirtualTimePolicy(
     const PendingVirtualTimePolicy& new_policy) {
   web_local_frame_->View()->Scheduler()->SetVirtualTimePolicy(
       new_policy.policy);
-  WTF::TimeTicks virtual_time_base_ticks(
-      web_local_frame_->View()->Scheduler()->EnableVirtualTime());
+  virtual_time_base_ticks_ =
+      web_local_frame_->View()->Scheduler()->EnableVirtualTime();
   if (new_policy.virtual_time_budget_ms) {
     TRACE_EVENT_ASYNC_BEGIN1("renderer.scheduler", "VirtualTimeBudget", this,
                              "budget", *new_policy.virtual_time_budget_ms);
@@ -247,7 +251,6 @@ WTF::TimeTicks InspectorEmulationAgent::ApplyVirtualTimePolicy(
     web_local_frame_->View()->Scheduler()->SetMaxVirtualTimeTaskStarvationCount(
         *new_policy.max_virtual_time_task_starvation_count);
   }
-  return virtual_time_base_ticks;
 }
 
 void InspectorEmulationAgent::FrameStartedLoading(LocalFrame*, FrameLoadType) {

third_party/WebKit/Source/core/inspector/InspectorEmulationAgent.h

@@ -87,11 +87,11 @@ class CORE_EXPORT InspectorEmulationAgent final
     WTF::Optional<double> virtual_time_budget_ms;
     WTF::Optional<int> max_virtual_time_task_starvation_count;
   };
-  WTF::TimeTicks ApplyVirtualTimePolicy(
-      const PendingVirtualTimePolicy& new_policy);
+  void ApplyVirtualTimePolicy(const PendingVirtualTimePolicy& new_policy);
 
   Member<WebLocalFrameImpl> web_local_frame_;
   bool virtual_time_setup_ = false;
+  WTF::TimeTicks virtual_time_base_ticks_;
 
   // Supports a virtual time policy change scheduled to occur after any
   // navigation has started.