Implement WebVR presentation pausing for VR Shell Menu Mode

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/dom/DOMException.h"
 #include "core/dom/FrameRequestCallback.h"
 #include "core/dom/Fullscreen.h"
 #include "core/dom/ScriptedAnimationController.h"
@@ skipping 51 matching lines @@
       m_displayId(0),
       m_isConnected(false),
       m_isPresenting(false),
       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) {}
 
 VRDisplay::~VRDisplay() {}
 
 VRController* VRDisplay::controller() {
   return m_navigatorVR->controller();
 }
 
 void VRDisplay::update(const device::blink::VRDisplayPtr& display) {
@@ skipping 21 matching lines @@
 }
 
 void VRDisplay::disconnected() {
   if (m_isConnected)
     m_isConnected = !m_isConnected;
 }
 
 bool VRDisplay::getFrameData(VRFrameData* frameData) {
   updatePose();
 
+  if (!m_framePose)
+    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)
     return nullptr;
 
   VRPose* pose = VRPose::create();
   pose->setPose(m_framePose);
   return pose;
 }
 
 void VRDisplay::updatePose() {
+  if (m_displayBlurred) {
+    m_framePose = nullptr;

[dcheng, 2016/11/08 23:05:45]

Out of curiosity, why don't we just clear this in onDisplayBlur()?

VRDisplay seems like it's a state machine, so if it's possible to add some more
comments about how the different parts interact, that would help readability.
For someone who's not familiar with the WebVR spec, it can be difficult to
follow the flow of logic.

(Comments and/or pointers to the spec in the implementation can be done in a
followup though)

[mthiesse, 2016/11/10 22:14:10]

I clear it in updatePose simply for code clarity. The spec says to return a null
pose when the display is blurred.

I'll add a few comments for the parts I touched. I'll leave it to bajones@ to
improve readability on the rest, as I myself am not very familiar with spec and
added these changes on his request.

+    return;
+  }
   if (m_canUpdateFramePose) {
     m_framePose = controller()->getPose(m_displayId);
     if (m_isPresenting)
       m_canUpdateFramePose = false;
   }
 }
 
 void VRDisplay::resetPose() {
   controller()->resetPose(m_displayId);
 }
@@ skipping 22 matching lines @@
   callback->m_useLegacyTimeBase = false;
   return ensureScriptedAnimationController(doc).registerCallback(callback);
 }
 
 void VRDisplay::cancelAnimationFrame(int id) {
   if (!m_scriptedAnimationController)
     return;
   m_scriptedAnimationController->cancelCallback(id);
 }
 
+void VRDisplay::onDisplayBlur() {
+  m_displayBlurred = true;
+  m_navigatorVR->fireVrDisplayOnBlur(this);
+}
+
+void VRDisplay::onDisplayFocus() {
+  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 = m_navigatorVR->document();
+    if (!doc)
+      return;
+    doc->requestAnimationFrame(new VRDisplayFrameRequestCallback(this));
+  }
+  m_navigatorVR->fireVrDisplayOnFocus(this);
+}
+
 void VRDisplay::serviceScriptedAnimations(double monotonicAnimationStartTime) {
   if (!m_scriptedAnimationController)
     return;
   AutoReset<bool> animating(&m_inAnimationFrame, true);
   m_animationCallbackRequested = false;
+  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,
@@ skipping 307 matching lines @@
   visitor->trace(m_capabilities);
   visitor->trace(m_stageParameters);
   visitor->trace(m_eyeParametersLeft);
   visitor->trace(m_eyeParametersRight);
   visitor->trace(m_layer);
   visitor->trace(m_renderingContext);
   visitor->trace(m_scriptedAnimationController);
 }
 
 }  // namespace blink