Allow VRDisplay to specify which frame the layer bounds should be updated at.

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 482 matching lines @@
     rightBounds->height = m_layer.rightBounds()[3];
   } else {
     // Right eye defaults
     rightBounds->left = 0.5f;
     rightBounds->top = 0.0f;
     rightBounds->width = 0.5f;
     rightBounds->height = 1.0f;
     m_layer.setRightBounds({0.5f, 0.0f, 0.5f, 1.0f});
   }
 
-  m_display->UpdateLayerBounds(std::move(leftBounds), std::move(rightBounds));
+  m_display->UpdateLayerBounds(m_frameId, std::move(leftBounds),
+                               std::move(rightBounds));
 }
 
 HeapVector<VRLayer> VRDisplay::getLayers() {
   HeapVector<VRLayer> layers;
 
   if (m_isPresenting) {
     layers.push_back(m_layer);
   }
 
   return layers;
@@ skipping 21 matching lines @@
                                  "VRDisplay.requestAnimationFrame callback."));
     }
     return;
   }
 
   if (!m_contextGL) {
     // Something got confused, we can't submit frames without a GL context.
     return;
   }
 
+  // No frame Id to write before submitting the frame.
+  if (m_frameId < 0) {
+    m_display->SubmitFrame(m_framePose.Clone());
+    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.
   // Use the low byte of the index as the red component, and store an arbitrary
   // magic number in green/blue. This number must match the reading code in
   // vr_shell.cc. Avoid all-black/all-white.
-  gl->ClearColor((idx & 255) / 255.0f, kWebVrPosePixelMagicNumbers[0] / 255.0f,
+  gl->ClearColor((m_frameId & 255) / 255.0f,
+                 kWebVrPosePixelMagicNumbers[0] / 255.0f,
                  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());
@@ skipping 35 matching lines @@
       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) {
+                        mojo::common::mojom::blink::TimeDeltaPtr time,
+                        int16_t frameId) {
   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.is_zero()) {
     // 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_frameId = frameId;
   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))));
@@ skipping 76 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