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 10 matching lines @@
 #include "modules/vr/VREyeParameters.h"
 #include "modules/vr/VRFrameData.h"
 #include "modules/vr/VRLayer.h"
 #include "modules/vr/VRPose.h"
 #include "modules/vr/VRStageParameters.h"
 #include "modules/webgl/WebGLRenderingContextBase.h"
 #include "platform/Histogram.h"
 #include "platform/UserGestureIndicator.h"
 #include "public/platform/Platform.h"
 #include "wtf/AutoReset.h"
+#include "wtf/Time.h"
 
 #include <array>
 
 namespace blink {
 
 namespace {
 
 // Magic numbers used to mark valid pose index values encoded in frame
 // data. Must match the magic numbers used in vr_shell.cc.
 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)) {}
 
 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;
+  m_pendingRaf = true;
+  if (!m_vrVSyncProvider.is_bound()) {
+    ConnectVSyncProvider();
+  } else if (!m_displayBlurred) {
+    m_vrVSyncProvider->GetVSync(convertToBaseCallback(
+        WTF::bind(&VRDisplay::OnVSync, wrapWeakPersistent(this))));
   }
-
   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_vrVSyncProvider.reset();
   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));
-  }
+  ConnectVSyncProvider();
   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 365 matching lines @@
                  kWebVrPosePixelMagicNumbers[1] / 255.0f, 1.0f);
   gl->Clear(GL_COLOR_BUFFER_BIT);
 
   // Set the GL state back to what was set by the WebVR application.
   m_renderingContext->restoreScissorEnabled();
   m_renderingContext->restoreScissorBox();
   m_renderingContext->restoreColorMask();
   m_renderingContext->restoreClearColor();
 
   m_display->SubmitFrame(m_framePose.Clone());
-  m_canUpdateFramePose = true;
 }
 
 Document* VRDisplay::document() {
   return m_navigatorVR->document();
 }
 
 void VRDisplay::OnPresentChange() {
   if (m_isPresenting && !m_isValidDeviceForPresenting) {
     VLOG(1) << __FUNCTION__ << ": device not valid, not sending event";
     return;
@@ skipping 24 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::OnVSync(device::mojom::blink::VRPosePtr pose,
+                        mojo::common::mojom::blink::TimeDeltaPtr time) {
+  WTF::TimeDelta timeDelta =
+      WTF::TimeDelta::FromMicroseconds(time->microseconds);
+  // The VSync provider cannot shut down before replying to pending callbacks,
+  // so it will send a null pose with no timestamp to be ignored.
+  if (pose.is_null() && timeDelta == WTF::TimeDelta()) {

[haraken, 2017/01/19 00:49:56]

Just help me understand: What does 'timeDelta == WTF::TimeDelta()' mean?

[mthiesse, 2017/01/19 00:54:04]

This is checking that the timeDelta default initialized, or set to 0, which is
used as a signal that this isn't actually a vsync, but we were forced to respond
to the callback regardless and had to send *something*.

[dcheng, 2017/01/19 22:16:11]

Can we write this as is_zero()?

[mthiesse, 2017/01/19 22:56:49]

Done.

+    // We need to keep the VSync loop going because we haven't responded to the
+    // previous rAF yet.
+    m_vrVSyncProvider->GetVSync(convertToBaseCallback(
+        WTF::bind(&VRDisplay::OnVSync, wrapWeakPersistent(this))));
+    return;
+  }
+  if (m_displayBlurred)
+    return;
+  if (!m_scriptedAnimationController)
+    return;
+  Document* doc = this->document();
+  if (!doc)
+    return;
+
+  // 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_pendingRaf = false;
+  m_scriptedAnimationController->serviceScriptedAnimations(
+      m_timebase + timeDelta.InSecondsF());
+}
+
+void VRDisplay::ConnectVSyncProvider() {
+  m_display->GetVRVSyncProvider(mojo::MakeRequest(&m_vrVSyncProvider));
+  if (m_pendingRaf && !m_displayBlurred) {
+    m_vrVSyncProvider->GetVSync(convertToBaseCallback(
+        WTF::bind(&VRDisplay::OnVSync, wrapWeakPersistent(this))));
+  }
+}
+
 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_vrVSyncProvider.reset();
 }
 
 ExecutionContext* VRDisplay::getExecutionContext() const {
   return ContextLifecycleObserver::getExecutionContext();
 }
 
 const AtomicString& VRDisplay::interfaceName() const {
   return EventTargetNames::VRDisplay;
 }
 
@@ skipping 16 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