WebVR: process animations from posted task to yield for other events

third_party/WebKit/Source/modules/vr/VRDisplay.cpp

 // Copyright 2016 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 "modules/vr/VRDisplay.h"
 
 #include "core/css/StylePropertySet.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/dom/FrameRequestCallback.h"
@@ skipping 671 matching lines @@
   m_navigatorVR->dispatchVRGestureEvent(VRDisplayEvent::create(
       EventTypeNames::vrdisplayactivate, true, false, this, reason));
 }
 
 void VRDisplay::OnDeactivate(
     device::mojom::blink::VRDisplayEventReason reason) {
   m_navigatorVR->enqueueVREvent(VRDisplayEvent::create(
       EventTypeNames::vrdisplaydeactivate, true, false, this, reason));
 }
 
+void VRDisplay::processScheduledAnimations(double timestamp) {
+  TRACE_EVENT1("gpu", "VRDisplay::OnVSync", "frame", m_vrFrameId);
+
+  AutoReset<bool> animating(&m_inAnimationFrame, true);
+  m_pendingRaf = false;
+  m_scriptedAnimationController->serviceScriptedAnimations(timestamp);
+}
+
 void VRDisplay::OnVSync(device::mojom::blink::VRPosePtr pose,
                         mojo::common::mojom::blink::TimeDeltaPtr time,
                         int16_t frameId,
                         device::mojom::blink::VRVSyncProvider::Status error) {
   switch (error) {
     case device::mojom::blink::VRVSyncProvider::Status::SUCCESS:
       break;
     case device::mojom::blink::VRVSyncProvider::Status::CLOSING:
       return;
   }
   m_pendingVsync = false;
   Document* doc = this->document();
   if (!doc || m_displayBlurred || !m_scriptedAnimationController)
     return;
 
   WTF::TimeDelta timeDelta =
       WTF::TimeDelta::FromMicroseconds(time->microseconds);
   // Ensure a consistent timebase with document rAF.
   if (m_timebase < 0) {
     m_timebase = WTF::monotonicallyIncreasingTime() - timeDelta.InSecondsF();
   }
 
-  AutoReset<bool> animating(&m_inAnimationFrame, true);
   m_framePose = std::move(pose);
   m_vrFrameId = frameId;
-  m_pendingRaf = false;
-  m_scriptedAnimationController->serviceScriptedAnimations(
-      m_timebase + timeDelta.InSecondsF());
+
+  // Post a task to handle scheduled animations after the current
+  // execution context finishes, so that we yield to non-mojo tasks in
+  // between frames. Executing mojo tasks back to back within the same
+  // execution context caused extreme input delay due to processing
+  // multiple frames without yielding, see crbug.com/701444. I suspect
+  // this is due to WaitForIncomingMethodCall receiving the OnVSync
+  // but queueing it for immediate execution since it doesn't match
+  // the interface being waited on.
+  Platform::current()->currentThread()->getWebTaskRunner()->postTask(

[billorr, 2017/03/15 18:35:45]

Does this measurably have a negative effect on latency?

Should we set m_pendingVsync = false in the posted task rather than here so we
can't queue many posted tasks and get behind?

[klausw, 2017/03/15 19:00:17]

I don't think so, if I understand it right it's just saving a closure and
running it in the same thread from the work queue immediately after the current
context finishes. There's no task switching, scheduling, or IPC involved.
 
No, we're not going to be queueing multiple posted tasks. We're changing state
to indicate that we're not going to be getting another vsync because none is
scheduled. The VSync events don't happen automatically, we only get one per
GetVSync.

It gets flipped back to "pending" when the scheduled animation and its rAF
callback calls rAF which calls GetVSync.

+      BLINK_FROM_HERE,
+      WTF::bind(&VRDisplay::processScheduledAnimations,
+                wrapWeakPersistent(this), m_timebase + timeDelta.InSecondsF()));
 }
 
 void VRDisplay::ConnectVSyncProvider() {
   if (!m_navigatorVR->isFocused() || m_vrVSyncProvider.is_bound())
     return;
   m_display->GetVRVSyncProvider(mojo::MakeRequest(&m_vrVSyncProvider));
   m_vrVSyncProvider.set_connection_error_handler(convertToBaseCallback(
       WTF::bind(&VRDisplay::OnVSyncConnectionError, wrapWeakPersistent(this))));
   if (m_pendingRaf && !m_displayBlurred) {
     m_pendingVsync = true;
@@ skipping 53 matching lines @@
   visitor->trace(m_stageParameters);
   visitor->trace(m_eyeParametersLeft);
   visitor->trace(m_eyeParametersRight);
   visitor->trace(m_layer);
   visitor->trace(m_renderingContext);
   visitor->trace(m_scriptedAnimationController);
   visitor->trace(m_pendingPresentResolvers);
 }
 
 }  // namespace blink