Clean up some VrShell threading issues and remove unnecessary WeakPtr types.

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 "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/thread_task_runner_handle.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_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_math.h"
 #include "chrome/browser/android/vr_shell/vr_shell.h"
 #include "chrome/browser/android/vr_shell/vr_shell_renderer.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "ui/gfx/vsync_provider.h"
 #include "ui/gl/android/scoped_java_surface.h"
@@ skipping 148 matching lines @@
 }
 
 int64_t TimeInMicroseconds() {
   return std::chrono::duration_cast<std::chrono::microseconds>(
       std::chrono::steady_clock::now().time_since_epoch()).count();
 }
 
 }  // namespace
 
 VrShellGl::VrShellGl(
-    VrShell* vr_shell,
     const base::WeakPtr<VrShell>& weak_vr_shell,
     const base::WeakPtr<VrInputManager>& content_input_manager,
     const base::WeakPtr<VrInputManager>& ui_input_manager,
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
-    gvr_context* gvr_api)
-      : task_runner_(base::ThreadTaskRunnerHandle::Get()),
-        vr_shell_(vr_shell),
+    gvr_context* gvr_api,
+    bool initially_web_vr)
+      : web_vr_mode_(initially_web_vr),
+        task_runner_(base::ThreadTaskRunnerHandle::Get()),
         weak_vr_shell_(weak_vr_shell),
         content_input_manager_(content_input_manager),
         ui_input_manager_(ui_input_manager),
         main_thread_task_runner_(std::move(main_thread_task_runner)),
         weak_ptr_factory_(this) {
   GvrInit(gvr_api);
 }
 
 VrShellGl::~VrShellGl() {
   draw_task_.Cancel();
@@ skipping 182 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 defined(ENABLE_VR_SHELL)
-  // TODO(mthiesse): Fix menu button handling, which should be posted to the UI
-  // thread instead of handled here.
 
   // Note that button up/down state is transient, so ButtonUpHappened only
   // returns true for a single frame (and we're guaranteed not to miss it).
   if (controller_->ButtonUpHappened(
           gvr::ControllerButton::GVR_CONTROLLER_BUTTON_APP)) {
-//    html_interface_->SetMenuMode(!html_interface_->GetMenuMode());
+    main_thread_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&VrShell::AppButtonPressed, weak_vr_shell_));
+  }
 
-    // TODO(mthiesse): The page is no longer visible when in menu mode. We
-    // should unfocus or otherwise let it know it's hidden.
-//    if (html_interface_->GetMode() == UiInterface::Mode::WEB_VR) {
-//      const auto&& task = html_interface_->GetMenuMode() ?
-//          &device::GvrDeviceProvider::OnDisplayBlur :
-//          &device::GvrDeviceProvider::OnDisplayFocus;
-//      main_thread_task_runner_->PostTask(
-//          FROM_HERE, base::Bind(task, delegate_->GetDeviceProvider()));
-//    }
-  }
-#endif
-  if (vr_shell_->GetUiInterface()->GetMode() == UiInterface::Mode::WEB_VR) {
+  if (web_vr_mode_) {
     // 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());
       gesture->sourceDevice = blink::WebGestureDeviceTouchpad;
       gesture->timeStampSeconds =
           (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
       gesture->type = WebInputEvent::GestureTapDown;
@@ skipping 210 matching lines @@
   }
 
   frame.BindBuffer(kFramePrimaryBuffer);
 
   // Update the render position of all UI elements (including desktop).
   const float screen_tilt = kDesktopScreenTiltDefault * M_PI / 180.0f;
   scene_->UpdateTransforms(screen_tilt, TimeInMicroseconds());
 
   UpdateController(GetForwardVector(head_pose));
 
-  if (vr_shell_->GetUiInterface()->GetMode() == UiInterface::Mode::WEB_VR) {
+  if (web_vr_mode_) {
     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,crbug.com/655722): stop
     // doing this once we have working no-compositor rendering for WebVR.
     if (gvr_api_->GetAsyncReprojectionEnabled()) {
@@ skipping 37 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 (vr_shell_->GetUiInterface()->GetMode() == UiInterface::Mode::WEB_VR) {
+  if (web_vr_mode_) {
     // 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);
@@ skipping 55 matching lines @@
     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),
         view_matrix);
 
     DrawElements(render_matrix, elements);
-    if (head_pose != nullptr &&
-        vr_shell_->GetUiInterface()->GetMode() != UiInterface::Mode::WEB_VR) {
+    if (head_pose != nullptr && !web_vr_mode_) {
       DrawCursor(render_matrix);
     }
   }
 }
 
 void VrShellGl::DrawElements(
     const gvr::Mat4f& render_matrix,
     const std::vector<const ContentRectangle*>& elements) {
   for (const auto& rect : elements) {
     Rectf copy_rect;
@@ skipping 121 matching lines @@
 
 void VrShellGl::OnResume() {
   gvr_api_->RefreshViewerProfile();
   gvr_api_->ResumeTracking();
   controller_->OnResume();
   draw_task_.Reset(base::Bind(&VrShellGl::DrawFrame, base::Unretained(this)));
   ScheduleNextDrawFrame();
 }
 
 void VrShellGl::SetWebVrMode(bool enabled) {
-  if (enabled) {
-    vr_shell_->GetUiInterface()->SetMode(UiInterface::Mode::WEB_VR);
-  } else {
-    vr_shell_->GetUiInterface()->SetMode(UiInterface::Mode::STANDARD);
-  }
+  web_vr_mode_ = enabled;
 }
 
 void VrShellGl::UpdateWebVRTextureBounds(const gvr::Rectf& left_bounds,
                                          const gvr::Rectf& right_bounds) {
   webvr_left_viewport_->SetSourceUv(left_bounds);
   webvr_right_viewport_->SetSourceUv(right_bounds);
 }
 
 gvr::GvrApi* VrShellGl::gvr_api() {
   return gvr_api_.get();
@@ skipping 52 matching lines @@
 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());
 }
 
 }  // namespace vr_shell