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. If we call GetVSync inline here via

[mthiesse, 2017/03/15 17:43:51]

Comment needs to be updated.

[klausw, 2017/03/15 17:55:40]

The comment is accurate, but I'll rephrase it to be less confusing.

I think the sequence was:

while (mojo stuff to do)
  OnVSync
    serviceScriptedAnimations
      JS rAF callback
        rAF
          GetVSync
        ...
        submitFrame
          (VSync arrives, add to mojo queue)
  (keep going since queue isn't empty)

[mthiesse, 2017/03/15 18:05:03]

The problem is the comment says "If we call GetVSync inline here via...", but we
do call GetVSync inline here. We should instead say that we need to inject a
posted task with every frame to prevent starvation of non-mojo IPC, as our
render loop blocks on mojo IPC and ends up taking priority over other posted
tasks as a result.

[klausw, 2017/03/15 18:14:26]

No, we don't call GetVSync inline here. It's now called from the posted task,
the scheduled animation will call rAF from the JS code it's executing.

Anyway, comment rephrased to be less detailed, the bug pointer should be enough
for context.

[mthiesse, 2017/03/15 18:19:01]

We should at least mention in this comment that the starvation is due to
WaitForIncomingMethodCall

[klausw, 2017/03/15 18:21:00]

Done.

+  // serviceScriptedAnimations calling rAF, we can end up with the
+  // next VSync already being ready and scheduled when we exit, and
+  // then we'll process several frames in a row without ever yielding
+  // back to the main event loop. This causes extreme input delay, see
+  // crbug.com/701444.
+  Platform::current()->currentThread()->getWebTaskRunner()->postTask(
+      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