Implement WebVR presentation pausing for VR Shell Menu Mode

chrome/browser/android/vr_shell/vr_shell.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.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "chrome/browser/android/vr_shell/ui_elements.h"
 #include "chrome/browser/android/vr_shell/ui_interface.h"
 #include "chrome/browser/android/vr_shell/ui_scene.h"
 #include "chrome/browser/android/vr_shell/vr_compositor.h"
 #include "chrome/browser/android/vr_shell/vr_controller.h"
 #include "chrome/browser/android/vr_shell/vr_gl_util.h"
 #include "chrome/browser/android/vr_shell/vr_input_manager.h"
 #include "chrome/browser/android/vr_shell/vr_shell_delegate.h"
 #include "chrome/browser/android/vr_shell/vr_shell_renderer.h"
 #include "chrome/browser/android/vr_shell/vr_web_contents_observer.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/referrer.h"
+#include "device/vr/android/gvr/gvr_device_provider.h"
 #include "jni/VrShellImpl_jni.h"
 #include "ui/android/view_android.h"
 #include "ui/android/window_android.h"
 #include "ui/base/page_transition_types.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/init/gl_factory.h"
 
 using base::android::JavaParamRef;
@@ skipping 96 matching lines @@
 namespace vr_shell {
 
 VrShell::VrShell(JNIEnv* env, jobject obj,
                  content::WebContents* main_contents,
                  ui::WindowAndroid* content_window,
                  content::WebContents* ui_contents,
                  ui::WindowAndroid* ui_window)
     : WebContentsObserver(ui_contents),
       main_contents_(main_contents),
       ui_contents_(ui_contents),
+      main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       weak_ptr_factory_(this) {
   DCHECK(g_instance == nullptr);
   g_instance = this;
   j_vr_shell_.Reset(env, obj);
   scene_.reset(new UiScene);
   html_interface_.reset(new UiInterface);
   content_compositor_.reset(new VrCompositor(content_window, false));
   ui_compositor_.reset(new VrCompositor(ui_window, true));
   vr_web_contents_observer_.reset(
       new VrWebContentsObserver(main_contents, html_interface_.get()));
@@ skipping 20 matching lines @@
   ui_contents_->GetController().LoadURL(
       url, content::Referrer(),
       ui::PageTransition::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string(""));
 }
 
 bool RegisterVrShell(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 VrShell::~VrShell() {
+  if (delegate_ && delegate_->GetDeviceProvider()) {
+    delegate_->GetDeviceProvider()->OnGvrDelegateRemoved();
+  }
   g_instance = nullptr;
   gl::init::ClearGLBindings();
 }
 
 void VrShell::SetDelegate(JNIEnv* env,
     const base::android::JavaParamRef<jobject>& obj,
     const base::android::JavaParamRef<jobject>& delegate) {
-  delegate_ = VrShellDelegate::getNativeDelegate(env, delegate);
+  base::AutoLock lock(gvr_init_lock_);
+  delegate_ = VrShellDelegate::GetNativeDelegate(env, delegate);
+  if (gvr_api_) {
+    main_thread_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&device::GvrDeviceProvider::OnGvrDelegateReady,
+                              delegate_->GetDeviceProvider(),
+                              weak_ptr_factory_.GetWeakPtr()));
+  }
 }
 
-enum class ViewerType
-{
+enum class ViewerType {
   UNKNOWN_TYPE = 0,
   CARDBOARD = 1,
   DAYDREAM = 2,
   VIEWER_TYPE_MAX,
 };
 
 void VrShell::GvrInit(JNIEnv* env,
                       const JavaParamRef<jobject>& obj,
                       jlong native_gvr_api) {
+  base::AutoLock lock(gvr_init_lock_);
   gvr_api_ =
       gvr::GvrApi::WrapNonOwned(reinterpret_cast<gvr_context*>(native_gvr_api));
 
-  if (delegate_)
-    delegate_->OnVrShellReady(this);
+  if (delegate_) {
+    main_thread_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&device::GvrDeviceProvider::OnGvrDelegateReady,
+                              delegate_->GetDeviceProvider(),
+                              weak_ptr_factory_.GetWeakPtr()));
+  }
   controller_.reset(
       new VrController(reinterpret_cast<gvr_context*>(native_gvr_api)));
   content_input_manager_ = new VrInputManager(main_contents_);
   ui_input_manager_ = new VrInputManager(ui_contents_);
 
   ViewerType viewerType;
-  switch (gvr_api_->GetViewerType())
-  {
+  switch (gvr_api_->GetViewerType()) {
     case gvr::ViewerType::GVR_VIEWER_TYPE_DAYDREAM:
       viewerType = ViewerType::DAYDREAM;
       break;
     case gvr::ViewerType::GVR_VIEWER_TYPE_CARDBOARD:
       viewerType = ViewerType::CARDBOARD;
       break;
     default:
       NOTREACHED();
       viewerType = ViewerType::UNKNOWN_TYPE;
       break;
@@ skipping 41 matching lines @@
       new gvr::BufferViewport(gvr_api_->CreateBufferViewport()));
   buffer_viewport_list_->GetBufferViewport(GVR_RIGHT_EYE,
                                            headlocked_right_viewport_.get());
   headlocked_right_viewport_->SetSourceBufferIndex(kFrameHeadlockedBuffer);
   headlocked_right_viewport_->SetReprojection(GVR_REPROJECTION_NONE);
 }
 
 void VrShell::UpdateController(const gvr::Vec3f& forward_vector) {
   controller_->UpdateState();
 
+#if defined(ENABLE_VR_SHELL)
+  // Note that button up/down state is transient, so IsButtonUp only returns
+  // true for a single frame (and we're guaranteed not to miss it).
+  if (controller_->IsButtonUp(
+      gvr::ControllerButton::GVR_CONTROLLER_BUTTON_APP)) {
+    if (html_interface_->GetMode() == UiInterface::Mode::MENU) {
+      // Temporary: Hit app button a second time to exit menu mode.
+      if (webvr_mode_) {
+        html_interface_->SetMode(UiInterface::Mode::WEB_VR);
+        main_thread_task_runner_->PostTask(
+            FROM_HERE, base::Bind(&device::GvrDeviceProvider::OnDisplayFocus,
+                                  delegate_->GetDeviceProvider()));
+      } else {
+        html_interface_->SetMode(UiInterface::Mode::STANDARD);
+      }
+    } else {
+      if (html_interface_->GetMode() == UiInterface::Mode::WEB_VR) {
+        main_thread_task_runner_->PostTask(
+            FROM_HERE, base::Bind(&device::GvrDeviceProvider::OnDisplayBlur,
+                                  delegate_->GetDeviceProvider()));
+      }
+      html_interface_->SetMode(UiInterface::Mode::MENU);
+      // TODO(mthiesse): The page is no longer visible here. We should unfocus
+      // or otherwise let it know it's hidden.
+    }
+  }
+#endif
+  if (html_interface_->GetMode() == UiInterface::Mode::WEB_VR) {
+    return;
+  }
+
   gvr::Vec3f ergo_neutral_pose;
   if (!controller_->IsConnected()) {
     // No controller detected, set up a gaze cursor that tracks the
     // forward direction.
     ergo_neutral_pose = {0.0f, 0.0f, -1.0f};
     controller_quat_ = GetRotationFromZAxis(forward_vector);
   } else {
     ergo_neutral_pose = {0.0f, -sin(kErgoAngleOffset), -cos(kErgoAngleOffset)};
     controller_quat_ = controller_->Orientation();
   }
@@ skipping 137 matching lines @@
 void VrShell::SetGvrPoseForWebVr(const gvr::Mat4f& pose, uint32_t pose_num) {
   webvr_head_pose_[pose_num % kPoseRingBufferSize] = pose;
 }
 
 uint32_t GetPixelEncodedPoseIndex() {
   // 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.
   uint8_t pixels[4];
-  // Assume we're reading from the frambebuffer we just wrote to.
+  // 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);
   return pixels[0] | (pixels[1] << 8) | (pixels[2] << 16);
 }
 
 void VrShell::DrawFrame(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   buffer_viewport_list_->SetToRecommendedBufferViewports();
 
   gvr::Frame frame = swap_chain_->AcquireFrame();
@@ skipping 17 matching lines @@
   frame.BindBuffer(kFramePrimaryBuffer);
 
   HandleQueuedTasks();
 
   // Update the render position of all UI elements (including desktop).
   const float screen_tilt = kDesktopScreenTiltDefault * M_PI / 180.0f;
   scene_->UpdateTransforms(screen_tilt, UiScene::TimeInMicroseconds());
 
   UpdateController(GetForwardVector(head_pose));
 
-  if (webvr_mode_) {
+  if (html_interface_->GetMode() == UiInterface::Mode::WEB_VR) {
     DrawWebVr();
 
     // 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): stop doing this once we
     // have working no-compositor rendering for WebVR.
     if (gvr_api_->GetAsyncReprojectionEnabled()) {
@@ skipping 16 matching lines @@
     if (!rect->visible) {
       continue;
     }
     if (rect->lock_to_fov) {
       head_locked_elements.push_back(rect.get());
     } else {
       world_elements.push_back(rect.get());
     }
   }
 
-  if (!webvr_mode_) {
+  bool not_web_vr = html_interface_->GetMode() != UiInterface::Mode::WEB_VR;
+
+  if (not_web_vr) {
     glEnable(GL_CULL_FACE);
     glEnable(GL_DEPTH_TEST);
     glEnable(GL_SCISSOR_TEST);
     glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
   }
 
-  if (!world_elements.empty()) {
-    DrawUiView(&head_pose, world_elements);
-  }
+  DrawUiView(&head_pose, world_elements, not_web_vr);
 
   if (!head_locked_elements.empty()) {
     // Switch to head-locked viewports.
     size_t last_viewport = buffer_viewport_list_->GetSize();
     buffer_viewport_list_->SetBufferViewport(last_viewport++,
         *headlocked_left_viewport_);
     buffer_viewport_list_->SetBufferViewport(last_viewport++,
         *headlocked_right_viewport_);
 
     // Bind the headlocked framebuffer.
     frame.BindBuffer(kFrameHeadlockedBuffer);
-    glClear(GL_COLOR_BUFFER_BIT);
-
-    DrawUiView(nullptr, head_locked_elements);
+    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+    DrawUiView(nullptr, head_locked_elements, true);
   }
 }
 
 void VrShell::DrawUiView(const gvr::Mat4f* head_pose,
-                         const std::vector<const ContentRectangle*>& elements) {
+                         const std::vector<const ContentRectangle*>& elements,
+                         bool clear) {
   for (auto eye : {GVR_LEFT_EYE, GVR_RIGHT_EYE}) {
     buffer_viewport_list_->GetBufferViewport(eye, buffer_viewport_.get());
 
     gvr::Mat4f view_matrix = gvr_api_->GetEyeFromHeadMatrix(eye);
     if (head_pose != nullptr) {
       view_matrix = MatrixMul(view_matrix, *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);
     glScissor(pixel_rect.left, pixel_rect.bottom,
               pixel_rect.right - pixel_rect.left,
               pixel_rect.top - pixel_rect.bottom);
 
-    if (!webvr_mode_) {
+    if (clear) {
       glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     }
 
     const gvr::Mat4f render_matrix = MatrixMul(
         PerspectiveMatrixFromView(
             buffer_viewport_->GetSourceFov(), kZNear, kZFar),
         view_matrix);
 
     DrawElements(render_matrix, elements);
-    if (head_pose != nullptr) {
+    if (head_pose != nullptr &&
+        html_interface_->GetMode() != UiInterface::Mode::WEB_VR) {
       DrawCursor(render_matrix);
     }
   }
 }
 
 void VrShell::DrawElements(
     const gvr::Mat4f& render_matrix,
     const std::vector<const ContentRectangle*>& elements) {
   for (const auto& rect : elements) {
     Rectf copy_rect;
@@ skipping 92 matching lines @@
 
 void VrShell::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);
 
-  // Don't need to clear, since we're drawing over the entire render target.
-  glClear(GL_COLOR_BUFFER_BIT);
-
   glViewport(0, 0, render_size_.width, render_size_.height);
   vr_shell_renderer_->GetWebVrRenderer()->Draw(content_texture_id_);
 }
 
 void VrShell::OnTriggerEvent(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   // Set a flag to handle this on the render thread at the next frame.
   touch_pending_ = true;
 }
 
 void VrShell::OnPause(JNIEnv* env, const JavaParamRef<jobject>& obj) {
@@ skipping 155 matching lines @@
            const JavaParamRef<jobject>& ui_web_contents,
            jlong ui_window_android) {
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, content::WebContents::FromJavaWebContents(content_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(content_window_android),
       content::WebContents::FromJavaWebContents(ui_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(ui_window_android)));
 }
 
 }  // namespace vr_shell