Swap to foreground tab when following links that open in a new tab/window in VR Shell.

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 <android/native_window_jni.h>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/android/vr_shell/ui_interface.h"
 #include "chrome/browser/android/vr_shell/vr_compositor.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_gl.h"
 #include "chrome/browser/android/vr_shell/vr_usage_monitor.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 "third_party/WebKit/public/platform/WebInputEvent.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"
 
 using base::android::JavaParamRef;
 using base::android::JavaRef;
 
 namespace vr_shell {
 
 namespace {
 vr_shell::VrShell* g_instance;
 
 static const char kVrShellUIURL[] = "chrome://vr-shell-ui";
 
 class GLThread : public base::Thread {
  public:
   GLThread(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,
            bool initially_web_vr,
            bool reprojected_rendering)
       : base::Thread("VrShellGL"),
         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)),
         gvr_api_(gvr_api),
         initially_web_vr_(initially_web_vr),
         reprojected_rendering_(reprojected_rendering) {}
 
   ~GLThread() override {
     Stop();
   }
   base::WeakPtr<VrShellGl> GetVrShellGl() { return weak_vr_shell_gl_; }
   VrShellGl* GetVrShellGlUnsafe() { return vr_shell_gl_.get(); }
 
  protected:
   void Init() override {
     vr_shell_gl_.reset(new VrShellGl(std::move(weak_vr_shell_),
-                                     std::move(content_input_manager_),
-                                     std::move(ui_input_manager_),
                                      std::move(main_thread_task_runner_),
                                      gvr_api_,
                                      initially_web_vr_,
                                      reprojected_rendering_));
     weak_vr_shell_gl_ = vr_shell_gl_->GetWeakPtr();
     vr_shell_gl_->Initialize();
   }
   void CleanUp() override {
     vr_shell_gl_.reset();
   }
 
  private:
   // Created on GL thread.
   std::unique_ptr<VrShellGl> vr_shell_gl_;
   base::WeakPtr<VrShellGl> weak_vr_shell_gl_;
 
   base::WeakPtr<VrShell> weak_vr_shell_;
-  base::WeakPtr<VrInputManager> content_input_manager_;
-  base::WeakPtr<VrInputManager> ui_input_manager_;
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
   gvr_context* gvr_api_;
   bool initially_web_vr_;
   bool reprojected_rendering_;
 };
 
+void SetIsInVR(content::WebContents* contents, bool is_in_vr) {
+  if (contents->GetRenderWidgetHostView())
+    contents->GetRenderWidgetHostView()->SetIsInVR(is_in_vr);
+}
+
 }  // namespace
 
 VrShell::VrShell(JNIEnv* env,
                  jobject obj,
                  content::WebContents* main_contents,
                  ui::WindowAndroid* content_window,
                  content::WebContents* ui_contents,
                  ui::WindowAndroid* ui_window,
                  bool for_web_vr,
                  VrShellDelegate* delegate,
                  gvr_context* gvr_api,
                  bool reprojected_rendering)
     : WebContentsObserver(ui_contents),
       main_contents_(main_contents),
-      content_compositor_(new VrCompositor(content_window, false)),
+      content_compositor_(
+          base::MakeUnique<VrCompositor>(content_window, false)),
       ui_contents_(ui_contents),
-      ui_compositor_(new VrCompositor(ui_window, true)),
+      ui_compositor_(base::MakeUnique<VrCompositor>(ui_window, true)),
       delegate_(delegate),
-      metrics_helper_(new VrMetricsHelper(main_contents_)),
+      metrics_helper_(base::MakeUnique<VrMetricsHelper>(main_contents_)),
       main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       reprojected_rendering_(reprojected_rendering),
       weak_ptr_factory_(this) {
   DCHECK(g_instance == nullptr);
   g_instance = this;
   j_vr_shell_.Reset(env, obj);
 
-  content_input_manager_.reset(new VrInputManager(main_contents_));
-  ui_input_manager_.reset(new VrInputManager(ui_contents_));
+  content_input_manager_ = base::MakeUnique<VrInputManager>(main_contents_);
+  ui_input_manager_ = base::MakeUnique<VrInputManager>(ui_contents_);
 
   content_compositor_->SetLayer(main_contents_);
   ui_compositor_->SetLayer(ui_contents_);
 
-  gl_thread_.reset(new GLThread(weak_ptr_factory_.GetWeakPtr(),
-                                content_input_manager_->GetWeakPtr(),
-                                ui_input_manager_->GetWeakPtr(),
-                                main_thread_task_runner_,
-                                gvr_api,
-                                for_web_vr,
-                                reprojected_rendering_));
+  gl_thread_ = base::MakeUnique<GLThread>(weak_ptr_factory_.GetWeakPtr(),
+                                          main_thread_task_runner_, gvr_api,
+                                          for_web_vr, reprojected_rendering_);
 
   base::Thread::Options options(base::MessageLoop::TYPE_DEFAULT, 0);
   options.priority = base::ThreadPriority::DISPLAY;
   gl_thread_->StartWithOptions(options);
 
   if (for_web_vr)
     metrics_helper_->SetWebVREnabled(true);
-  html_interface_.reset(new UiInterface(
+  html_interface_ = base::MakeUnique<UiInterface>(
       for_web_vr ? UiInterface::Mode::WEB_VR : UiInterface::Mode::STANDARD,
-      main_contents_->IsFullscreen()));
-  vr_web_contents_observer_.reset(new VrWebContentsObserver(
-      main_contents, html_interface_.get(), this));
+      main_contents_->IsFullscreen());
+  vr_web_contents_observer_ = base::MakeUnique<VrWebContentsObserver>(
+      main_contents_, html_interface_.get(), this);
 
-  SetIsInVR(true);
+  SetIsInVR(main_contents_, true);
 }
 
 void VrShell::Destroy(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   delete this;
 }
 
+void VrShell::SwapContents(JNIEnv* env, const JavaParamRef<jobject>& obj,
+                           const JavaParamRef<jobject>& web_contents) {
+  SetIsInVR(main_contents_, false);
+  content::WebContents* contents =
+      content::WebContents::FromJavaWebContents(web_contents);
+  main_contents_ = contents;
+  content_input_manager_ = base::MakeUnique<VrInputManager>(main_contents_);
+  content_compositor_->SetLayer(main_contents_);
+  vr_web_contents_observer_ = base::MakeUnique<VrWebContentsObserver>(
+      main_contents_, html_interface_.get(), this);
+  SetIsInVR(main_contents_, true);
+
+  // TODO(billorr): Make VrMetricsHelper tab-aware and able to track multiple
+  // tabs. crbug.com/684661
+  metrics_helper_ = base::MakeUnique<VrMetricsHelper>(main_contents_);
+  metrics_helper_->SetVRActive(true);
+  metrics_helper_->SetWebVREnabled(
+      html_interface_->GetMode() == UiInterface::Mode::WEB_VR);
+}
+
 void VrShell::LoadUIContent(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   GURL url(kVrShellUIURL);
   ui_contents_->GetController().LoadURL(
       url, content::Referrer(),
       ui::PageTransition::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string(""));
 }
 
 bool RegisterVrShell(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
@@ skipping 33 matching lines @@
                                              thread->GetVrShellGl()));
 }
 
 void VrShell::OnPause(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
   thread->task_runner()->PostTask(
       FROM_HERE, base::Bind(&VrShellGl::OnPause, thread->GetVrShellGl()));
 
   // exit vr session
   metrics_helper_->SetVRActive(false);
-  SetIsInVR(false);
+  SetIsInVR(main_contents_, false);
 }
 
 void VrShell::OnResume(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
   thread->task_runner()->PostTask(
       FROM_HERE, base::Bind(&VrShellGl::OnResume, thread->GetVrShellGl()));
 
   metrics_helper_->SetVRActive(true);
-  SetIsInVR(true);
+  SetIsInVR(main_contents_, true);
 }
 
 void VrShell::SetSurface(JNIEnv* env,
                          const JavaParamRef<jobject>& obj,
                          const JavaParamRef<jobject>& surface) {
   CHECK(!reprojected_rendering_);
   GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
   gfx::AcceleratedWidget window =
       ANativeWindow_fromSurface(base::android::AttachCurrentThread(), surface);
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::InitializeGl,
                                      thread->GetVrShellGl(),
                                      base::Unretained(window)));
 }
 
-void VrShell::SetIsInVR(bool is_in_vr) {
-  main_contents_->GetRenderWidgetHostView()->SetIsInVR(is_in_vr);
-}
-
 base::WeakPtr<VrShell> VrShell::GetWeakPtr(
     const content::WebContents* web_contents) {
   // Ensure that the WebContents requesting the VrShell instance is the one
   // we created.
   if (g_instance != nullptr && g_instance->ui_contents_ == web_contents)
     return g_instance->weak_ptr_factory_.GetWeakPtr();
   return base::WeakPtr<VrShell>(nullptr);
 }
 
 void VrShell::OnDomContentsLoaded() {
@@ skipping 191 matching lines @@
 
 void VrShell::ContentWebContentsDestroyed() {
   content_input_manager_.reset();
   main_contents_ = nullptr;
   // TODO(mthiesse): Handle web contents being destroyed.
   ForceExitVr();
 }
 
 void VrShell::ContentWasHidden() {
   // Ensure we don't continue sending input to it.
   content_input_manager_.reset();

[bshe, 2017/01/25 22:15:45]

Is there case that content was hidden but SwapContents was not called
afterwards? If not, perhaps you can just remove this function, since
content_input_manager_ is set to a new instance in SwapContents

[mthiesse, 2017/01/25 22:34:26]

I would rather not remove it. SwapContents will be called at some indeterminate
time in the future, and we don't want to keep sending input events while the
content is hidden.

Added the WasShown override as well in case the contents somehow come back.

-  // TODO(mthiesse): Handle web contents being hidden.
-  ForceExitVr();
 }
 
 void VrShell::ForceExitVr() {
   delegate_->ForceExitVr();
 }
 
 void VrShell::SetContentCssSize(float width, float height, float dpr) {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_VrShellImpl_setContentCssSize(env, j_vr_shell_.obj(), width, height,
                                      dpr);
 }
 
 void VrShell::SetUiCssSize(float width, float height, float dpr) {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_VrShellImpl_setUiCssSize(env, j_vr_shell_.obj(), width, height, dpr);
 }
 
+void VrShell::ProcessUIGesture(std::unique_ptr<blink::WebInputEvent> event) {
+  if (ui_input_manager_) {
+    ui_input_manager_->ProcessUpdatedGesture(std::move(event));
+  }
+
+}
+
+void VrShell::ProcessContentGesture(
+    std::unique_ptr<blink::WebInputEvent> event) {
+  if (content_input_manager_) {
+    content_input_manager_->ProcessUpdatedGesture(std::move(event));
+  }
+}
+
+
 // ----------------------------------------------------------------------------
 // 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, jboolean for_web_vr,
            const base::android::JavaParamRef<jobject>& delegate,
            jlong gvr_api, jboolean reprojected_rendering) {
   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),
       for_web_vr, VrShellDelegate::GetNativeDelegate(env, delegate),
       reinterpret_cast<gvr_context*>(gvr_api), reprojected_rendering));
 }
 
 }  // namespace vr_shell