Decouple VR Shell DPR and CSS size from Physical Displays.

ui/android/java/src/org/chromium/ui/base/WindowAndroid.java

 // Copyright 2012 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.ui.base;
 
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
@@ skipping 73 matching lines @@
     protected SparseArray<IntentCallback> mOutstandingIntents;
     // We use a weak reference here to prevent this from leaking in WebView.
     private WeakReference<Context> mContextRef;
 
     // Ideally, this would be a SparseArray<String>, but there's no easy way to store a
     // SparseArray<String> in a bundle during saveInstanceState(). So we use a HashMap and suppress
     // the Android lint warning "UseSparseArrays".
     protected HashMap<Integer, String> mIntentErrors;
 
     // We track all animations over content and provide a drawing placeholder for them.
-    private HashSet<Animator> mAnimationsOverContent = new HashSet<Animator>();
+    private HashSet<Animator> mAnimationsOverContent = new HashSet<>();
     private View mAnimationPlaceholderView;
 
     private ViewGroup mKeyboardAccessoryView;
 
     protected boolean mIsKeyboardShowing = false;
 
     // System accessibility service.
     private final AccessibilityManager mAccessibilityManager;
 
     // Whether touch exploration is enabled.
     private boolean mIsTouchExplorationEnabled;
 
     // On KitKat and higher, a class that monitors the touch exploration state.
     private TouchExplorationMonitor mTouchExplorationMonitor;
 
     private AndroidPermissionDelegate mPermissionDelegate;
 
     /**
      * An interface to notify listeners of changes in the soft keyboard's visibility.
      */
     public interface KeyboardVisibilityListener {
         public void keyboardVisibilityChanged(boolean isShowing);
     }
     private LinkedList<KeyboardVisibilityListener> mKeyboardVisibilityListeners =
-            new LinkedList<KeyboardVisibilityListener>();
+            new LinkedList<>();
 
     private final VSyncMonitor.Listener mVSyncListener = new VSyncMonitor.Listener() {
         @Override
         public void onVSync(VSyncMonitor monitor, long vsyncTimeMicros) {
             if (mNativeWindowAndroid != 0) {
                 nativeOnVSync(mNativeWindowAndroid,
                               vsyncTimeMicros,
                               mVSyncMonitor.getVSyncPeriodInMicroseconds());
             }
         }
@@ skipping 29 matching lines @@
     /**
      * @return The time interval between two consecutive vsync pulses in milliseconds.
      */
     public long getVsyncPeriodInMillis() {
         return mVSyncMonitor.getVSyncPeriodInMicroseconds() / 1000;
     }
 
     /**
      * @param context The application context.
      */
+    public WindowAndroid(Context context) {
+        this(context, DisplayAndroid.getNonMultiDisplay(context));
+    }
+
+    /**
+     * @param context The application context.
+     * @param display
+     */
     @SuppressLint("UseSparseArrays")
-    public WindowAndroid(Context context) {
+    protected WindowAndroid(Context context, DisplayAndroid display) {
         mApplicationContext = context.getApplicationContext();
         // context does not have the same lifetime guarantees as an application context so we can't
         // hold a strong reference to it.
-        mContextRef = new WeakReference<Context>(context);
-        mOutstandingIntents = new SparseArray<IntentCallback>();
-        mIntentErrors = new HashMap<Integer, String>();
+        mContextRef = new WeakReference<>(context);
+        mOutstandingIntents = new SparseArray<>();
+        mIntentErrors = new HashMap<>();
         mVSyncMonitor = new VSyncMonitor(context, mVSyncListener);
         mAccessibilityManager = (AccessibilityManager) mApplicationContext.getSystemService(
                 Context.ACCESSIBILITY_SERVICE);
-        mDisplayAndroid = DisplayAndroid.getNonMultiDisplay(context);
+        mDisplayAndroid = display;
     }
 
     @CalledByNative
     private static long createForTesting(Context context) {
         WindowAndroid windowAndroid = new WindowAndroid(context);
         // |windowAndroid.getNativePointer()| creates native WindowAndroid object
         // which stores a global ref to |windowAndroid|. Therefore |windowAndroid|
         // is not immediately eligible for gc.
         return windowAndroid.getNativePointer();
     }
@@ skipping 213 matching lines @@
     public DisplayAndroid getDisplay() {
         return mDisplayAndroid;
     }
 
     /**
      * @return A reference to owning Activity.  The returned WeakReference will never be null, but
      *         the contained Activity can be null (either if it has been garbage collected or if
      *         this is in the context of a WebView that was not created using an Activity).
      */
     public WeakReference<Activity> getActivity() {
-        return new WeakReference<Activity>(null);
+        return new WeakReference<>(null);
     }
 
     /**
      * @return The application context for this activity.
      */
     public Context getApplicationContext() {
         return mApplicationContext;
     }
 
     /**
@@ skipping 182 matching lines @@
      * To be called when the keyboard visibility state might have changed. Informs listeners of the
      * state change IFF there actually was a change.
      * @param isShowing The current (guesstimated) state of the keyboard.
      */
     protected void keyboardVisibilityPossiblyChanged(boolean isShowing) {
         if (mIsKeyboardShowing == isShowing) return;
         mIsKeyboardShowing = isShowing;
 
         // Clone the list in case a listener tries to remove itself during the callback.
         LinkedList<KeyboardVisibilityListener> listeners =
-                new LinkedList<KeyboardVisibilityListener>(mKeyboardVisibilityListeners);
+                new LinkedList<>(mKeyboardVisibilityListeners);
         for (KeyboardVisibilityListener listener : listeners) {
             listener.keyboardVisibilityChanged(isShowing);
         }
     }
 
     /**
      * Start a post-layout animation on top of web content.
      *
      * By default, Android optimizes what it shows on top of SurfaceViews (saves power).
      * Effectively, layouts determine what gets drawn and post-layout animations outside
@@ skipping 28 matching lines @@
         });
     }
 
     /**
      * Getter for the current context (not necessarily the application context).
      * Make no assumptions regarding what type of Context is returned here, it could be for example
      * an Activity or a Context created specifically to target an external display.
      */
     public WeakReference<Context> getContext() {
         // Return a new WeakReference to prevent clients from releasing our internal WeakReference.
-        return new WeakReference<Context>(mContextRef.get());
+        return new WeakReference<>(mContextRef.get());
     }
 
     /**
      * Update whether the placeholder is 'drawn' based on whether an animation is running
      * or touch exploration is enabled - if either of those are true, we call
      * setWillNotDraw(false) to ensure that the animation is drawn over the SurfaceView,
      * and otherwise we call setWillNotDraw(true).
      */
     private void refreshWillNotDraw() {
         boolean willNotDraw = !mIsTouchExplorationEnabled && mAnimationsOverContent.isEmpty();
         if (mAnimationPlaceholderView.willNotDraw() != willNotDraw) {
             mAnimationPlaceholderView.setWillNotDraw(willNotDraw);
         }
     }
 
     private native long nativeInit(int displayId);
     private native void nativeOnVSync(long nativeWindowAndroid,
                                       long vsyncTimeMicros,
                                       long vsyncPeriodMicros);
     private native void nativeOnVisibilityChanged(long nativeWindowAndroid, boolean visible);
     private native void nativeOnActivityStopped(long nativeWindowAndroid);
     private native void nativeOnActivityStarted(long nativeWindowAndroid);
     private native void nativeDestroy(long nativeWindowAndroid);
 
 }