Allow VRDisplay to manage it's own rAF callbacks

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"
 #include "core/frame/UseCounter.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "modules/vr/NavigatorVR.h"
 #include "modules/vr/VRController.h"
 #include "modules/vr/VRDisplayCapabilities.h"
 #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"
 
 namespace blink {
 
 namespace {
 
 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) {}
+  ~VRDisplayFrameRequestCallback() override {}
+  void handleEvent(double highResTimeMs) override {
+    m_vrDisplay->serviceScriptedAnimations(highResTimeMs);
+  }
+
+  DEFINE_INLINE_VIRTUAL_TRACE() {
+    visitor->trace(m_vrDisplay);
+
+    FrameRequestCallback::trace(visitor);
+  }
+
+  Member<VRDisplay> m_vrDisplay;
+};
+
 }  // namespace
 
 VRDisplay::VRDisplay(NavigatorVR* navigatorVR)
     : m_navigatorVR(navigatorVR),
       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_fullscreenCheckTimer(this, &VRDisplay::onFullscreenCheck),
+      m_animationCallbackRequested(false),
+      m_inAnimationFrame(false) {}
 
 VRDisplay::~VRDisplay() {}
 
 VRController* VRDisplay::controller() {
   return m_navigatorVR->controller();
 }
 
 void VRDisplay::update(const device::blink::VRDisplayPtr& display) {
   m_displayId = display->index;
   m_displayName = display->displayName;
@@ skipping 64 matching lines @@
     case VREyeLeft:
       return m_eyeParametersLeft;
     case VREyeRight:
       return m_eyeParametersRight;
     default:
       return nullptr;
   }
 }
 
 int VRDisplay::requestAnimationFrame(FrameRequestCallback* callback) {
-  // TODO: Use HMD-specific rAF when an external display is present.
+  Document* doc = m_navigatorVR->document();
+  if (!doc)
+    return 0;
+
+  if (!m_animationCallbackRequested) {
+    doc->requestAnimationFrame(new VRDisplayFrameRequestCallback(this));
+    m_animationCallbackRequested = true;
+  }
+
   callback->m_useLegacyTimeBase = false;
-  if (Document* doc = m_navigatorVR->document())
-    return doc->requestAnimationFrame(callback);
-  return 0;
+  return ensureScriptedAnimationController(doc).registerCallback(callback);
 }
 
 void VRDisplay::cancelAnimationFrame(int id) {
-  if (Document* document = m_navigatorVR->document())
-    document->cancelAnimationFrame(id);
+  if (!m_scriptedAnimationController)
+    return;
+  m_scriptedAnimationController->cancelCallback(id);
+}
+
+void VRDisplay::serviceScriptedAnimations(double monotonicAnimationStartTime) {
+  if (!m_scriptedAnimationController)
+    return;
+  AutoReset<bool> animating(&m_inAnimationFrame, true);
+  m_animationCallbackRequested = false;
+  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)));
@@ skipping 214 matching lines @@
   HeapVector<VRLayer> layers;
 
   if (m_isPresenting) {
     layers.append(m_layer);
   }
 
   return layers;
 }
 
 void VRDisplay::submitFrame() {
-  if (!m_isPresenting || !m_contextGL) {
-    // Something got confused, we can't submit frames if we're not presenting.
+  Document* doc = m_navigatorVR->document();
+  if (!m_isPresenting) {
+    if (doc) {
+      doc->addConsoleMessage(ConsoleMessage::create(
+          RenderingMessageSource, WarningMessageLevel,
+          "submitFrame has no effect when the VRDisplay is not presenting."));
+    }
     return;
   }
 
+  if (!m_inAnimationFrame) {
+    if (doc) {
+      doc->addConsoleMessage(
+          ConsoleMessage::create(RenderingMessageSource, WarningMessageLevel,
+                                 "submitFrame must be called within a "
+                                 "VRDisplay.requestAnimationFrame callback."));
+    }
+    return;
+  }
+
+  if (!m_contextGL) {
+    // Something got confused, we can't submit frames without a GL context.
+    return;
+  }
+
   // Write the frame number for the pose used into a bottom left pixel block.
   // It is read by chrome/browser/android/vr_shell/vr_shell.cc to associate
   // the correct corresponding pose for submission.
   auto gl = m_contextGL;
 
   // We must ensure that the WebGL app's GL state is preserved. We do this by
   // calling low-level GL commands directly so that the rendering context's
   // saved parameters don't get overwritten.
 
   gl->Enable(GL_SCISSOR_TEST);
@@ skipping 26 matching lines @@
   // become unnessecary. Until that point, though, this seems preferable to
   // adding a bunch of notification plumbing to Fullscreen.
   if (!Fullscreen::isCurrentFullScreenElement(*m_layer.source())) {
     m_isPresenting = false;
     m_navigatorVR->fireVRDisplayPresentChange(this);
     m_fullscreenCheckTimer.stop();
     controller()->exitPresent(m_displayId);
   }
 }
 
+ScriptedAnimationController& VRDisplay::ensureScriptedAnimationController(
+    Document* doc) {
+  if (!m_scriptedAnimationController)
+    m_scriptedAnimationController = ScriptedAnimationController::create(doc);
+
+  return *m_scriptedAnimationController;
+}
+
 DEFINE_TRACE(VRDisplay) {
   visitor->trace(m_navigatorVR);
   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