Support rendering Android Native Pages 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 <string>
 #include <utility>
@@ skipping 37 matching lines @@
 using base::android::JavaRef;
 
 namespace vr_shell {
 
 namespace {
 vr_shell::VrShell* g_instance;
 
 static const char kVrShellUIURL[] = "chrome://vr-shell-ui";
 
 void SetIsInVR(content::WebContents* contents, bool is_in_vr) {
-  if (contents->GetRenderWidgetHostView())
+  if (contents && 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_window_(content_window),
       content_compositor_(
-          base::MakeUnique<VrCompositor>(content_window, false)),
+          base::MakeUnique<VrCompositor>(content_window_, false)),
       ui_contents_(ui_contents),
       ui_compositor_(base::MakeUnique<VrCompositor>(ui_window, true)),
       delegate_provider_(delegate),
-      metrics_helper_(base::MakeUnique<VrMetricsHelper>(main_contents_)),
       main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       reprojected_rendering_(reprojected_rendering),
       gvr_api_(gvr_api),
       weak_ptr_factory_(this) {
   DCHECK(g_instance == nullptr);
   g_instance = this;
   j_vr_shell_.Reset(env, obj);
 
-  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_ = base::MakeUnique<VrGLThread>(
       weak_ptr_factory_.GetWeakPtr(), delegate_provider_->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_ = base::MakeUnique<UiInterface>(
-      for_web_vr ? UiInterface::Mode::WEB_VR : UiInterface::Mode::STANDARD,
-      main_contents_->IsFullscreen());
-  vr_web_contents_observer_ = base::MakeUnique<VrWebContentsObserver>(
-      main_contents_, html_interface_.get(), this);
-
-  SetIsInVR(main_contents_, true);
+      for_web_vr ? UiInterface::Mode::WEB_VR : UiInterface::Mode::STANDARD);
 }
 
 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);
+  if (contents == main_contents_)
+    return;
+
+  SetIsInVR(main_contents_, false);
+
   main_contents_ = contents;
+  content_compositor_->SetLayer(main_contents_);
+  SetIsInVR(main_contents_, true);
+  ContentFrameWasResized(false /* unused */);

[cjgrant, 2017/02/10 15:21:47]

Is "unused" necessary?

[mthiesse, 2017/02/10 16:13:39]

Technically no, but I'm pointing out that this value is arbitrary. It's only
there because we're overriding an interface.

+
+  if (!main_contents_) {
+    content_input_manager_ = nullptr;
+    vr_web_contents_observer_ = nullptr;
+    html_interface_->SetFullscreen(false);
+    metrics_helper_ = nullptr;
+    // TODO(mthiesse): Properly handle native page URLs.
+    html_interface_->SetURL(GURL());
+    html_interface_->SetLoading(false);
+    return;
+  }
   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);
+  html_interface_->SetFullscreen(main_contents_->IsFullscreen());

[cjgrant, 2017/02/10 15:21:47]

Should probably create a SetUiState() method that sets UI properties, rather
than have two sets of set calls (here and in OnDomContentsLoaded()).

[mthiesse, 2017/02/10 16:13:39]

Done.

+  html_interface_->SetURL(main_contents_->GetVisibleURL());
+  html_interface_->SetLoading(main_contents_->IsLoading());
 
   // 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(webvr_mode_);
 }
 
 void VrShell::LoadUIContent(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   GURL url(kVrShellUIURL);
@@ skipping 55 matching lines @@
   gl_thread_->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&VrShellGl::OnTriggerEvent, gl_thread_->GetVrShellGl()));
 }
 
 void VrShell::OnPause(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   gl_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&VrShellGl::OnPause, gl_thread_->GetVrShellGl()));
 
   // exit vr session
-  metrics_helper_->SetVRActive(false);
+  if (metrics_helper_)
+    metrics_helper_->SetVRActive(false);
   SetIsInVR(main_contents_, false);
 }
 
 void VrShell::OnResume(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   gl_thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&VrShellGl::OnResume, gl_thread_->GetVrShellGl()));
 
-  metrics_helper_->SetVRActive(true);
+  if (metrics_helper_)
+    metrics_helper_->SetVRActive(true);
   SetIsInVR(main_contents_, true);
 }
 
 void VrShell::SetSurface(JNIEnv* env,
                          const JavaParamRef<jobject>& obj,
                          const JavaParamRef<jobject>& surface) {
   CHECK(!reprojected_rendering_);
   gfx::AcceleratedWidget window =
       ANativeWindow_fromSurface(base::android::AttachCurrentThread(), surface);
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::InitializeGl,
                                      gl_thread_->GetVrShellGl(),
                                      base::Unretained(window)));
 }
 
 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() {
-  html_interface_->SetURL(main_contents_->GetVisibleURL());
-  html_interface_->SetLoading(main_contents_->IsLoading());
+  if (main_contents_) {
+    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(enabled);
+  if (metrics_helper_)
+    metrics_helper_->SetWebVREnabled(enabled);
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::SetWebVrMode,
                                      gl_thread_->GetVrShellGl(), enabled));
   html_interface_->SetMode(
       enabled ? UiInterface::Mode::WEB_VR : UiInterface::Mode::STANDARD);
 }
 
 void VrShell::OnLoadProgressChanged(JNIEnv* env,
                                     const JavaParamRef<jobject>& obj,
                                     double progress) {
   html_interface_->SetLoadProgress(progress);
@@ skipping 59 matching lines @@
 }
 
 void VrShell::CreateVRDisplayInfo(
     const base::Callback<void(device::mojom::VRDisplayInfoPtr)>& callback,
     uint32_t device_id) {
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::CreateVRDisplayInfo,
                                      gl_thread_->GetVrShellGl(),
                                      callback, device_id));
 }
 
-void VrShell::SurfacesChanged(jobject content_surface, jobject ui_surface) {
-  content_compositor_->SurfaceChanged(content_surface);
-  ui_compositor_->SurfaceChanged(ui_surface);
+base::android::ScopedJavaGlobalRef<jobject> VrShell::TakeContentSurface(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
+  content_compositor_->SurfaceChanged(nullptr);
+  base::android::ScopedJavaGlobalRef<jobject> surface(env, content_surface_);
+  content_surface_ = nullptr;
+  return surface;
+}
+
+void VrShell::RestoreContentSurface(JNIEnv* env,
+                                    const JavaParamRef<jobject>& obj) {
+  PostToGlThreadWhenReady(
+      base::Bind(&VrShellGl::CreateContentSurface, gl_thread_->GetVrShellGl()));
+}
+
+void VrShell::UiSurfaceChanged(jobject surface) {
+  ui_compositor_->SurfaceChanged(surface);
+}
+
+void VrShell::ContentSurfaceChanged(jobject surface) {
+  content_surface_ = surface;
+  content_compositor_->SurfaceChanged(surface);
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_VrShellImpl_contentSurfaceCreated(env, j_vr_shell_.obj());
 }
 
 void VrShell::GvrDelegateReady() {
   delegate_provider_->SetDelegate(this, gvr_api_);
 }
 
 void VrShell::AppButtonPressed() {
 #if defined(ENABLE_VR_SHELL)
   html_interface_->HandleAppButtonClicked();
 #endif
@@ skipping 24 matching lines @@
 }
 
 void VrShell::UpdateScene(const base::ListValue* args) {
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::UpdateScene,
                                      gl_thread_->GetVrShellGl(),
                                      base::Passed(args->CreateDeepCopy())));
 }
 
 void VrShell::DoUiAction(const UiAction action,
                          const base::DictionaryValue* arguments) {
-  content::NavigationController& controller = main_contents_->GetController();

[cjgrant, 2017/02/10 15:21:47]

For readability, it's odd to have several different "don't have a webcontents"
checks in the first 5 cases (main_contents_, controller, !controller), which are
all derived from main_contents_.  Maybe it'd be better to drop the controller
pointer, put "if (!main_contents_) break" at the start of the first 5 cases, and
just reference the controller as main_contents_->GetController() on-site when
needed.  A thought, anyway.

[mthiesse, 2017/02/10 16:13:39]

Done.

+  content::NavigationController* controller =
+      main_contents_ ? &main_contents_->GetController() : nullptr;
   switch (action) {
     case HISTORY_BACK:
-      if (main_contents_->IsFullscreen()) {
+      if (main_contents_ && main_contents_->IsFullscreen()) {
         main_contents_->ExitFullscreen(false);
-      } else if (controller.CanGoBack()) {
-        controller.GoBack();
+      } else if (controller && controller->CanGoBack()) {
+        controller->GoBack();
       }
       break;
     case HISTORY_FORWARD:
-      if (controller.CanGoForward())
-        controller.GoForward();
+      if (controller && controller->CanGoForward())
+        controller->GoForward();
       break;
     case RELOAD:
-      controller.Reload(content::ReloadType::NORMAL, false);
+      if (controller)
+        controller->Reload(content::ReloadType::NORMAL, false);
       break;
     case LOAD_URL: {
+      // TODO(mthiesse): Pass the URL up to the Tab in java and navigate there
+      // to support navigating from native pages.
+      if (!controller)
+        break;
       std::string url_string;
       CHECK(arguments->GetString("url", &url_string));
       GURL url(url_string);
       // TODO(crbug.com/683344): Sanitize the URL and prefix, and pass the
       // proper transition type down from the UI.
-      controller.LoadURL(url, content::Referrer(),
-                         ui::PageTransition::PAGE_TRANSITION_AUTO_TOPLEVEL,
-                         std::string(""));
+      controller->LoadURL(url, content::Referrer(),
+                          ui::PageTransition::PAGE_TRANSITION_AUTO_TOPLEVEL,
+                          std::string(""));
       break;
     }
     case OMNIBOX_CONTENT:
       html_interface_->HandleOmniboxInput(*arguments);
       break;
     case SET_CONTENT_PAUSED: {
       bool paused;
       CHECK(arguments->GetBoolean("paused", &paused));
       SetContentPaused(paused);
       break;
     }
 #if defined(ENABLE_VR_SHELL_UI_DEV)
     case RELOAD_UI:
+      if (!main_contents_)
+        return;
       ui_contents_->GetController().Reload(content::ReloadType::NORMAL, false);
       html_interface_.reset(new UiInterface(UiInterface::Mode::STANDARD,
                                             main_contents_->IsFullscreen()));
       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);
 }
 
 void VrShell::MainFrameWasResized(bool width_changed) {
   display::Display display = display::Screen::GetScreen()
       ->GetDisplayNearestWindow(ui_contents_->GetNativeView());
   PostToGlThreadWhenReady(
       base::Bind(&VrShellGl::UIBoundsChanged, gl_thread_->GetVrShellGl(),
                  display.size().width(), display.size().height()));
 }
 
 void VrShell::ContentFrameWasResized(bool width_changed) {
-  display::Display display = display::Screen::GetScreen()
-      ->GetDisplayNearestWindow(main_contents_->GetNativeView());
+  display::Display display =
+      display::Screen::GetScreen()->GetDisplayNearestWindow(content_window_);
   PostToGlThreadWhenReady(
       base::Bind(&VrShellGl::ContentBoundsChanged, gl_thread_->GetVrShellGl(),
                  display.size().width(), display.size().height()));
 }
 
 void VrShell::WebContentsDestroyed() {
   ui_input_manager_.reset();
   ui_contents_ = nullptr;
   // TODO(mthiesse): Handle web contents being destroyed.
   ForceExitVr();
 }
 
 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_ = nullptr;
 }
 
 void VrShell::ContentWasShown() {
-  content_input_manager_ = base::MakeUnique<VrInputManager>(main_contents_);
+  if (main_contents_)
+    content_input_manager_ = base::MakeUnique<VrInputManager>(main_contents_);
 }
 
 void VrShell::ForceExitVr() {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_VrShellImpl_forceExitVr(env, j_vr_shell_.obj());
 }
 
 void VrShell::OnVRVsyncProviderRequest(
     device::mojom::VRVSyncProviderRequest request) {
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::OnRequest,
@@ skipping 110 matching lines @@
     eye_params->offset[2] = -eye_mat.m[2][3];
   }
 
   return device;
 }
 
 // ----------------------------------------------------------------------------
 // Native JNI methods
 // ----------------------------------------------------------------------------
 
-jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj,
-           const JavaParamRef<jobject>& content_web_contents,
+jlong Init(JNIEnv* env,
+           const JavaParamRef<jobject>& obj,
+           const JavaParamRef<jobject>& ui_web_contents,
            jlong content_window_android,
-           const JavaParamRef<jobject>& ui_web_contents,
-           jlong ui_window_android, jboolean for_web_vr,
+           jlong ui_window_android,
+           jboolean for_web_vr,
            const base::android::JavaParamRef<jobject>& delegate,
-           jlong gvr_api, jboolean reprojected_rendering) {
+           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),
+      env, obj, reinterpret_cast<ui::WindowAndroid*>(content_window_android),
       content::WebContents::FromJavaWebContents(ui_web_contents),
-      reinterpret_cast<ui::WindowAndroid*>(ui_window_android),
-      for_web_vr, VrShellDelegate::GetNativeVrShellDelegate(env, delegate),
+      reinterpret_cast<ui::WindowAndroid*>(ui_window_android), for_web_vr,
+      VrShellDelegate::GetNativeVrShellDelegate(env, delegate),
       reinterpret_cast<gvr_context*>(gvr_api), reprojected_rendering));
 }
 
 }  // namespace vr_shell