Add menu mode plumbing for WebVR mode.

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 <limits>
 #include <utility>
 
 #include "base/android/jni_android.h"
@@ skipping 457 matching lines @@
                                            webvr_right_viewport_.get());
   webvr_right_viewport_->SetSourceBufferIndex(kFramePrimaryBuffer);
 
   main_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VrShell::GvrDelegateReady, weak_vr_shell_));
 }
 
 void VrShellGl::UpdateController(const gvr::Vec3f& forward_vector) {
   controller_->UpdateState();
 
-  if (web_vr_mode_) {
+  if (ShouldDrawWebVr()) {
     // Process screen touch events for Cardboard button compatibility.
     // Also send tap events for controller "touchpad click" events.
     if (touch_pending_ ||
         controller_->ButtonUpHappened(
             gvr::ControllerButton::GVR_CONTROLLER_BUTTON_CLICK)) {
       touch_pending_ = false;
       std::unique_ptr<WebGestureEvent> gesture(new WebGestureEvent(
           WebInputEvent::GestureTapDown, WebInputEvent::NoModifiers,
           (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF()));
       gesture->sourceDevice = blink::WebGestureDeviceTouchpad;
@@ skipping 221 matching lines @@
 void VrShellGl::DrawFrame(int16_t frame_index) {
   TRACE_EVENT1("gpu", "VrShellGl::DrawFrame", "frame", frame_index);
 
   // Reset the viewport list to just the pair of viewports for the
   // primary buffer each frame. Head-locked viewports get added by
   // DrawVrShell if needed.
   buffer_viewport_list_->SetToRecommendedBufferViewports();
 
   // If needed, resize the primary buffer for use with WebVR. Resizing
   // needs to happen before acquiring a frame.
-  if (web_vr_mode_) {
+  if (ShouldDrawWebVr()) {
     // Process all pending_bounds_ changes targeted for before this
     // frame, being careful of wrapping frame indices.
+    // TODO(crbug.com/680253): Do not compare the constants on every frame.

[mthiesse, 2017/03/20 17:32:16]

Note that this is a static assert and is checked by the compiler, not run on
every frame.

[cjgrant, 2017/03/20 17:57:22]

Done. Sweet, I learned something cool today!

     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 is less than the frame_index it's possible we've
       // wrapped, so we extend the range and 'un-wrap' to account
       // for this.
@@ skipping 39 matching lines @@
   }
 
   TRACE_EVENT_BEGIN0("gpu", "VrShellGl::AcquireFrame");
   gvr::Frame frame = swap_chain_->AcquireFrame();
   TRACE_EVENT_END0("gpu", "VrShellGl::AcquireFrame");
   if (!frame.is_valid()) {
     return;
   }
   frame.BindBuffer(kFramePrimaryBuffer);
 
-  if (web_vr_mode_) {
+  if (ShouldDrawWebVr()) {
     DrawWebVr();
   }
 
   gvr::Mat4f head_pose;
 
   // When using async reprojection, we need to know which pose was
   // used in the WebVR app for drawing this frame and supply it when
   // submitting. Technically we don't need a pose if not reprojecting,
   // but keeping it uninitialized seems likely to cause problems down
   // the road. Copying it is cheaper than fetching a new one.
-  if (web_vr_mode_) {
+  if (ShouldDrawWebVr()) {
+    // TODO(crbug.com/680253): Do not compare the constants on every frame.

[mthiesse, 2017/03/20 17:32:16]

Same as above.

     static_assert(!((kPoseRingBufferSize - 1) & kPoseRingBufferSize),
                   "kPoseRingBufferSize must be a power of 2");
     head_pose = webvr_head_pose_[frame_index % kPoseRingBufferSize];
   } 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);
@@ skipping 40 matching lines @@
   for (const auto& rect : scene_->GetUiElements()) {
     if (!rect->IsVisible())
       continue;
     if (rect->computed_lock_to_fov) {
       head_locked_elements.push_back(rect.get());
     } else {
       world_elements.push_back(rect.get());
     }
   }
 
-  if (web_vr_mode_) {
+  if (ShouldDrawWebVr()) {
     // WebVR is incompatible with 3D world compositing since the
     // depth buffer was already populated with unknown scaling - the
     // WebVR app has full control over zNear/zFar. Just leave the
     // existing content in place in the primary buffer without
     // clearing. Currently, there aren't any world elements in WebVR
     // mode, this will need further testing if those get added
     // later.
   } else {
     // Non-WebVR mode, enable depth testing and clear the primary buffers.
     glEnable(GL_CULL_FACE);
     glEnable(GL_DEPTH_TEST);
     glDepthMask(GL_TRUE);
 
     const Colorf& backgroundColor = scene_->GetBackgroundColor();
     glClearColor(backgroundColor.r, backgroundColor.g, backgroundColor.b,
                  backgroundColor.a);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   }
   if (!world_elements.empty()) {
-    DrawUiView(&head_pose, world_elements, render_size_primary_,
-               kViewportListPrimaryOffset);
+    DrawUiView(head_pose, world_elements, render_size_primary_,
+               kViewportListPrimaryOffset, !ShouldDrawWebVr());
   }
   frame.Unbind();  // Done with the primary buffer.
 
   if (!head_locked_elements.empty()) {
     // Add head-locked viewports. The list gets reset to just
     // the recommended viewports (for the primary buffer) each frame.
     buffer_viewport_list_->SetBufferViewport(
         kViewportListHeadlockedOffset + GVR_LEFT_EYE,
         *headlocked_left_viewport_);
     buffer_viewport_list_->SetBufferViewport(
         kViewportListHeadlockedOffset + GVR_RIGHT_EYE,
         *headlocked_right_viewport_);
 
     // Bind the headlocked framebuffer.
     frame.BindBuffer(kFrameHeadlockedBuffer);
     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-    DrawUiView(nullptr, head_locked_elements, render_size_headlocked_,
-               kViewportListHeadlockedOffset);
+    gvr::Mat4f identity_matrix;
+    SetIdentityM(identity_matrix);
+    DrawUiView(identity_matrix, head_locked_elements, render_size_headlocked_,
+               kViewportListHeadlockedOffset, false);
     frame.Unbind();  // Done with the headlocked buffer.
   }
 }
 
-void VrShellGl::DrawUiView(const gvr::Mat4f* head_pose,
+void VrShellGl::DrawUiView(const gvr::Mat4f& head_pose,
                            const std::vector<const ContentRectangle*>& elements,
                            const gvr::Sizei& render_size,
-                           int viewport_offset) {
+                           int viewport_offset,
+                           bool draw_cursor) {
   TRACE_EVENT0("gpu", "VrShellGl::DrawUiView");
 
-  gvr::Mat4f view_matrix;
-  if (head_pose) {
-    view_matrix = *head_pose;
-  } else {
-    SetIdentityM(view_matrix);
-  }
-  auto elementsInDrawOrder = GetElementsInDrawOrder(view_matrix, elements);
+  auto elementsInDrawOrder = GetElementsInDrawOrder(head_pose, elements);
 
   for (auto eye : {GVR_LEFT_EYE, GVR_RIGHT_EYE}) {
     buffer_viewport_list_->GetBufferViewport(eye + viewport_offset,
                                              buffer_viewport_.get());
 
     const gvr::Mat4f eye_view_matrix =
-        MatrixMul(gvr_api_->GetEyeFromHeadMatrix(eye), view_matrix);
+        MatrixMul(gvr_api_->GetEyeFromHeadMatrix(eye), head_pose);
 
     gvr::Recti pixel_rect =
         CalculatePixelSpaceRect(render_size, buffer_viewport_->GetSourceUv());
     glViewport(pixel_rect.left, pixel_rect.bottom,
                pixel_rect.right - pixel_rect.left,
                pixel_rect.top - pixel_rect.bottom);
 
     const gvr::Mat4f render_matrix =
         MatrixMul(PerspectiveMatrixFromView(buffer_viewport_->GetSourceFov(),
                                             kZNear, kZFar),
                   eye_view_matrix);
 
-    DrawElements(render_matrix, eye_view_matrix, elementsInDrawOrder);
-    if (head_pose != nullptr && !web_vr_mode_) {
+    DrawElements(render_matrix, elementsInDrawOrder);
+    if (draw_cursor) {
       DrawCursor(render_matrix);
     }
   }
 }
 
 void VrShellGl::DrawElements(
     const gvr::Mat4f& view_proj_matrix,
-    const gvr::Mat4f& view_matrix,
     const std::vector<const ContentRectangle*>& elements) {
   for (const auto* rect : elements) {
     gvr::Mat4f transform = MatrixMul(view_proj_matrix, rect->TransformMatrix());
 
     switch (rect->fill) {
       case Fill::SPRITE: {
         Rectf copy_rect;
         copy_rect.x = static_cast<float>(rect->copy_rect.x) / ui_tex_css_width_;
         copy_rect.y =
             static_cast<float>(rect->copy_rect.y) / ui_tex_css_height_;
@@ skipping 134 matching lines @@
 
     // Move the beam origin to the hand.
     TranslateM(face_transform, face_transform, kHandPosition.x, kHandPosition.y,
                kHandPosition.z);
 
     transform = MatrixMul(render_matrix, face_transform);
     vr_shell_renderer_->GetLaserRenderer()->Draw(transform);
   }
 }
 
+bool VrShellGl::ShouldDrawWebVr() {
+  return web_vr_mode_ && scene_->GetWebVrRenderingEnabled();
+}
+
 void VrShellGl::DrawWebVr() {
   TRACE_EVENT0("gpu", "VrShellGl::DrawWebVr");
   // 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);
 
@@ skipping 96 matching lines @@
   task_runner_->PostDelayedTask(FROM_HERE, vsync_task_.callback(),
                                 target - now);
 
   base::TimeDelta time = intervals * vsync_interval_;
   if (!callback_.is_null()) {
     SendVSync(time, base::ResetAndReturn(&callback_));
   } else {
     pending_vsync_ = true;
     pending_time_ = time;
   }
-  if (!web_vr_mode_) {
+  if (!ShouldDrawWebVr()) {
     DrawFrame(-1);
   }
 }
 
 void VrShellGl::OnRequest(device::mojom::VRVSyncProviderRequest request) {
   binding_.Close();
   binding_.Bind(std::move(request));
 }
 
 void VrShellGl::GetVSync(const GetVSyncCallback& callback) {
@@ skipping 62 matching lines @@
   // appropriate recommended render resolution as the default size during
   // InitializeGl. Revisit if the initialization order changes.
   device::mojom::VRDisplayInfoPtr info = VrShell::CreateVRDisplayInfo(
       gvr_api_.get(), webvr_surface_size_, device_id);
   main_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RunVRDisplayInfoCallback, callback, base::Passed(&info)));
 }
 
 }  // namespace vr_shell