Hold a reference to any kind of context in WindowAndroid.

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 59 matching lines @@
     private final VSyncMonitor mVSyncMonitor;
 
     // A string used as a key to store intent errors in a bundle
     static final String WINDOW_CALLBACK_ERRORS = "window_callback_errors";
 
     // Error code returned when an Intent fails to start an Activity.
     public static final int START_INTENT_FAILURE = -1;
 
     protected Context mApplicationContext;
     protected SparseArray<IntentCallback> mOutstandingIntents;
+    // To render properly on an external display through a Presentation we need to fetch
+    // display metrics from the context provided by the Presentation. This context is not the same
+    // as the application context since the application context targets the primary display.
+    // We use a weak reference here to prevent this from leaking in WebView.
+    private WeakReference<Context> mDisplayContextRef;
 
     // 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 View mAnimationPlaceholderView;
 
@@ skipping 39 matching lines @@
      */
     public boolean isInsideVSync() {
         return mVSyncMonitor.isInsideVSync();
     }
 
     /**
      * @param context The application context.
      */
     @SuppressLint("UseSparseArrays")
     public WindowAndroid(Context context) {
-        assert context == context.getApplicationContext();
-        mApplicationContext = context;
+        mApplicationContext = context.getApplicationContext();
+        // context could be an Activity Context so we can't hold a strong reference to it.
+        mDisplayContextRef = new WeakReference<Context>(context);
         mOutstandingIntents = new SparseArray<IntentCallback>();
         mIntentErrors = new HashMap<Integer, String>();
         mVSyncMonitor = new VSyncMonitor(context, mVSyncListener);
-        mAccessibilityManager = (AccessibilityManager)
-                context.getSystemService(Context.ACCESSIBILITY_SERVICE);
+        mAccessibilityManager = (AccessibilityManager) mApplicationContext.getSystemService(
+                Context.ACCESSIBILITY_SERVICE);
     }
 
     /**
      * Set the delegate that will handle android permissions requests.
      */
     @VisibleForTesting
     public void setAndroidPermissionDelegate(AndroidPermissionDelegate delegate) {
         mPermissionDelegate = delegate;
     }
 
@@ skipping 420 matching lines @@
         animation.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animation) {
                 animation.removeListener(this);
                 mAnimationsOverContent.remove(animation);
                 refreshWillNotDraw();
             }
         });
     }
 
+    @CalledByNative
+    private Context getDisplayContext() {
+        return mDisplayContextRef.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();
     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);
 
 }