Remove Sync GetPose VRService call, implement VRVSyncProvider

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 29 matching lines @@
 static constexpr std::array<uint8_t, 2> kWebVrPosePixelMagicNumbers{{42, 142}};
 
 VREye stringToVREye(const String& whichEye) {
   if (whichEye == "left")
     return VREyeLeft;
   if (whichEye == "right")
     return VREyeRight;
   return VREyeNone;
 }
 
-class VRDisplayFrameRequestCallback : public FrameRequestCallback {
- public:
-  VRDisplayFrameRequestCallback(VRDisplay* vrDisplay) : m_vrDisplay(vrDisplay) {
-    m_useLegacyTimeBase = true;
-  }
-  ~VRDisplayFrameRequestCallback() override {}
-  void handleEvent(double highResTimeMs) override {
-    Document* doc = m_vrDisplay->document();
-    if (!doc)
-      return;
-
-    // Need to divide by 1000 here because serviceScriptedAnimations expects
-    // time to be given in seconds.
-    m_vrDisplay->serviceScriptedAnimations(
-        doc->loader()->timing().pseudoWallTimeToMonotonicTime(highResTimeMs /
-                                                              1000.0));
-  }
-
-  DEFINE_INLINE_VIRTUAL_TRACE() {
-    visitor->trace(m_vrDisplay);
-
-    FrameRequestCallback::trace(visitor);
-  }
-
-  Member<VRDisplay> m_vrDisplay;
-};
-
 }  // namespace
 
 VRDisplay::VRDisplay(NavigatorVR* navigatorVR,
                      device::mojom::blink::VRDisplayPtr display,
                      device::mojom::blink::VRDisplayClientRequest request)
     : ContextLifecycleObserver(navigatorVR->document()),
       m_navigatorVR(navigatorVR),
-      m_isConnected(false),
-      m_isPresenting(false),
-      m_isValidDeviceForPresenting(true),
-      m_canUpdateFramePose(true),
       m_capabilities(new VRDisplayCapabilities()),
       m_eyeParametersLeft(new VREyeParameters()),
       m_eyeParametersRight(new VREyeParameters()),
-      m_depthNear(0.01),
-      m_depthFar(10000.0),
       m_fullscreenCheckTimer(this, &VRDisplay::onFullscreenCheck),
-      m_contextGL(nullptr),
-      m_animationCallbackRequested(false),
-      m_inAnimationFrame(false),
       m_display(std::move(display)),
-      m_binding(this, std::move(request)) {}
+      m_displayClientBinding(this, std::move(request)),
+      m_vsyncProviderClientBinding(this) {}
 
 VRDisplay::~VRDisplay() {}
 
 VRController* VRDisplay::controller() {
   return m_navigatorVR->controller();
 }
 
 void VRDisplay::update(const device::mojom::blink::VRDisplayInfoPtr& display) {
   m_displayId = display->index;
   m_displayName = display->displayName;
@@ skipping 28 matching lines @@
     OnPresentChange();
   }
 }
 
 void VRDisplay::disconnected() {
   if (m_isConnected)
     m_isConnected = !m_isConnected;
 }
 
 bool VRDisplay::getFrameData(VRFrameData* frameData) {
-  updatePose();
-
-  if (!m_framePose)
+  if (!m_framePose || m_displayBlurred)
     return false;
 
   if (!frameData)
     return false;
 
   if (m_depthNear == m_depthFar)
     return false;
 
   return frameData->update(m_framePose, m_eyeParametersLeft,
                            m_eyeParametersRight, m_depthNear, m_depthFar);
 }
 
 VRPose* VRDisplay::getPose() {
-  updatePose();
-
-  if (!m_framePose)
+  if (!m_framePose || m_displayBlurred)
     return nullptr;
 
   VRPose* pose = VRPose::create();
   pose->setPose(m_framePose);
   return pose;
 }
 
-void VRDisplay::updatePose() {
-  if (m_displayBlurred) {
-    // WebVR spec says to return a null pose when the display is blurred.
-    m_framePose = nullptr;
-    return;
-  }
-  if (m_canUpdateFramePose) {
-    if (!m_display)
-      return;
-    device::mojom::blink::VRPosePtr pose;
-    m_display->GetPose(&pose);
-    m_framePose = std::move(pose);
-    if (m_isPresenting)
-      m_canUpdateFramePose = false;
-  }
-}
-
 void VRDisplay::resetPose() {
   if (!m_display)
     return;
 
   m_display->ResetPose();
 }
 
 VREyeParameters* VRDisplay::getEyeParameters(const String& whichEye) {
   switch (stringToVREye(whichEye)) {
     case VREyeLeft:
       return m_eyeParametersLeft;
     case VREyeRight:
       return m_eyeParametersRight;
     default:
       return nullptr;
   }
 }
 
 int VRDisplay::requestAnimationFrame(FrameRequestCallback* callback) {
   Document* doc = this->document();
   if (!doc)
     return 0;
-
-  if (!m_animationCallbackRequested) {
-    doc->requestAnimationFrame(new VRDisplayFrameRequestCallback(this));
-    m_animationCallbackRequested = true;
-  }
-
   callback->m_useLegacyTimeBase = false;
   return ensureScriptedAnimationController(doc).registerCallback(callback);
 }
 
 void VRDisplay::cancelAnimationFrame(int id) {
   if (!m_scriptedAnimationController)
     return;
   m_scriptedAnimationController->cancelCallback(id);
 }
 
 void VRDisplay::OnBlur() {
   m_displayBlurred = true;
-
   m_navigatorVR->enqueueVREvent(VRDisplayEvent::create(
       EventTypeNames::vrdisplayblur, true, false, this, ""));
 }
 
 void VRDisplay::OnFocus() {
   m_displayBlurred = false;
-  // Restart our internal doc requestAnimationFrame callback, if it fired while
-  // the display was blurred.
-  // TODO(bajones): Don't use doc->requestAnimationFrame() at all. Animation
-  // frames should be tied to the presenting VR display (e.g. should be serviced
-  // by GVR library callbacks on Android), and not the doc frame rate.
-  if (!m_animationCallbackRequested) {
-    Document* doc = this->document();
-    if (!doc)
-      return;
-    doc->requestAnimationFrame(new VRDisplayFrameRequestCallback(this));
-  }
   m_navigatorVR->enqueueVREvent(VRDisplayEvent::create(
       EventTypeNames::vrdisplayfocus, true, false, this, ""));
 }
 
-void VRDisplay::serviceScriptedAnimations(double monotonicAnimationStartTime) {
-  if (!m_scriptedAnimationController)
-    return;
-  AutoReset<bool> animating(&m_inAnimationFrame, true);
-  m_animationCallbackRequested = false;
-
-  // We use an internal rAF callback to run the animation loop at the display
-  // speed, and run the user's callback after our internal callback fires.
-  // However, when the display is blurred, we want to pause the animation loop,
-  // so we don't fire the user's callback until the display is focused.
-  if (m_displayBlurred)
-    return;
-  m_scriptedAnimationController->serviceScriptedAnimations(
-      monotonicAnimationStartTime);
-}
-
 void ReportPresentationResult(PresentationResult result) {
   // Note that this is called twice for each call to requestPresent -
   // one to declare that requestPresent was called, and one for the
   // result.
   DEFINE_STATIC_LOCAL(
       EnumerationHistogram, vrPresentationResultHistogram,
       ("VRDisplayPresentResult",
        static_cast<int>(PresentationResult::PresentationResultMax)));
   vrPresentationResultHistogram.count(static_cast<int>(result));
 }
@@ skipping 407 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::OnVRVsyncProviderReady(
+    const OnVRVsyncProviderReadyCallback& callback) {
+  if (m_vsyncProviderClientBinding.is_bound())
+    m_vsyncProviderClientBinding.Unbind();
+  callback.Run(m_vsyncProviderClientBinding.CreateInterfacePtrAndBind());
+}
+
+void VRDisplay::OnVSync(device::mojom::blink::VRPosePtr pose,
+                        double timeSeconds,
+                        const OnVSyncCallback& callback) {
+  callback.Run();
+  if (m_displayBlurred)
+    return;
+  if (!m_scriptedAnimationController)
+    return;
+  Document* doc = this->document();
+  if (!doc)
+    return;
+
+  AutoReset<bool> animating(&m_inAnimationFrame, true);
+  if (m_canUpdateFramePose)

[bajones, 2017/01/10 00:22:17]

I think we can safely drop the logic behind m_canUpdateFramePose in this patch
and just always update it in OnVSync()

[klausw, 2017/01/10 00:35:23]

Strictly speaking that may be a spec violation. As written, if a rAF callback
doesn't call submitFrame, it seems to be required to keep reusing the same pose
for the next rAF too. I don't think that's the intention though, and I think it
would be saner to use a fresh pose.

+    m_framePose = std::move(pose);
+  m_canUpdateFramePose = false;
+  m_scriptedAnimationController->serviceScriptedAnimations(
+      doc->loader()->timing().referenceMonotonicTime() + timeSeconds);

[bajones, 2017/01/10 00:22:17]

How confident are we that this will align with the values provided to
window.requestAnimationFrame? Ideally they should match.

[mthiesse, 2017/01/10 00:25:24]

I haven't checked, but I can pretty much guarantee they won't match as-is. How
important is it that they match, and what purpose does that serve?

[klausw, 2017/01/10 00:35:23]

This becomes important when switching between window.rAF (not presenting) and
VRDisplay.rAF (when presenting), the time must not jump around during
transitions.

+}
+
 void VRDisplay::onFullscreenCheck(TimerBase*) {
   if (!m_isPresenting) {
     m_fullscreenCheckTimer.stop();
     return;
   }
   // TODO: This is a temporary measure to track if fullscreen mode has been
   // exited by the UA. If so we need to end VR presentation. Soon we won't
   // depend on the Fullscreen API to fake VR presentation, so this will
   // become unnessecary. Until that point, though, this seems preferable to
   // adding a bunch of notification plumbing to Fullscreen.
@@ skipping 25 matching lines @@
 
 ScriptedAnimationController& VRDisplay::ensureScriptedAnimationController(
     Document* doc) {
   if (!m_scriptedAnimationController)
     m_scriptedAnimationController = ScriptedAnimationController::create(doc);
 
   return *m_scriptedAnimationController;
 }
 
 void VRDisplay::dispose() {
-  m_binding.Close();
+  m_displayClientBinding.Close();
+  m_vsyncProviderClientBinding.Close();
 }
 
 ExecutionContext* VRDisplay::getExecutionContext() const {
   return ContextLifecycleObserver::getExecutionContext();
 }
 
 const AtomicString& VRDisplay::interfaceName() const {
   return EventTargetNames::VRDisplay;
 }
 
@@ skipping 15 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