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);

[bshe, 2017/02/10 20:15:44]

if (main_contents_) before this line? 

[mthiesse, 2017/02/13 15:27:35]

No, we just do the check inside SetIsInVR

+  ContentFrameWasResized(false /* unused */);
+  SetUiState();
+
+  if (!main_contents_) {
+    content_input_manager_ = nullptr;
+    vr_web_contents_observer_ = nullptr;
+    metrics_helper_ = nullptr;
+    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);
-
   // 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::SetUiState() {
+  if (!main_contents_) {
+    // TODO(mthiesse): Properly handle native page URLs.

[bshe, 2017/02/10 20:15:44]

nit: file a bug or reference to existing bug?

[mthiesse, 2017/02/13 15:27:35]

Done.

+    html_interface_->SetURL(GURL());
+    html_interface_->SetLoading(false);
+    html_interface_->SetFullscreen(false);
+  } else {
+    html_interface_->SetURL(main_contents_->GetVisibleURL());
+    html_interface_->SetLoading(main_contents_->IsLoading());
+    html_interface_->SetFullscreen(main_contents_->IsFullscreen());
+  }
+}
+
 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 47 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_)

[bshe, 2017/02/10 20:15:44]

does this mean we may miss recording the metrics?

[mthiesse, 2017/02/13 15:27:36]

Yes, when on a native page.

+    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());
+  SetUiState();
   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());

[bshe, 2017/02/10 20:15:44]

I am not sure I understand correctly here. So contentSurfaceCreated will
indirectly trigger TakeContentSurface. Why not just passing the surface directly
as a parameter of contentSufaceCreated so the TakeContentSurface is no longer
necessary.
Also, is there a reason to not name the java function to contentSurfaceChanged
to match the function name at 361?

[mthiesse, 2017/02/13 15:27:35]

We can't just pass the surface up as a parameter because we need to know if java
took ownership of the surface. I could return a boolean, but I think it's
cleaner to just have a separate function call for java taking ownership of the
surface.

Note that once java takes ownership of the surface, native can't reclaim it - we
have to create a new one.

I'll rename the function.

 }
 
 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) {
+  switch (action) {
+    case OMNIBOX_CONTENT:

[bshe, 2017/02/10 20:15:44]

braces here too? Or remove brances at 414

[cjgrant, 2017/02/10 20:20:22]

The braces on 414 keep "bool paused" in the scope of that case.  What's wrong
with braces on some bigger cases, but not trivially short ones?  If this was a
tiny switch block, consistency would seem more important...  My 2 cents.

[mthiesse, 2017/02/13 15:27:35]

Leaving braces as-is.

[bshe, 2017/02/13 15:56:11]

It is not a blocker. It is a suggestion to keep style consistent for each
"case". Either have braces for all cases or no braces at all. I am not saying
there is anything wrong with braces. But I am not sure I understand the life
scope argument. The code wont be any different after you remove the braces. It
is still out of scope after return.

+      html_interface_->HandleOmniboxInput(*arguments);
+      return;
+    case SET_CONTENT_PAUSED: {
+      bool paused;
+      CHECK(arguments->GetBoolean("paused", &paused));
+      SetContentPaused(paused);
+      return;
+    }
+    default:
+      break;
+  }
+  // TODO(mthiesse): Handles these in java through the Tab.
+  if (!main_contents_)
+    return;

[bshe, 2017/02/10 20:15:44]

Does this mean we can't use the navigate controls if it is a native page? If so,
perhaps create a bug?

[mthiesse, 2017/02/13 15:27:35]

No need for a separate bug I think, this is part of the implementation that
isn't finished.

   content::NavigationController& controller = main_contents_->GetController();
   switch (action) {
     case HISTORY_BACK:
       if (main_contents_->IsFullscreen()) {
         main_contents_->ExitFullscreen(false);
       } else if (controller.CanGoBack()) {
         controller.GoBack();
       }
       break;
     case HISTORY_FORWARD:
       if (controller.CanGoForward())
         controller.GoForward();
       break;
     case RELOAD:
       controller.Reload(content::ReloadType::NORMAL, false);
       break;
     case LOAD_URL: {
       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(""));
       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:
       ui_contents_->GetController().Reload(content::ReloadType::NORMAL, false);
-      html_interface_.reset(new UiInterface(UiInterface::Mode::STANDARD,
-                                            main_contents_->IsFullscreen()));
+      html_interface_.reset(new UiInterface(UiInterface::Mode::STANDARD));
+      SetUiState();
       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