Encode frame number in pixel data for pose sync

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/Fullscreen.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/UserGestureIndicator.h"
@@ skipping 177 matching lines @@
       m_layer.source()->renderingContext();
 
   if (!renderingContext || !renderingContext->is3d()) {
     forceExitPresent();
     DOMException* exception = DOMException::create(
         InvalidStateError, "Layer source must have a WebGLRenderingContext");
     resolver->reject(exception);
     return promise;
   }
 
+  // Save the WebGL script and underlying GL contexts for use by submitFrame().
+  m_renderingContext = toWebGLRenderingContextBase(renderingContext);
+  m_contextGL = m_renderingContext->contextGL();
+
   if ((m_layer.leftBounds().size() != 0 && m_layer.leftBounds().size() != 4) ||
       (m_layer.rightBounds().size() != 0 &&
        m_layer.rightBounds().size() != 4)) {
     forceExitPresent();
     DOMException* exception = DOMException::create(
         InvalidStateError,
         "Layer bounds must either be an empty array or have 4 values");
     resolver->reject(exception);
     return promise;
   }
@@ skipping 69 matching lines @@
     if (!m_capabilities->hasExternalDisplay()) {
       Fullscreen::fullyExitFullscreen(m_layer.source()->document());
       m_fullscreenCheckTimer.stop();
     } else {
       // Can't get into this presentation mode, so nothing to do here.
     }
     m_navigatorVR->fireVRDisplayPresentChange(this);
   }
 
   m_isPresenting = false;
+  m_renderingContext = nullptr;
+  m_contextGL = nullptr;
 }
 
 void VRDisplay::updateLayerBounds() {
   // Set up the texture bounds for the provided layer
   device::blink::VRLayerBoundsPtr leftBounds =
       device::blink::VRLayerBounds::New();
   device::blink::VRLayerBoundsPtr rightBounds =
       device::blink::VRLayerBounds::New();
 
   if (m_layer.leftBounds().size() == 4) {
@@ skipping 30 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.
+    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);
+  // Use a few pixels to ensure we get a clean color. The resolution for the
+  // WebGL buffer may not match the final rendered destination size, and
+  // texture filtering could interfere for single pixels. This isn't visible
+  // since the final rendering hides the edges via a vignette effect.
+  gl->Scissor(0, 0, 4, 4);
+  gl->ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+  int idx = m_framePose->poseIndex;
+  // Careful with the arithmetic here. Float color 1.f is equivalent to int 255.
+  gl->ClearColor((idx & 255) / 255.0f, ((idx >> 8) & 255) / 255.0f,
+                 ((idx >> 16) & 255) / 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();
+
   controller()->submitFrame(m_displayId, m_framePose.Clone());
   m_canUpdateFramePose = true;
 }
 
 void VRDisplay::onFullscreenCheck(TimerBase*) {
   // 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.
   if (!Fullscreen::isCurrentFullScreenElement(*m_layer.source())) {
     m_isPresenting = false;
     m_navigatorVR->fireVRDisplayPresentChange(this);
     m_fullscreenCheckTimer.stop();
     controller()->exitPresent(m_displayId);
   }
 }
 
 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);
 }
 
 }  // namespace blink