Enable magic window mode with new Gvr

chrome/android/java/src/org/chromium/chrome/browser/vr_shell/VrShellDelegate.java

 // 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.
 
 package org.chromium.chrome.browser.vr_shell;
 
 import android.app.Activity;
 import android.content.Intent;
 import android.content.pm.ActivityInfo;
 import android.os.StrictMode;
@@ skipping 14 matching lines @@
 
 /**
  * Manages interactions with the VR Shell.
  */
 @JNINamespace("vr_shell")
 public class VrShellDelegate {
     private static final String TAG = "VrShellDelegate";
 
     private ChromeTabbedActivity mActivity;
 
-    private boolean mVrShellEnabled;
+    private boolean mVrEnabled;
 
     private Class<? extends VrShellInterface> mVrShellClass;
+    private Class<? extends NonPresentingGvrContextInterface> mNonPresentingGvrContextClass;
     private VrShellInterface mVrShell;
+    private NonPresentingGvrContextInterface mNonPresentingGvrContext;
     private boolean mInVr;
     private int mRestoreSystemUiVisibilityFlag = -1;
     private String mVrExtra;
     private long mNativeVrShellDelegate;
 
     public VrShellDelegate(ChromeTabbedActivity activity) {
         mActivity = activity;
 
-        mVrShellClass = maybeFindVrShell();
-        if (mVrShellClass != null) {
-            mVrShellEnabled = true;
+        mVrEnabled = maybeFindVrClasses();
+        if (mVrEnabled) {
             try {
                 mVrExtra = (String) mVrShellClass.getField("VR_EXTRA").get(null);
             } catch (IllegalAccessException | IllegalArgumentException | NoSuchFieldException e) {
                 Log.e(TAG, "Unable to read VR_EXTRA field", e);
-                mVrShellEnabled = false;
+                mVrEnabled = false;
             }
         }
     }
 
     /**
      * Should be called once the native library is loaded so that the native portion of this
      * class can be initialized.
      */
     public void onNativeLibraryReady() {
-        if (mVrShellEnabled) {
+        if (mVrEnabled) {
             mNativeVrShellDelegate = nativeInit();
         }
     }
 
     @SuppressWarnings("unchecked")
-    private Class<? extends VrShellInterface> maybeFindVrShell() {
+    private boolean maybeFindVrClasses() {
         try {
-            return (Class<? extends VrShellInterface>) Class
-                    .forName("org.chromium.chrome.browser.vr_shell.VrShell");
+            mVrShellClass = (Class<? extends VrShellInterface>) Class.forName(
+                    "org.chromium.chrome.browser.vr_shell.VrShell");
+            mNonPresentingGvrContextClass =
+                    (Class<? extends NonPresentingGvrContextInterface>) Class.forName(
+                            "org.chromium.chrome.browser.vr_shell.NonPresentingGvrContext");
+            return true;
         } catch (ClassNotFoundException e) {
-            return null;
+            mVrShellClass = null;
+            mNonPresentingGvrContextClass = null;
+            return false;
         }
     }
 
     /**
      * Enters VR Shell, displaying browser UI and tab contents in VR.
      *
      * This function performs native initialization, and so must only be called after native
      * libraries are ready.
      * @param inWebVR If true should begin displaying WebVR content rather than the VrShell UI.
      * @return Whether or not we are in VR when this function returns.
      */
     @CalledByNative
     public boolean enterVRIfNecessary(boolean inWebVR) {
-        if (!mVrShellEnabled || mNativeVrShellDelegate == 0) return false;
+        if (!mVrEnabled || mNativeVrShellDelegate == 0) return false;
         Tab tab = mActivity.getActivityTab();
         // TODO(mthiesse): When we have VR UI for opening new tabs, etc., allow VR Shell to be
         // entered without any current tabs.
         if (tab == null || tab.getContentViewCore() == null) {
             return false;
         }
         if (mInVr) return true;
         // VrShell must be initialized in Landscape mode due to a bug in the GVR library.
         mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
         if (!createVrShell()) {
@@ skipping 17 matching lines @@
         // TODO(bajones): Once VR Shell can be invoked outside of WebVR this
         // should no longer exit the shell outright. Need a way to determine
         // how VrShell was created.
         shutdownVR();
         return true;
     }
 
     /**
      * Resumes VR Shell.
      */
     public void resumeVR() {

[mthiesse, 2016/10/11 18:10:44]

nit: Rename to maybeResumeVR() and maybePauseVR() now that these functions may
be no-ops

[bshe, 2016/10/12 19:02:17]

Done.

-        setupVrModeWindowFlags();
-        StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
-        try {
-            mVrShell.resume();
-        } catch (IllegalArgumentException e) {
-            Log.e(TAG, "Unable to resume VrShell", e);
-        } finally {
-            StrictMode.setThreadPolicy(oldPolicy);
+        if (mNonPresentingGvrContext != null) {

[mthiesse, 2016/10/11 18:10:44]

Is there a reason to have both a non-presenting GVR context and VrShell active
at the same time? If the answer is technical complexity, leaving a TODO is
probably fine for now.

[bshe, 2016/10/12 19:02:17]

I can't think of any reason. And we might want to do so when we are able to
transit from WebVr presentation to ChromeVr directly. I imagine we could create
gvr factory which provide gvr_context for magic window and for presentation. I
would leave a TODO here to avoid future complicate this CL.

+            StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
+            try {
+                mNonPresentingGvrContext.resume();
+            } catch (IllegalArgumentException e) {
+                Log.e(TAG, "Unable to resume mNonPresentingGvrContext", e);
+            } finally {
+                StrictMode.setThreadPolicy(oldPolicy);
+            }
+        }
+
+        if (mInVr) {
+            setupVrModeWindowFlags();
+            StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
+            try {
+                mVrShell.resume();
+            } catch (IllegalArgumentException e) {
+                Log.e(TAG, "Unable to resume VrShell", e);
+            } finally {
+                StrictMode.setThreadPolicy(oldPolicy);
+            }
         }
     }
 
     /**
      * Pauses VR Shell.
      */
     public void pauseVR() {
-        mVrShell.pause();
+        if (mNonPresentingGvrContext != null) {
+            mNonPresentingGvrContext.pause();
+        }
+        if (mInVr) {
+            mVrShell.pause();
+        }
     }
 
     /**
      * Exits the current VR mode (WebVR or VRShell)
      * @return Whether or not we exited VR.
      */
     public boolean exitVRIfNecessary() {
         if (!mInVr) return false;
         // If WebVR is presenting instruct it to exit. VR mode should not
         // exit in this scenario, in case we want to return to the VrShell.
         if (!nativeExitWebVRIfNecessary(mNativeVrShellDelegate)) {
             // If WebVR was not presenting, shutdown VR mode entirely.
             shutdownVR();
         }
 
         return true;
     }
 
+    @CalledByNative
+    private long createNonPresentingNativeContext() {
+        if (!mVrEnabled) return 0;
+
+        try {
+            Constructor<?> nonPresentingGvrContextConstructor =
+                    mNonPresentingGvrContextClass.getConstructor(Activity.class);
+            mNonPresentingGvrContext =
+                    (NonPresentingGvrContextInterface)
+                            nonPresentingGvrContextConstructor.newInstance(mActivity);
+        } catch (InstantiationException | IllegalAccessException | IllegalArgumentException
+                | InvocationTargetException | NoSuchMethodException e) {
+            Log.e(TAG, "Unable to instantiate NonPresentingGvrContext", e);
+            return 0;
+        }
+        return mNonPresentingGvrContext.getNativeGvrContext();
+    }
+
+    @CalledByNative
+    private void shutdownNonPresentingNativeContext() {
+        mNonPresentingGvrContext.shutdown();
+        mNonPresentingGvrContext = null;
+    }
+
     /**
      * Exits VR Shell, performing all necessary cleanup.
      */
     private void shutdownVR() {
         if (!mInVr) return;
         mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
         mVrShell.setVrModeEnabled(false);
         mVrShell.pause();
         removeVrViews();
         clearVrModeWindowFlags();
@@ skipping 77 matching lines @@
      * Whether or not we are currently in VR.
      */
     public boolean isInVR() {
         return mInVr;
     }
 
     /**
      * @return Whether or not VR Shell is currently enabled.
      */
     public boolean isVrShellEnabled() {
-        return mVrShellEnabled;
+        return mVrEnabled;
     }
 
     /**
      * @return Pointer to the native VrShellDelegate object.
      */
     @CalledByNative
     private long getNativePointer() {
         return mNativeVrShellDelegate;
     }
 
     private native long nativeInit();
     private native boolean nativeExitWebVRIfNecessary(long nativeVrShellDelegate);
 }