Clean up VR Shell mode transitions (and fix potential webvr startup race).

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"
@@ skipping 133 matching lines @@
 
 }  // namespace
 
 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)
+                 ui::WindowAndroid* ui_window,
+                 bool for_web_vr)
     : WebContentsObserver(ui_contents),
       main_contents_(main_contents),
       ui_contents_(ui_contents),
       metrics_helper_(new VrMetricsHelper(main_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);
+
+  if (for_web_vr)
+    metrics_helper_->SetWebVREnabled(true);
+  html_interface_.reset(new UiInterface(
+      for_web_vr ? UiInterface::Mode::WEB_VR : UiInterface::Mode::STANDARD));
   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()));
 
   LoadUIContent();
 
   gvr::Mat4f identity;
   SetIdentityM(identity);
   webvr_head_pose_.resize(kPoseRingBufferSize, identity);
@@ skipping 47 matching lines @@
   DAYDREAM = 2,
   VIEWER_TYPE_MAX,
 };
 
 void VrShell::GvrInit(JNIEnv* env,
                       const JavaParamRef<jobject>& obj,
                       jlong native_gvr_api) {
   base::AutoLock lock(gvr_init_lock_);
 
   // set the initial webvr state
-  metrics_helper_->SetWebVREnabled(webvr_mode_);
   metrics_helper_->SetVRActive(true);
 
   gvr_api_ =
       gvr::GvrApi::WrapNonOwned(reinterpret_cast<gvr_context*>(native_gvr_api));
   // TODO(klausw,crbug.com/655722): should report OnGvrDelegateReady here once
   // we switch to using a WebVR render surface. We currently need to wait for
   // the compositor window's size to be known first. See also
   // ContentSurfaceChanged.
   controller_.reset(
       new VrController(reinterpret_cast<gvr_context*>(native_gvr_api)));
@@ skipping 98 matching lines @@
   webvr_right_viewport_->SetSourceBufferIndex(kFramePrimaryBuffer);
 }
 
 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.
+          gvr::ControllerButton::GVR_CONTROLLER_BUTTON_APP)) {
+    html_interface_->SetMenuMode(!html_interface_->GetMenuMode());
+
+    // 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 (html_interface_->GetMode() == UiInterface::Mode::WEB_VR) {
     // Process screen touch events for Cardboard button compatibility.
     // Also send tap events for controller "touchpad click" events.
     if (touch_pending_ || controller_->IsButtonUp(
             gvr::ControllerButton::GVR_CONTROLLER_BUTTON_CLICK)) {
       touch_pending_ = false;
       std::unique_ptr<WebGestureEvent> gesture(new WebGestureEvent());
@@ skipping 514 matching lines @@
 
 void VrShell::OnDomContentsLoaded() {
   html_interface_->SetURL(main_contents_->GetVisibleURL());
   html_interface_->SetLoading(main_contents_->IsLoading());
   html_interface_->OnDomContentsLoaded();
 }
 
 void VrShell::SetWebVrMode(JNIEnv* env,
                            const base::android::JavaParamRef<jobject>& obj,
                            bool enabled) {
-  webvr_mode_ = enabled;
-  metrics_helper_->SetWebVREnabled(webvr_mode_);
+  metrics_helper_->SetWebVREnabled(enabled);
   if (enabled) {
     html_interface_->SetMode(UiInterface::Mode::WEB_VR);
   } else {
     html_interface_->SetMode(UiInterface::Mode::STANDARD);
   }
 }
 
 void VrShell::SetWebVRSecureOrigin(bool secure_origin) {
   html_interface_->SetSecureOrigin(secure_origin);
 }
 
-void VrShell::SubmitWebVRFrame() {
-}
+void VrShell::SubmitWebVRFrame() {}
 
 void VrShell::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* VrShell::gvr_api() {
   return gvr_api_.get();
 }
@@ skipping 80 matching lines @@
     case HISTORY_FORWARD:
       if (controller.CanGoForward())
         controller.GoForward();
       break;
     case RELOAD:
       controller.Reload(false);
       break;
 #if defined(ENABLE_VR_SHELL_UI_DEV)
     case RELOAD_UI:
       ui_contents_->GetController().Reload(false);
-      html_interface_.reset(new UiInterface);
-      html_interface_->SetMode(UiInterface::Mode::STANDARD);
+      html_interface_.reset(new UiInterface(UiInterface::Mode::STANDARD));
       vr_web_contents_observer_->SetUiInterface(html_interface_.get());
       break;
 #endif
     case ZOOM_OUT:  // Not handled yet.
     case ZOOM_IN:  // Not handled yet.
       break;
     default:
       NOTREACHED();
   }
 }
 
 void VrShell::RenderViewHostChanged(content::RenderViewHost* old_host,
                                     content::RenderViewHost* new_host) {
   new_host->GetWidget()->GetView()->SetBackgroundColor(SK_ColorTRANSPARENT);
 }
 
 // ----------------------------------------------------------------------------
 // Native JNI methods
 // ----------------------------------------------------------------------------
 
 jlong Init(JNIEnv* env,
            const JavaParamRef<jobject>& obj,
            const JavaParamRef<jobject>& content_web_contents,
            jlong content_window_android,
            const JavaParamRef<jobject>& ui_web_contents,
-           jlong ui_window_android) {
+           jlong ui_window_android,
+           jboolean for_web_vr) {
   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)));
+      reinterpret_cast<ui::WindowAndroid*>(ui_window_android),
+      for_web_vr));
 }
 
 }  // namespace vr_shell