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 52 matching lines @@
     : m_navigatorVR(navigatorVR),
       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),
       m_display(std::move(display)),
       m_binding(this, std::move(request)) {
   ThreadState::current()->registerPreFinalizer(this);
 }
 
 VRDisplay::~VRDisplay() {}
 
 VRController* VRDisplay::controller() {
@@ skipping 25 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) {
+    // 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;
   }
 }
@@ skipping 29 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;
+
+  // 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,
@@ skipping 370 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