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

chrome/browser/android/vr_shell/vr_shell_gl.cc

 // 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 "chrome/browser/android/vr_shell/vr_shell_gl.h"
 
 #include <utility>
 
 #include "base/android/jni_android.h"
 #include "base/memory/ptr_util.h"
@@ skipping 68 matching lines @@
 // is currently sized to fit the WebVR "insecure transport" warnings,
 // adjust it as needed if there is additional content.
 static constexpr gvr::Sizei kHeadlockedBufferDimensions = {1024, 1024};
 static constexpr gvr::Rectf kHeadlockedBufferFov = {20.f, 20.f, 20.f, 20.f};
 
 // The GVR viewport list has two entries (left eye and right eye) for each
 // GVR buffer.
 static constexpr int kViewportListPrimaryOffset = 0;
 static constexpr int kViewportListHeadlockedOffset = 2;
 
+// Buffer size large enough to handle the current backlog of poses which is
+// 2-3 frames.
+static constexpr unsigned kPoseRingBufferSize = 8;
+
 // Magic numbers used to mark valid pose index values encoded in frame
 // data. Must match the magic numbers used in blink's VRDisplay.cpp.
 static constexpr std::array<uint8_t, 2> kWebVrPosePixelMagicNumbers{{42, 142}};
 
 float Distance(const gvr::Vec3f& vec1, const gvr::Vec3f& vec2) {
   float xdiff = (vec1.x - vec2.x);
   float ydiff = (vec1.y - vec2.y);
   float zdiff = (vec1.z - vec2.z);
   float scale = xdiff * xdiff + ydiff * ydiff + zdiff * zdiff;
   return std::sqrt(scale);
@@ skipping 69 matching lines @@
         content_input_manager_(content_input_manager),
         ui_input_manager_(ui_input_manager),
         delegate_provider_(delegate_provider),
         main_thread_task_runner_(std::move(main_thread_task_runner)),
         weak_ptr_factory_(this) {
   GvrInit(gvr_api);
 }
 
 VrShellGl::~VrShellGl() {
   vsync_task_.Cancel();
-  if (!callback_.is_null())
-    callback_.Run(nullptr, base::TimeDelta());
+  if (!callback_.is_null()) {
+    callback_.Run(nullptr, base::TimeDelta(), -1);
+    callback_.Reset();
+  }
   if (binding_.is_bound()) {
     main_thread_task_runner_->PostTask(FROM_HERE, base::Bind(
         &VrShellDelegate::OnVRVsyncProviderRequest, delegate_provider_,
         base::Passed(binding_.Unbind())));
   }
 }
 
 void VrShellGl::Initialize() {
   scene_.reset(new UiScene);
 
@@ skipping 71 matching lines @@
 
 void VrShellGl::OnUIFrameAvailable() {
   ui_surface_texture_->UpdateTexImage();
 }
 
 void VrShellGl::OnContentFrameAvailable() {
   content_surface_texture_->UpdateTexImage();
   received_frame_ = true;
 }
 
-bool VrShellGl::GetPixelEncodedPoseIndexByte(int* pose_index) {
-  TRACE_EVENT0("gpu", "VrShellGl::GetPixelEncodedPoseIndex");
+bool VrShellGl::GetPixelEncodedFrameIndex(uint16_t* frame_index) {
+  TRACE_EVENT0("gpu", "VrShellGl::GetPixelEncodedFrameIndex");
   if (!received_frame_) {
-    *pose_index = last_pose_;
+    if (last_frame_index_ == -1)
+      return false;
+    *frame_index = last_frame_index_;
     return true;
   }
   received_frame_ = false;
 
   // Read the pose index encoded in a bottom left pixel as color values.
   // See also third_party/WebKit/Source/modules/vr/VRDisplay.cpp which
   // encodes the pose index, and device/vr/android/gvr/gvr_device.cc
   // which tracks poses. Returns the low byte (0..255) if valid, or -1
   // if not valid due to bad magic number.
   uint8_t pixels[4];
   // Assume we're reading from the framebuffer we just wrote to.
   // That's true currently, we may need to use glReadBuffer(GL_BACK)
   // or equivalent if the rendering setup changes in the future.
   glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
 
   // Check for the magic number written by VRDevice.cpp on submit.
   // This helps avoid glitches from garbage data in the render
   // buffer that can appear during initialization or resizing. These
   // often appear as flashes of all-black or all-white pixels.
   if (pixels[1] == kWebVrPosePixelMagicNumbers[0] &&
       pixels[2] == kWebVrPosePixelMagicNumbers[1]) {
     // Pose is good.
-    *pose_index = pixels[0];
-    last_pose_ = pixels[0];
+    *frame_index = pixels[0];
+    last_frame_index_ = pixels[0];
     return true;
   }
   VLOG(1) << "WebVR: reject decoded pose index " << (int)pixels[0]
           << ", bad magic number " << (int)pixels[1] << ", "
           << (int)pixels[2];
   return false;
 }
 
 void VrShellGl::GvrInit(gvr_context* gvr_api) {
   gvr_api_ = gvr::GvrApi::WrapNonOwned(gvr_api);
@@ skipping 295 matching lines @@
 
   gvr::Frame frame = swap_chain_->AcquireFrame();
   if (!frame.is_valid()) {
     return;
   }
   frame.BindBuffer(kFramePrimaryBuffer);
   if (web_vr_mode_) {
     DrawWebVr();
   }
 
-  int pose_index;
+  uint16_t frame_index;
   gvr::Mat4f head_pose;
 
   // When using async reprojection, we need to know which pose was used in
   // the WebVR app for drawing this frame. Due to unknown amounts of
   // buffering in the compositor and SurfaceTexture, we read the pose number
   // from a corner pixel. There's no point in doing this for legacy
   // distortion rendering since that doesn't need a pose, and reading back
   // pixels is an expensive operation. TODO(klausw,crbug.com/655722): stop
   // doing this once we have working no-compositor rendering for WebVR.
   if (web_vr_mode_ && gvr_api_->GetAsyncReprojectionEnabled() &&
-      GetPixelEncodedPoseIndexByte(&pose_index)) {
-    head_pose = webvr_head_pose_[pose_index % kPoseRingBufferSize];
+      GetPixelEncodedFrameIndex(&frame_index)) {
+    static_assert(!((kPoseRingBufferSize - 1) & kPoseRingBufferSize),
+                  "kPoseRingBufferSize must be a power of 2");
+    head_pose = webvr_head_pose_[frame_index % kPoseRingBufferSize];
+    // Process all pending_bounds_ changes targeted for before this frame, being
+    // careful of wrapping frame indices.
+    static constexpr unsigned max =
+        std::numeric_limits<decltype(frame_index_)>::max();
+    static_assert(max > kPoseRingBufferSize * 2,
+                  "To detect wrapping, kPoseRingBufferSize must be smaller "
+                  "than half of frame_index_ range.");
+    while (!pending_bounds_.empty()) {
+      uint16_t index = pending_bounds_.front().first;
+      if (index < frame_index) index += max;

[dcheng, 2017/01/27 09:41:33]

Nit: a few more comments here could be helpful for future readers (explaining
the purpose of these two branches)

[mthiesse, 2017/01/27 16:15:31]

Done.

+      if (index > frame_index && index <= frame_index + kPoseRingBufferSize)
+        break;
+
+      const BoundsPair& bounds = pending_bounds_.front().second;
+      webvr_left_viewport_->SetSourceUv(bounds.first);
+      webvr_right_viewport_->SetSourceUv(bounds.second);
+      pending_bounds_.pop();
+    }
+    buffer_viewport_list_->SetBufferViewport(GVR_LEFT_EYE,
+                                             *webvr_left_viewport_);
+    buffer_viewport_list_->SetBufferViewport(GVR_RIGHT_EYE,
+                                             *webvr_right_viewport_);
   } else {
     gvr::ClockTimePoint target_time = gvr::GvrApi::GetTimePointNow();
     target_time.monotonic_system_time_nanos += kPredictionTimeWithoutVsyncNanos;
     head_pose = gvr_api_->GetHeadSpaceFromStartSpaceRotation(target_time);
   }
 
   gvr::Vec3f position = GetTranslation(head_pose);
   if (position.x == 0.0f && position.y == 0.0f && position.z == 0.0f) {
     // This appears to be a 3DOF pose without a neck model. Add one.
     // The head pose has redundant data. Assume we're only using the
@@ skipping 220 matching lines @@
   // Don't need face culling, depth testing, blending, etc. Turn it all off.
   glDisable(GL_CULL_FACE);
   glDepthMask(GL_FALSE);
   glDisable(GL_DEPTH_TEST);
   glDisable(GL_SCISSOR_TEST);
   glDisable(GL_BLEND);
   glDisable(GL_POLYGON_OFFSET_FILL);
 
   glViewport(0, 0, render_size_primary_.width, render_size_primary_.height);
   vr_shell_renderer_->GetWebVrRenderer()->Draw(webvr_texture_id_);
-
-  buffer_viewport_list_->SetBufferViewport(GVR_LEFT_EYE,
-                                           *webvr_left_viewport_);
-  buffer_viewport_list_->SetBufferViewport(GVR_RIGHT_EYE,
-                                           *webvr_right_viewport_);
 }
 
 void VrShellGl::OnTriggerEvent() {
   // Set a flag to handle this on the render thread at the next frame.
   touch_pending_ = true;
 }
 
 void VrShellGl::OnPause() {
   vsync_task_.Cancel();
   controller_->OnPause();
   gvr_api_->PauseTracking();
 }
 
 void VrShellGl::OnResume() {
   gvr_api_->RefreshViewerProfile();
   gvr_api_->ResumeTracking();
   controller_->OnResume();
   if (ready_to_draw_) {
     vsync_task_.Reset(base::Bind(&VrShellGl::OnVSync, base::Unretained(this)));
     OnVSync();
   }
 }
 
 void VrShellGl::SetWebVrMode(bool enabled) {
   web_vr_mode_ = enabled;
 }
 
-void VrShellGl::UpdateWebVRTextureBounds(const gvr::Rectf& left_bounds,
+void VrShellGl::UpdateWebVRTextureBounds(int16_t frame_index,
+                                         const gvr::Rectf& left_bounds,
                                          const gvr::Rectf& right_bounds) {
-  webvr_left_viewport_->SetSourceUv(left_bounds);
-  webvr_right_viewport_->SetSourceUv(right_bounds);
+  if (frame_index < 0) {
+    webvr_left_viewport_->SetSourceUv(left_bounds);
+    webvr_right_viewport_->SetSourceUv(right_bounds);
+  } else {
+    pending_bounds_.emplace(
+        std::make_pair(frame_index, std::make_pair(left_bounds, right_bounds)));
+  }
 }
 
 gvr::GvrApi* VrShellGl::gvr_api() {
   return gvr_api_.get();
 }
 
 void VrShellGl::ContentBoundsChanged(int width, int height) {
   TRACE_EVENT0("gpu", "VrShellGl::ContentBoundsChanged");
   content_tex_css_width_ = width;
   content_tex_css_height_ = height;
@@ skipping 30 matching lines @@
   if (vsync_interval_.is_zero())
     return;
   target = now + vsync_interval_;
   int64_t intervals = (target - vsync_timebase_) / vsync_interval_;
   target = vsync_timebase_ + intervals * vsync_interval_;
   task_runner_->PostDelayedTask(FROM_HERE, vsync_task_.callback(),
                                 target - now);
 
   base::TimeDelta time = intervals * vsync_interval_;
   if (!callback_.is_null()) {
-    callback_.Run(GetPose(), time);
+    SendVSync(time, callback_);
     callback_.Reset();
   } else {
     pending_vsync_ = true;
     pending_time_ = time;
   }
   DrawFrame();
 }
 
 void VrShellGl::OnRequest(device::mojom::VRVSyncProviderRequest request) {
   binding_.Close();
   binding_.Bind(std::move(request));
 }
 
 void VrShellGl::GetVSync(const GetVSyncCallback& callback) {
   if (!pending_vsync_) {
     if (!callback_.is_null()) {
       mojo::ReportBadMessage("Requested VSync before waiting for response to "
           "previous request.");
       return;
     }
     callback_ = callback;
     return;
   }
   pending_vsync_ = false;
-  callback.Run(GetPose(), pending_time_);
+  SendVSync(pending_time_, callback);
 }
 
 void VrShellGl::UpdateVSyncInterval(long timebase_nanos,
                                     double interval_seconds) {
   vsync_timebase_ = base::TimeTicks();
   vsync_timebase_ += base::TimeDelta::FromMicroseconds(timebase_nanos / 1000);
   vsync_interval_ = base::TimeDelta::FromSecondsD(interval_seconds);
   vsync_task_.Reset(base::Bind(&VrShellGl::OnVSync, base::Unretained(this)));
   OnVSync();
 }
 
 void VrShellGl::ForceExitVr() {
   main_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VrShell::ForceExitVr, weak_vr_shell_));
 }
 
 void VrShellGl::UpdateScene(std::unique_ptr<base::ListValue> commands) {
   scene_->HandleCommands(std::move(commands), TimeInMicroseconds());
 }
 
-device::mojom::VRPosePtr VrShellGl::GetPose() {
-  TRACE_EVENT0("input", "VrShellGl::GetPose");
+void VrShellGl::SendVSync(base::TimeDelta time,
+                          const GetVSyncCallback& callback) {
+  TRACE_EVENT0("input", "VrShellGl::SendVSync");
+
+  uint8_t frame_index = frame_index_++;
 
   gvr::ClockTimePoint target_time = gvr::GvrApi::GetTimePointNow();
   target_time.monotonic_system_time_nanos += kPredictionTimeWithoutVsyncNanos;
 
   gvr::Mat4f head_mat =
       gvr_api_->GetHeadSpaceFromStartSpaceRotation(target_time);
   head_mat = gvr_api_->ApplyNeckModel(head_mat, 1.0f);
 
-  uint32_t pose_index = pose_index_++;
-  webvr_head_pose_[pose_index % kPoseRingBufferSize] = head_mat;
+  webvr_head_pose_[frame_index % kPoseRingBufferSize] = head_mat;
 
-  return VrShell::VRPosePtrFromGvrPose(head_mat, pose_index);
+  callback.Run(VrShell::VRPosePtrFromGvrPose(head_mat), time, frame_index);
 }
 
 }  // namespace vr_shell