Hold a reference to any kind of context in WindowAndroid.

ui/android/java/src/org/chromium/ui/resources/ResourceManager.java

 // Copyright 2014 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.resources;
 
 import android.content.Context;
 import android.content.res.Resources;
 import android.graphics.Bitmap;
 import android.graphics.Rect;
 import android.util.SparseArray;
 
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.annotations.MainDex;
+import org.chromium.ui.base.WindowAndroid;
+import org.chromium.ui.gfx.DeviceDisplayInfo;
 import org.chromium.ui.resources.ResourceLoader.ResourceLoaderCallback;
 import org.chromium.ui.resources.dynamics.DynamicResource;
 import org.chromium.ui.resources.dynamics.DynamicResourceLoader;
 import org.chromium.ui.resources.sprites.CrushedSpriteResource;
 import org.chromium.ui.resources.sprites.CrushedSpriteResourceLoader;
 import org.chromium.ui.resources.statics.StaticResourceLoader;
 import org.chromium.ui.resources.system.SystemResourceLoader;
 
 /**
  * The Java component of a manager for all static resources to be loaded and used by CC layers.
  * This class does not hold any resource state, but passes it directly to native as they are loaded.
  */
 @JNINamespace("ui")
 @MainDex
 public class ResourceManager implements ResourceLoaderCallback {
     private final SparseArray<ResourceLoader> mResourceLoaders = new SparseArray<ResourceLoader>();
     private final SparseArray<SparseArray<LayoutResource>> mLoadedResources =
             new SparseArray<SparseArray<LayoutResource>>();
     private final CrushedSpriteResourceLoader mCrushedSpriteResourceLoader;
 
     private final float mPxToDp;
 
     private long mNativeResourceManagerPtr;
 
-    private ResourceManager(Context context, long staticResourceManagerPtr) {
-        Resources resources = context.getResources();
+    private ResourceManager(
+            Resources resources, int minScreenSideLength, long staticResourceManagerPtr) {
         mPxToDp = 1.f / resources.getDisplayMetrics().density;
 
-        // Register ResourceLoaders
         registerResourceLoader(new StaticResourceLoader(
                 AndroidResourceType.STATIC, this, resources));
         registerResourceLoader(new DynamicResourceLoader(
                 AndroidResourceType.DYNAMIC, this));
         registerResourceLoader(new DynamicResourceLoader(
                 AndroidResourceType.DYNAMIC_BITMAP, this));
-        registerResourceLoader(new SystemResourceLoader(
-                AndroidResourceType.SYSTEM, this, context));
+        registerResourceLoader(
+                new SystemResourceLoader(AndroidResourceType.SYSTEM, this, minScreenSideLength));
         mCrushedSpriteResourceLoader = new CrushedSpriteResourceLoader(this, resources);
 
         mNativeResourceManagerPtr = staticResourceManagerPtr;
     }
 
     /**
-     * Creates an instance of a {@link ResourceManager}.  This will
-     * @param context                  A {@link Context} instance to grab {@link Resources} from.
+     * Creates an instance of a {@link ResourceManager}.
+     * @param WindowAndroid            A {@link WindowAndroid} instance to fetch a {@link Context}
+     * and thus grab {@link Resources} from.
      * @param staticResourceManagerPtr A pointer to the native component of this class.
      * @return                         A new instance of a {@link ResourceManager}.
      */
     @CalledByNative
-    private static ResourceManager create(Context context, long staticResourceManagerPtr) {
-        return new ResourceManager(context, staticResourceManagerPtr);
+    private static ResourceManager create(
+            WindowAndroid windowAndroid, long staticResourceManagerPtr) {
+        Context context = windowAndroid.getContext().get();
+        // This call should happen early enough (i.e. during construction) that this context should
+        // not yet have been released.
+        if (context == null) return null;

[Ted C, 2015/11/16 16:51:54]

from my brief glance, it doesn't look like native supports/handles this
returning null

I think throwing an IllegalStateException here would be clearer and make it
easier to figure out what went wrong.

[gsennton, 2015/11/16 19:53:58]

Done.

+
+        DeviceDisplayInfo displayInfo = DeviceDisplayInfo.create(context);
+        int screenWidth = displayInfo.getPhysicalDisplayWidth() != 0
+                ? displayInfo.getPhysicalDisplayWidth()
+                : displayInfo.getDisplayWidth();
+        int screenHeight = displayInfo.getPhysicalDisplayHeight() != 0
+                ? displayInfo.getPhysicalDisplayHeight()
+                : displayInfo.getDisplayHeight();
+        int minScreenSideLength = Math.min(screenWidth, screenHeight);
+
+        Resources resources = context.getResources();
+        return new ResourceManager(resources, minScreenSideLength, staticResourceManagerPtr);
     }
 
     /**
      * @return A reference to the {@link DynamicResourceLoader} that provides
      *         {@link DynamicResource} objects to this class.
      */
     public DynamicResourceLoader getDynamicResourceLoader() {
         return (DynamicResourceLoader) mResourceLoaders.get(
                 AndroidResourceType.DYNAMIC);
     }
@@ skipping 124 matching lines @@
             int resId, Bitmap bitmap, int paddingLeft, int paddingTop, int paddingRight,
             int paddingBottom, int apertureLeft, int apertureTop, int apertureRight,
             int apertureBottom);
     private native void nativeOnCrushedSpriteResourceReady(long nativeResourceManagerImpl,
             int bitmapResId, Bitmap bitmap, int[][] frameRects, int unscaledSpriteWidth,
             int unscaledSpriteHeight, float scaledSpriteWidth, float scaledSpriteHeight);
     private native void nativeOnCrushedSpriteResourceReloaded(long nativeResourceManagerImpl,
             int bitmapResId, Bitmap bitmap);
 
 }