Implement lazy initialization for VrShellDelegate

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.app.PendingIntent;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.ActivityInfo;
 import android.content.res.Configuration;
 import android.net.Uri;
 import android.os.Build;
 import android.os.Handler;
 import android.os.StrictMode;
 import android.os.SystemClock;
 import android.support.annotation.IntDef;
 import android.view.Choreographer;
 import android.view.Choreographer.FrameCallback;
 import android.view.Display;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewGroup.LayoutParams;
 import android.view.WindowManager;
 import android.widget.FrameLayout;
 
+import org.chromium.base.ApplicationStatus;
 import org.chromium.base.Log;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.library_loader.LibraryLoader;
-
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.ChromeActivity;
 import org.chromium.chrome.browser.ChromeFeatureList;
 import org.chromium.chrome.browser.ChromeTabbedActivity;
 import org.chromium.chrome.browser.infobar.InfoBarIdentifier;
 import org.chromium.chrome.browser.infobar.SimpleConfirmInfoBarBuilder;
 import org.chromium.chrome.browser.multiwindow.MultiWindowUtils;
 import org.chromium.chrome.browser.tab.Tab;
 import org.chromium.chrome.browser.tabmodel.TabModel;
+import org.chromium.chrome.browser.tabmodel.TabModelSelector;
 import org.chromium.chrome.browser.tabmodel.TabModelUtils;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 
 /**
  * Manages interactions with the VR Shell.
  */
@@ skipping 27 matching lines @@
 
     private static final String MIN_SDK_VERSION_PARAM_NAME = "min_sdk_version";
 
     private static final String VR_ACTIVITY_ALIAS =
             "org.chromium.chrome.browser.VRChromeTabbedActivity";
 
     private static final String VR_CORE_PACKAGE_ID = "com.google.vr.vrcore";
 
     private static final long REENTER_VR_TIMEOUT_MS = 1000;
 
-    private final ChromeTabbedActivity mActivity;
-    private Intent mEnterVRIntent;
+    private static VrShellDelegate sInstance;
+
+    private final ChromeActivity mActivity;
 
     @VrSupportLevel
     private int mVrSupportLevel;
 
     private final VrClassesWrapper mVrClassesWrapper;
     private VrShell mVrShell;
     private NonPresentingGvrContext mNonPresentingGvrContext;
     private VrDaydreamApi mVrDaydreamApi;
     private VrCoreVersionChecker mVrCoreVersionChecker;
+    private TabModelSelector mTabModelSelector;
 
     private boolean mInVr;
     private boolean mEnteringVr;
     private boolean mPaused;
     private int mRestoreSystemUiVisibilityFlag = -1;
     private Integer mRestoreOrientation = null;
     private long mNativeVrShellDelegate;
     private boolean mRequestedWebVR;
     private long mLastVRExit;
     private boolean mListeningForWebVrActivate;
     private boolean mListeningForWebVrActivateBeforePause;
 
-    public VrShellDelegate(ChromeTabbedActivity activity) {
-        mActivity = activity;
-        mVrClassesWrapper = createVrClassesWrapper();
+    /**
+     * Called when the native library is first available.
+     */
+    public static void onNativeLibraryAvailable() {
+        nativeOnLibraryAvailable();
     }
 
     /**
-     * Updates mVrSupportLevel to the correct value. isVrCoreCompatible might return different value
-     * at runtime.
+     * @return A helper class for creating VR-specific classes that may not be available at compile
+     * time.
      */
-    // TODO(bshe): Find a place to call this function again, i.e. page refresh or onResume.
-    // TODO(mthiesse): Clean this function up, lots of duplicated code.
-    private void updateVrSupportLevel() {
-        if (mVrClassesWrapper == null || !isVrCoreCompatible()) {
-            mVrSupportLevel = VR_NOT_AVAILABLE;
-            mEnterVRIntent = null;
-            return;
-        }
-
-        if (mVrDaydreamApi == null) {
-            mVrDaydreamApi = mVrClassesWrapper.createVrDaydreamApi();
-        }
-
-        // Check cardboard support for non-daydream devices.
-        if (!mVrDaydreamApi.isDaydreamReadyDevice()) {
-            // Supported Build version is determined by the webvr cardboard support feature.
-            // Default is KITKAT unless specified via server side finch config.
-            if (Build.VERSION.SDK_INT < ChromeFeatureList.getFieldTrialParamByFeatureAsInt(
-                                                ChromeFeatureList.WEBVR_CARDBOARD_SUPPORT,
-                                                MIN_SDK_VERSION_PARAM_NAME,
-                                                Build.VERSION_CODES.KITKAT)) {
-                mVrSupportLevel = VR_NOT_AVAILABLE;
-                mEnterVRIntent = null;
-                return;
-            }
-        }
-
-        if (mEnterVRIntent == null) {
-            mEnterVRIntent =
-                    mVrDaydreamApi.createVrIntent(new ComponentName(mActivity, VR_ACTIVITY_ALIAS));
-        }
-        mVrSupportLevel = mVrDaydreamApi.isDaydreamReadyDevice() ? VR_DAYDREAM : VR_CARDBOARD;
+    @VisibleForTesting
+    public static VrClassesWrapper getVrClassesWrapper() {
+        if (sInstance != null) return sInstance.mVrClassesWrapper;
+        return createVrClassesWrapper();
     }
 
     /**
-     * Should be called once the native library is loaded so that the native portion of this class
-     * can be initialized.
+     * Pauses VR Shell, if it needs to be paused.
      */
-    public void onNativeLibraryReady() {
-        updateVrSupportLevel();
-        if (mVrSupportLevel == VR_NOT_AVAILABLE) return;
-        mNativeVrShellDelegate = nativeInit();
-        Choreographer choreographer = Choreographer.getInstance();
-        choreographer.postFrameCallback(new FrameCallback() {
-            @Override
-            public void doFrame(long frameTimeNanos) {
-                Display display = ((WindowManager) mActivity.getSystemService(
-                        Context.WINDOW_SERVICE)).getDefaultDisplay();
-                nativeUpdateVSyncInterval(mNativeVrShellDelegate, frameTimeNanos,
-                        1.0d / display.getRefreshRate());
-            }
-        });
+    public static void maybePauseVR(ChromeActivity activity) {
+        maybeUnregisterDaydreamIntent(activity);
+        if (sInstance == null) return;
+        if (sInstance.mActivity != activity) {
+            assert !sInstance.mInVr;
+            return;
+        }
+        sInstance.pauseVR();
+    }
+
+    /**
+     * Resumes VR Shell, if it needs to be resumed.
+     */
+    public static void maybeResumeVR(ChromeActivity activity) {
+        maybeRegisterDaydreamIntent(activity);
+        if (sInstance == null) return;
+        if (sInstance.mActivity != activity) {
+            assert !sInstance.mInVr;
+            return;
+        }
+        sInstance.resumeVR();
+    }
+
+    /**
+     * Whether or not we are currently in VR.
+     */
+    public static boolean isInVR() {
+        if (sInstance == null) return false;
+        return sInstance.mInVr;
+    }
+
+    /**
+     * See {@link ChromeActivity#handleBackPressed}
+     * Only handles the back press while in VR.
+     */
+    public static boolean onBackPressed() {
+        if (sInstance == null) return false;
+        return sInstance.onBackPressedInternal();
+    }
+
+    /**
+     * Enters VR on the current tab if possible.
+     */
+    public static void enterVRIfNecessary() {
+        boolean created_delegate = sInstance == null;
+        VrShellDelegate instance = getInstance();
+        if (instance == null) return;
+        if (instance.enterVRInternal() == ENTER_VR_CANCELLED && created_delegate) {
+            instance.destroy();
+        }
+    }
+
+    /**
+     * Handles a VR intent, entering VR in the process.
+     */
+    public static void enterVRFromIntent(Intent intent) {
+        assert isDaydreamVrIntent(intent);
+        boolean created_delegate = sInstance == null;
+        VrShellDelegate instance = getInstance();
+        if (instance == null) return;
+        if (!instance.enterVRFromIntent() && created_delegate) instance.destroy();
+    }
+
+    /**
+     * Whether or not the intent is a Daydream VR Intent.
+     */
+    public static boolean isDaydreamVrIntent(Intent intent) {
+        if (intent == null || intent.getCategories() == null) return false;
+        return intent.getCategories().contains(DAYDREAM_CATEGORY);
+    }
+
+    /**
+     * Handles the result of the exit VR flow (DOFF).
+     */
+    public static void onExitVRResult(int resultCode) {
+        if (sInstance == null) return;
+        sInstance.onExitVRResult(resultCode == Activity.RESULT_OK);
+    }
+
+    public static int getVrSupportLevel(VrDaydreamApi daydreamApi,
+            VrCoreVersionChecker versionChecker, Tab tabToShowInfobarIn) {
+        if (!isVrCoreCompatible(versionChecker, tabToShowInfobarIn) || daydreamApi == null
+                || versionChecker == null) {
+            return VR_NOT_AVAILABLE;
+        }
+
+        if (daydreamApi.isDaydreamReadyDevice()) return VR_DAYDREAM;
+
+        // Check cardboard support for non-daydream devices. Supported Build version is determined
+        // by the webvr cardboard support feature. Default is KITKAT unless specified via server
+        // side finch config.
+        if (Build.VERSION.SDK_INT < ChromeFeatureList.getFieldTrialParamByFeatureAsInt(
+                                            ChromeFeatureList.WEBVR_CARDBOARD_SUPPORT,
+                                            MIN_SDK_VERSION_PARAM_NAME,
+                                            Build.VERSION_CODES.KITKAT)) {
+            return VR_NOT_AVAILABLE;
+        }
+
+        return VR_CARDBOARD;
+    }
+
+    @CalledByNative
+    private static VrShellDelegate getInstance() {
+        if (sInstance != null) return sInstance;
+        if (!LibraryLoader.isInitialized()) return null;
+        Activity activity = ApplicationStatus.getLastTrackedFocusedActivity();
+        // Note that we only support ChromeTabbedActivity for now.
+        if (activity == null || !(activity instanceof ChromeTabbedActivity)) return null;
+        sInstance = new VrShellDelegate((ChromeActivity) activity);
+
+        return sInstance;
     }
 
     @SuppressWarnings("unchecked")
-    private VrClassesWrapper createVrClassesWrapper() {
+    private static VrClassesWrapper createVrClassesWrapper() {
         try {
             Class<? extends VrClassesWrapper> vrClassesBuilderClass =
                     (Class<? extends VrClassesWrapper>) Class.forName(
                             "org.chromium.chrome.browser.vr_shell.VrClassesWrapperImpl");
-            Constructor<?> vrClassesBuilderConstructor =
-                    vrClassesBuilderClass.getConstructor(ChromeActivity.class);
-            return (VrClassesWrapper) vrClassesBuilderConstructor.newInstance(mActivity);
+            Constructor<?> vrClassesBuilderConstructor = vrClassesBuilderClass.getConstructor();
+            return (VrClassesWrapper) vrClassesBuilderConstructor.newInstance();
         } catch (ClassNotFoundException | InstantiationException | IllegalAccessException
                 | IllegalArgumentException | InvocationTargetException | NoSuchMethodException e) {
             if (!(e instanceof ClassNotFoundException)) {
                 Log.e(TAG, "Unable to instantiate VrClassesWrapper", e);
             }
             return null;
         }
     }
 
+    private static PendingIntent getEnterVRPendingIntent(
+            VrDaydreamApi dayreamApi, Activity activity) {
+        return PendingIntent.getActivity(activity, 0,
+                dayreamApi.createVrIntent(new ComponentName(activity, VR_ACTIVITY_ALIAS)),
+                PendingIntent.FLAG_ONE_SHOT);
+    }
+
+    private static void maybeRegisterDaydreamIntent(Activity activity) {
+        if (sInstance != null) return; // Will be handled in onResume.
+        if (!(activity instanceof ChromeTabbedActivity)) return;
+        VrClassesWrapper wrapper = createVrClassesWrapper();
+        if (wrapper == null) return;
+        VrDaydreamApi api = wrapper.createVrDaydreamApi(activity);
+        if (api == null) return;
+        int vrSupportLevel = getVrSupportLevel(api, wrapper.createVrCoreVersionChecker(), null);
+        if (isVrShellEnabled(vrSupportLevel)) registerDaydreamIntent(api, activity);
+    }
+
+    private static void maybeUnregisterDaydreamIntent(Activity activity) {
+        if (sInstance != null) return; // Will be handled in onPause.
+        if (!(activity instanceof ChromeTabbedActivity)) return;
+        VrClassesWrapper wrapper = createVrClassesWrapper();
+        if (wrapper == null) return;
+        VrDaydreamApi api = wrapper.createVrDaydreamApi(activity);
+        if (api == null) return;
+        unregisterDaydreamIntent(api);
+    }
+
+    /**
+     * Registers the Intent to fire after phone inserted into a headset.
+     */
+    private static void registerDaydreamIntent(VrDaydreamApi dayreamApi, Activity activity) {
+        dayreamApi.registerDaydreamIntent(getEnterVRPendingIntent(dayreamApi, activity));
+    }
+
+    /**
+     * Unregisters the Intent which registered by this context if any.
+     */
+    private static void unregisterDaydreamIntent(VrDaydreamApi dayreamApi) {
+        dayreamApi.unregisterDaydreamIntent();
+    }
+
+    /**
+     * @return Whether or not VR Shell is currently enabled.
+     */
+    private static boolean isVrShellEnabled(int vrSupportLevel) {
+        // Only enable ChromeVR (VrShell) on Daydream devices as it currently needs a Daydream
+        // controller.
+        if (vrSupportLevel != VR_DAYDREAM) return false;
+        return ChromeFeatureList.isEnabled(ChromeFeatureList.VR_SHELL);
+    }
+
+    private VrShellDelegate(ChromeActivity activity) {
+        mActivity = activity;
+        mVrClassesWrapper = createVrClassesWrapper();
+        updateVrSupportLevel();
+        if (mVrSupportLevel == VR_NOT_AVAILABLE) return;

[amp, 2017/03/02 18:11:54]

If VR is not available, we still contruct a VrShellDelegate and return it.

Do we need to have an opportunity to create a new instance if the Vr support
level changes (after they updated libraries for instance), or should that
require a restart?

[mthiesse, 2017/03/02 20:01:58]

Oops, meant to remove the early return. The native side should always exist if
we have a VrShellDelegate at all.

+        mNativeVrShellDelegate = nativeInit();
+        Choreographer choreographer = Choreographer.getInstance();
+        choreographer.postFrameCallback(new FrameCallback() {
+            @Override
+            public void doFrame(long frameTimeNanos) {
+                Display display =
+                        ((WindowManager) mActivity.getSystemService(Context.WINDOW_SERVICE))
+                                .getDefaultDisplay();
+                nativeUpdateVSyncInterval(
+                        mNativeVrShellDelegate, frameTimeNanos, 1.0d / display.getRefreshRate());
+            }
+        });
+    }
+
+    /**
+     * Updates mVrSupportLevel to the correct value. isVrCoreCompatible might return different value
+     * at runtime.
+     */
+    // TODO(bshe): Find a place to call this function again, i.e. page refresh or onResume.
+    private void updateVrSupportLevel() {
+        if (mVrClassesWrapper == null) {
+            mVrSupportLevel = VR_NOT_AVAILABLE;
+            return;
+        }
+        if (mVrCoreVersionChecker == null) {
+            mVrCoreVersionChecker = mVrClassesWrapper.createVrCoreVersionChecker();
+        }
+        if (mVrDaydreamApi == null) {
+            mVrDaydreamApi = mVrClassesWrapper.createVrDaydreamApi(mActivity);
+        }
+        mVrSupportLevel = getVrSupportLevel(
+                mVrDaydreamApi, mVrCoreVersionChecker, mActivity.getActivityTab());
+    }
+
     /**
      * Handle a VR intent, entering VR in the process unless we're unable to.
      */
-    public void enterVRFromIntent(Intent intent) {
+    private boolean enterVRFromIntent() {
         // Vr Intent is only used on Daydream devices.
-        if (mVrSupportLevel != VR_DAYDREAM) return;
-        assert isDaydreamVrIntent(intent);
+        if (mVrSupportLevel != VR_DAYDREAM) return false;
         if (mListeningForWebVrActivateBeforePause && !mRequestedWebVR) {
             nativeDisplayActivate(mNativeVrShellDelegate);
-            return;
+            return false;
         }
         // Normally, if the active page doesn't have a vrdisplayactivate listener, and WebVR was not
         // presenting and VrShell was not enabled, we shouldn't enter VR and Daydream Homescreen
         // should show after DON flow. But due to a failure in unregisterDaydreamIntent, we still
         // try to enterVR. Here we detect this case and force switch to Daydream Homescreen.
-        if (!mListeningForWebVrActivateBeforePause && !mRequestedWebVR && !isVrShellEnabled()) {
+        if (!mListeningForWebVrActivateBeforePause && !mRequestedWebVR
+                && !isVrShellEnabled(mVrSupportLevel)) {
             mVrDaydreamApi.launchVrHomescreen();
-            return;
+            return false;
         }
 
         if (mInVr) {
             setEnterVRResult(true);
-            return;
+            return false;
         }
         if (!canEnterVR(mActivity.getActivityTab())) {
             setEnterVRResult(false);
-            return;
+            return false;
         }
         if (mPaused) {
             // We can't enter VR before the application resumes, or we encounter bizarre crashes
             // related to gpu surfaces. Set this flag to enter VR on the next resume.
             prepareToEnterVR();
             mEnteringVr = true;
         } else {
             enterVR();
         }
+        return true;
     }
 
     private void prepareToEnterVR() {
         if (mRestoreOrientation == null) {
             mRestoreOrientation = mActivity.getRequestedOrientation();
         }
         mActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
         setupVrModeWindowFlags();
     }
 
@@ skipping 11 matching lines @@
             return;
         }
         mEnteringVr = false;
         if (!createVrShell()) {
             if (mRestoreOrientation != null) mActivity.setRequestedOrientation(mRestoreOrientation);
             mRestoreOrientation = null;
             clearVrModeWindowFlags();
             setEnterVRResult(false);
             return;
         }
-        mVrClassesWrapper.setVrModeEnabled(true);
+        mVrClassesWrapper.setVrModeEnabled(mActivity, true);
         mInVr = true;
 
         addVrViews();
         mVrShell.initializeNative(mActivity.getActivityTab(), mRequestedWebVR);
         // onResume needs to be called on GvrLayout after initialization to make sure DON flow work
         // properly.
         mVrShell.resume();
 
         setEnterVRResult(true);
     }
 
     private void setEnterVRResult(boolean success) {
         if (mRequestedWebVR) nativeSetPresentResult(mNativeVrShellDelegate, success);
         if (!success && !mVrDaydreamApi.exitFromVr(EXIT_VR_RESULT, new Intent())) {
-            mVrClassesWrapper.setVrModeEnabled(false);
+            mVrClassesWrapper.setVrModeEnabled(mActivity, false);
         }
         mRequestedWebVR = false;
     }
 
     /* package */ boolean canEnterVR(Tab tab) {
         if (!LibraryLoader.isInitialized()) {
             return false;
         }
-        // If vr isn't in the build, or we haven't initialized yet, or vr shell is not enabled and
-        // this is not a web vr request, then return immediately.
-        if (mVrSupportLevel == VR_NOT_AVAILABLE || mNativeVrShellDelegate == 0
-                || (!isVrShellEnabled() && !(mRequestedWebVR || mListeningForWebVrActivate))) {
+        if (mVrSupportLevel == VR_NOT_AVAILABLE || mNativeVrShellDelegate == 0) return false;
+        // If vr shell is not enabled and this is not a web vr request, then return false.
+        if (!isVrShellEnabled(mVrSupportLevel)
+                && !(mRequestedWebVR || mListeningForWebVrActivate)) {
             return false;
         }
         // 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) {
             return false;
         }
         // For now we don't handle sad tab page. crbug.com/661609
         if (tab.isShowingSadTab()) {
             return false;
         }
         // crbug.com/667781
         if (MultiWindowUtils.getInstance().isInMultiWindowMode(mActivity)) {
             return false;
         }
         return true;
     }
 
     @CalledByNative
     private void presentRequested() {
         // TODO(mthiesse): There's a GVR bug where they're not calling us back with the intent we
         // ask them to when we call DaydreamApi#launchInVr. As a temporary hack, remember locally
         // that we want to enter webVR.
         mRequestedWebVR = true;
-        switch (enterVRIfNecessary()) {
+        switch (enterVRInternal()) {
             case ENTER_VR_NOT_NECESSARY:
                 mVrShell.setWebVrModeEnabled(true);
                 nativeSetPresentResult(mNativeVrShellDelegate, true);
                 mRequestedWebVR = false;
                 break;
             case ENTER_VR_CANCELLED:
                 nativeSetPresentResult(mNativeVrShellDelegate, false);
                 mRequestedWebVR = false;
                 break;
             case ENTER_VR_REQUESTED:
                 break;
             case ENTER_VR_SUCCEEDED:
                 nativeSetPresentResult(mNativeVrShellDelegate, true);
                 mRequestedWebVR = false;
                 break;
             default:
                 Log.e(TAG, "Unexpected enum.");
         }
     }
 
     /**
      * Enters VR Shell if necessary, displaying browser UI and tab contents in VR.
      */
     @EnterVRResult
-    public int enterVRIfNecessary() {
+    private int enterVRInternal() {
         // Update VR support level as it can change at runtime
         updateVrSupportLevel();
         if (mVrSupportLevel == VR_NOT_AVAILABLE) return ENTER_VR_CANCELLED;
         if (mInVr) return ENTER_VR_NOT_NECESSARY;
         if (!canEnterVR(mActivity.getActivityTab())) return ENTER_VR_CANCELLED;
 
         if (mVrSupportLevel == VR_CARDBOARD || !mVrDaydreamApi.isDaydreamCurrentViewer()) {
             // Avoid using launchInVr which would trigger DON flow regardless current viewer type
             // due to the lack of support for unexported activities.
             enterVR();
         } else {
-            if (!mVrDaydreamApi.launchInVr(getPendingEnterVRIntent())) return ENTER_VR_CANCELLED;
+            if (!mVrDaydreamApi.launchInVr(getEnterVRPendingIntent(mVrDaydreamApi, mActivity))) {
+                return ENTER_VR_CANCELLED;
+            }
         }
         return ENTER_VR_REQUESTED;
     }
 
     @CalledByNative
     private boolean exitWebVR() {
         if (!mInVr) return false;
         mVrShell.setWebVrModeEnabled(false);
         if (mVrSupportLevel == VR_CARDBOARD) {
             // Transition screen is not available for Cardboard only (non-Daydream) devices.
             // TODO(bshe): Fix this once b/33490788 is fixed.
             shutdownVR(false /* isPausing */, false /* showTransition */);
         } else {
             // 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(false /* isPausing */, !isVrShellEnabled() /* showTransition */);
+            shutdownVR(
+                    false /* isPausing */, !isVrShellEnabled(mVrSupportLevel) /* showTransition */);
         }
         return true;
     }
 
-    /**
-     * Resumes VR Shell.
-     */
-    public void maybeResumeVR() {
+    private void resumeVR() {
         mPaused = false;
         if (mVrSupportLevel == VR_NOT_AVAILABLE) return;
         if (mVrSupportLevel == VR_DAYDREAM
-                && (isVrShellEnabled() || mListeningForWebVrActivateBeforePause)) {
-            registerDaydreamIntent();
+                && (isVrShellEnabled(mVrSupportLevel) || mListeningForWebVrActivateBeforePause)) {
+            registerDaydreamIntent(mVrDaydreamApi, mActivity);
         }
 
         if (mEnteringVr) {
             enterVR();
         } else if (mRequestedWebVR) {
             // If this is still set, it means the user backed out of the DON flow, and we won't be
             // receiving an intent from daydream.
             nativeSetPresentResult(mNativeVrShellDelegate, false);
             mRequestedWebVR = false;
         }
@@ skipping 10 matching lines @@
             oldPolicy = StrictMode.allowThreadDiskWrites();
             try {
                 mVrShell.resume();
             } catch (IllegalArgumentException e) {
                 Log.e(TAG, "Unable to resume VrShell", e);
             } finally {
                 StrictMode.setThreadPolicy(oldPolicy);
             }
         } else if (mVrSupportLevel == VR_DAYDREAM && mVrDaydreamApi.isDaydreamCurrentViewer()
                 && mLastVRExit + REENTER_VR_TIMEOUT_MS > SystemClock.uptimeMillis()) {
-            enterVRIfNecessary();
+            enterVRInternal();
         }
     }
 
-    /**
-     * Pauses VR Shell.
-     */
-    public void maybePauseVR() {
+    private void pauseVR() {
         mPaused = true;
         if (mVrSupportLevel == VR_NOT_AVAILABLE) return;
 
         if (mVrSupportLevel == VR_DAYDREAM) {
-            unregisterDaydreamIntent();
+            unregisterDaydreamIntent(mVrDaydreamApi);
 
             // When the active web page has a vrdisplayactivate event handler,
             // mListeningForWebVrActivate should be set to true, which means a vrdisplayactive event
             // should be fired once DON flow finished. However, DON flow will pause our activity,
             // which makes the active page becomes invisible. And the event fires before the active
             // page becomes visible again after DON finished. So here we remember the value of
             // mListeningForWebVrActivity before pause and use this value to decide if
             // vrdisplayactivate event should be dispatched in enterVRFromIntent.
             mListeningForWebVrActivateBeforePause = mListeningForWebVrActivate;
         }
         nativeOnPause(mNativeVrShellDelegate);
 
         // TODO(mthiesse): When VR Shell lives in its own activity, and integrates with Daydream
         // home, pause instead of exiting VR here. For now, because VR Apps shouldn't show up in the
         // non-VR recents, and we don't want ChromeTabbedActivity disappearing, exit VR.
         shutdownVR(true /* isPausing */, false /* showTransition */);
     }
 
-    /**
-     * See {@link ChromeActivity#handleBackPressed}
-     */
-    public boolean onBackPressed() {
+    private boolean onBackPressedInternal() {
         if (mVrSupportLevel == VR_NOT_AVAILABLE) return false;
         if (!mInVr) return false;
         shutdownVR(false /* isPausing */, false /* showTransition */);
         return true;
     }
 
-    public void onExitVRResult(int resultCode) {
+    private void onExitVRResult(boolean success) {
         assert mVrSupportLevel != VR_NOT_AVAILABLE;
-        if (resultCode == Activity.RESULT_OK) {
-            mVrClassesWrapper.setVrModeEnabled(false);
-        } else {
-            // For now, we don't handle re-entering VR when exit fails, so keep trying to exit.
-            if (!mVrDaydreamApi.exitFromVr(EXIT_VR_RESULT, new Intent())) {
-                mVrClassesWrapper.setVrModeEnabled(false);
-            }
-        }
-    }
-
-    private PendingIntent getPendingEnterVRIntent() {
-        return PendingIntent.getActivity(mActivity, 0, mEnterVRIntent, PendingIntent.FLAG_ONE_SHOT);
-    }
-
-    /**
-     * Registers the Intent to fire after phone inserted into a headset.
-     */
-    private void registerDaydreamIntent() {
-        mVrDaydreamApi.registerDaydreamIntent(getPendingEnterVRIntent());
-    }
-
-    /**
-     * Unregisters the Intent which registered by this context if any.
-     */
-    private void unregisterDaydreamIntent() {
-        mVrDaydreamApi.unregisterDaydreamIntent();
+        // For now, we don't handle re-entering VR when exit fails, so keep trying to exit.
+        if (!success && sInstance.mVrDaydreamApi.exitFromVr(EXIT_VR_RESULT, new Intent())) return;
+        sInstance.mVrClassesWrapper.setVrModeEnabled(sInstance.mActivity, false);
     }
 
     @CalledByNative
     private long createNonPresentingNativeContext() {
         if (mVrClassesWrapper == null) return 0;
-        mNonPresentingGvrContext = mVrClassesWrapper.createNonPresentingGvrContext();
+        mNonPresentingGvrContext = mVrClassesWrapper.createNonPresentingGvrContext(mActivity);
         if (mNonPresentingGvrContext == null) return 0;
         return mNonPresentingGvrContext.getNativeGvrContext();
     }
 
     @CalledByNative
     private void shutdownNonPresentingNativeContext() {
         mNonPresentingGvrContext.shutdown();
         mNonPresentingGvrContext = null;
     }
 
     @CalledByNative
     private void setListeningForWebVrActivate(boolean listening) {
         // Non-Daydream devices may not have the concept of display activate. So disable
         // mListeningForWebVrActivate for them.
         if (mVrSupportLevel != VR_DAYDREAM) return;
         mListeningForWebVrActivate = listening;
         if (listening) {
-            registerDaydreamIntent();
+            registerDaydreamIntent(mVrDaydreamApi, mActivity);
         } else {
-            unregisterDaydreamIntent();
+            unregisterDaydreamIntent(mVrDaydreamApi);
         }
     }
 
     /**
      * Exits VR Shell, performing all necessary cleanup.
      */
     /* package */ void shutdownVR(boolean isPausing, boolean showTransition) {
         if (!mInVr) return;
         mInVr = false;
         mRequestedWebVR = false;
         boolean transition = mVrSupportLevel == VR_DAYDREAM && showTransition;
         if (!isPausing) {
             if (!transition || !mVrDaydreamApi.exitFromVr(EXIT_VR_RESULT, new Intent())) {
-                mVrClassesWrapper.setVrModeEnabled(false);
+                mVrClassesWrapper.setVrModeEnabled(mActivity, false);
             }
         } else {
-            mVrClassesWrapper.setVrModeEnabled(false);
+            mVrClassesWrapper.setVrModeEnabled(mActivity, false);
             mLastVRExit = SystemClock.uptimeMillis();
         }
         if (mRestoreOrientation != null) mActivity.setRequestedOrientation(mRestoreOrientation);
         mRestoreOrientation = null;
         mVrShell.pause();
         removeVrViews();
         clearVrModeWindowFlags();
         destroyVrShell();
         mActivity.getFullscreenManager().setPositionsForTabToNonFullscreen();
     }
 
-    private boolean isVrCoreCompatible() {
-        assert mVrClassesWrapper != null;
-        if (mVrCoreVersionChecker == null) {
-            mVrCoreVersionChecker = mVrClassesWrapper.createVrCoreVersionChecker();
-        }
-
+    private static boolean isVrCoreCompatible(
+            VrCoreVersionChecker versionChecker, Tab tabToShowInfobarIn) {
         return verifyOrUpdateVrServices(
-                mVrCoreVersionChecker.getVrCoreCompatibility(), mActivity.getActivityTab());
+                versionChecker.getVrCoreCompatibility(), tabToShowInfobarIn);
     }
 
-    private boolean verifyOrUpdateVrServices(int vrCoreCompatibility, Tab tab) {
+    private static boolean verifyOrUpdateVrServices(int vrCoreCompatibility, Tab tab) {
         if (vrCoreCompatibility == VrCoreVersionChecker.VR_READY) {
             return true;
         }
         if (tab == null) {
             return false;
         }
         // Make sure OS is supported before showing the user a prompt.
         if (Build.VERSION.SDK_INT < ChromeFeatureList.getFieldTrialParamByFeatureAsInt(
                                             ChromeFeatureList.WEBVR_CARDBOARD_SUPPORT,
                                             MIN_SDK_VERSION_PARAM_NAME,
                                             Build.VERSION_CODES.KITKAT)) {
             return false;
         }
-
+        final Activity activity = tab.getActivity();
         String infobarText;
         String buttonText;
         if (vrCoreCompatibility == VrCoreVersionChecker.VR_NOT_AVAILABLE) {
             // Supported, but not installed. Ask user to install instead of upgrade.
-            infobarText = mActivity.getString(R.string.vr_services_check_infobar_install_text);
-            buttonText = mActivity.getString(R.string.vr_services_check_infobar_install_button);
+            infobarText = activity.getString(R.string.vr_services_check_infobar_install_text);
+            buttonText = activity.getString(R.string.vr_services_check_infobar_install_button);
         } else if (vrCoreCompatibility == VrCoreVersionChecker.VR_OUT_OF_DATE) {
-            infobarText = mActivity.getString(R.string.vr_services_check_infobar_update_text);
-            buttonText = mActivity.getString(R.string.vr_services_check_infobar_update_button);
+            infobarText = activity.getString(R.string.vr_services_check_infobar_update_text);
+            buttonText = activity.getString(R.string.vr_services_check_infobar_update_button);
         } else {
             Log.e(TAG, "Unknown VrCore compatibility: " + vrCoreCompatibility);
             return false;
         }
 
         SimpleConfirmInfoBarBuilder.create(tab,
                 new SimpleConfirmInfoBarBuilder.Listener() {
                     @Override
                     public void onInfoBarDismissed() {}
 
                     @Override
                     public boolean onInfoBarButtonClicked(boolean isPrimary) {
-                        mActivity.startActivity(new Intent(Intent.ACTION_VIEW,
+                        activity.startActivity(new Intent(Intent.ACTION_VIEW,
                                 Uri.parse("market://details?id=" + VR_CORE_PACKAGE_ID)));
                         return false;
                     }
                 },
                 InfoBarIdentifier.VR_SERVICES_UPGRADE_ANDROID, R.drawable.vr_services, infobarText,
                 buttonText, null, true);
         return false;
     }
 
     private boolean createVrShell() {
         if (mVrClassesWrapper == null) return false;
-        mVrShell = mVrClassesWrapper.createVrShell(this, mActivity.getCompositorViewHolder());
+        mTabModelSelector = mActivity.getCompositorViewHolder().detachForVR();
+        if (mTabModelSelector == null) return false;
+        mVrShell = mVrClassesWrapper.createVrShell(mActivity, this, mTabModelSelector);
         return mVrShell != null;
     }
 
     private void addVrViews() {
         FrameLayout decor = (FrameLayout) mActivity.getWindow().getDecorView();
         LayoutParams params = new FrameLayout.LayoutParams(
                 ViewGroup.LayoutParams.MATCH_PARENT,
                 ViewGroup.LayoutParams.MATCH_PARENT);
         decor.addView(mVrShell.getContainer(), params);
-        mActivity.setUIVisibilityForVR(View.GONE);
+        mActivity.onEnterVR();
     }
 
     private void removeVrViews() {
-        mActivity.setUIVisibilityForVR(View.VISIBLE);
+        mActivity.onExitVR();
         FrameLayout decor = (FrameLayout) mActivity.getWindow().getDecorView();
         decor.removeView(mVrShell.getContainer());
     }
 
     private void setupVrModeWindowFlags() {
         if (mRestoreSystemUiVisibilityFlag == -1) {
             mRestoreSystemUiVisibilityFlag = mActivity.getWindow().getDecorView()
                     .getSystemUiVisibility();
         }
         mActivity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
         mActivity.getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                 | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                 | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                 | View.SYSTEM_UI_FLAG_FULLSCREEN | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
     }
 
     private void clearVrModeWindowFlags() {
         mActivity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
         if (mRestoreSystemUiVisibilityFlag != -1) {
             mActivity.getWindow().getDecorView()
                     .setSystemUiVisibility(mRestoreSystemUiVisibilityFlag);
         }
         mRestoreSystemUiVisibilityFlag = -1;
     }
 
     /**
      * Clean up VrShell, and associated native objects.
      */
-    public void destroyVrShell() {
+    private void destroyVrShell() {
         if (mVrShell != null) {
             mVrShell.teardown();
             mVrShell = null;
+            mActivity.getCompositorViewHolder().onExitVR(mTabModelSelector);
         }
     }
 
     /**
-     * Whether or not the intent is a Daydream VR Intent.
-     */
-    public boolean isDaydreamVrIntent(Intent intent) {
-        if (intent == null || intent.getCategories() == null) return false;
-        return intent.getCategories().contains(DAYDREAM_CATEGORY);
-    }
-
-    /**
-     * Whether or not we are currently in VR.
-     */
-    public boolean isInVR() {
-        return mInVr;
-    }
-
-    /**
-     * @return Whether or not VR Shell is currently enabled.
-     */
-    private boolean isVrShellEnabled() {
-        // Only enable ChromeVR (VrShell) on Daydream devices as it currently needs a Daydream
-        // controller.
-        if (mVrSupportLevel != VR_DAYDREAM) return false;
-        return ChromeFeatureList.isEnabled(ChromeFeatureList.VR_SHELL);
-    }
-
-    /**
      * @param api The VrDaydreamApi object this delegate will use instead of the default one
      */
     @VisibleForTesting
     public void overrideDaydreamApiForTesting(VrDaydreamApi api) {
         mVrDaydreamApi = api;
     }
 
     /**
      * @return Pointer to the native VrShellDelegate object.
      */
     @CalledByNative
     private long getNativePointer() {
         return mNativeVrShellDelegate;
     }
 
     @CalledByNative
     private void showTab(int id) {
         Tab tab = mActivity.getTabModelSelector().getTabById(id);
         if (tab == null) {
             return;
         }
         int index = mActivity.getTabModelSelector().getModel(tab.isIncognito()).indexOf(tab);
         if (index == TabModel.INVALID_TAB_INDEX) {
             return;
         }
         TabModelUtils.setIndex(mActivity.getTabModelSelector().getModel(tab.isIncognito()), index);
     }
 
+    private void destroy() {
+        if (sInstance == null) return;
+        if (mNativeVrShellDelegate != 0) nativeDestroy(mNativeVrShellDelegate);
+        sInstance = null;
+    }
+
     private native long nativeInit();
+    private static native void nativeOnLibraryAvailable();
     private native void nativeSetPresentResult(long nativeVrShellDelegate, boolean result);
     private native void nativeDisplayActivate(long nativeVrShellDelegate);
     private native void nativeUpdateVSyncInterval(long nativeVrShellDelegate, long timebaseNanos,
             double intervalSeconds);
     private native void nativeOnPause(long nativeVrShellDelegate);
     private native void nativeOnResume(long nativeVrShellDelegate);
+    private native void nativeDestroy(long nativeVrShellDelegate);
 }