ui/android: Fix Resource meta-data sharing with ResourceManager.

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;
@@ skipping 68 matching lines @@
                 : displayAndroid.getDisplayWidth();
         int screenHeight = displayAndroid.getPhysicalDisplayHeight() != 0
                 ? displayAndroid.getPhysicalDisplayHeight()
                 : displayAndroid.getDisplayHeight();
         int minScreenSideLength = Math.min(screenWidth, screenHeight);
 
         Resources resources = context.getResources();
         return new ResourceManager(resources, minScreenSideLength, staticResourceManagerPtr);
     }
 
+    public static long createBitmapResource() {

[David Trainor- moved to gerrit, 2017/03/14 18:31:52]

Maybe these should live on the resources.  I admit it adds more ugly JNI bridges
though :(.  Maybe one factory class?

[Khushal, 2017/03/15 01:50:06]

Actually, how about just making NinePatchData public? You only have one public
method then, createBitmapResource(NinePatchData) and if you pass a NinePatchData
then it will create the NinePatchResource.

In this patch I'll have to keep the createNinePatchBitmap public, for the
DynamicResource, but going forward we can remove that when DynamicResources
build their own Resource.

And if its just one public helper method, might as well just keep it on this
class?

[Khushal, 2017/03/16 19:01:44]

I moved it to a separate class. Cleaner.

+        return nativeCreateBitmapResource();
+    }
+
+    public static long createNinePatchBitmapResource(Rect padding, Rect aperture) {
+        return nativeCreateNinePatchBitmapResource(padding.left, padding.top, padding.right,
+                padding.bottom, aperture.left, aperture.top, aperture.right, aperture.bottom);
+    }
+
     /**
      * @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 53 matching lines @@
                 nativeOnCrushedSpriteResourceReady(mNativeResourceManagerPtr, resId,
                         crushedResource.getBitmap(), crushedResource.getFrameRectangles(),
                         crushedResource.getUnscaledSpriteWidth(),
                         crushedResource.getUnscaledSpriteHeight(),
                         crushedResource.getScaledSpriteWidth(),
                         crushedResource.getScaledSpriteHeight());
             }
             return;
         }
 
-        Rect padding = resource.getPadding();
-        Rect aperture = resource.getAperture();
-
         nativeOnResourceReady(mNativeResourceManagerPtr, resType, resId, resource.getBitmap(),
-                padding.left, padding.top, padding.right, padding.bottom,
-                aperture.left, aperture.top, aperture.right, aperture.bottom);
+                resource.createNativeResource());
     }
 
     @Override
     public void onResourceUnregistered(int resType, int resId) {
         // Only remove dynamic bitmaps that were unregistered.
         if (resType != AndroidResourceType.DYNAMIC_BITMAP) return;
 
         nativeRemoveResource(mNativeResourceManagerPtr, resType, resId);
     }
 
@@ skipping 49 matching lines @@
     @CalledByNative
     private long getNativePtr() {
         return mNativeResourceManagerPtr;
     }
 
     private void registerResourceLoader(ResourceLoader loader) {
         mResourceLoaders.put(loader.getResourceType(), loader);
     }
 
     private native void nativeOnResourceReady(long nativeResourceManagerImpl, int resType,
-            int resId, Bitmap bitmap, int paddingLeft, int paddingTop, int paddingRight,
-            int paddingBottom, int apertureLeft, int apertureTop, int apertureRight,
-            int apertureBottom);
+            int resId, Bitmap bitmap, long nativeResource);
     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);
     private native void nativeRemoveResource(long nativeResourceManagerImpl, int resType,
             int resId);
     private native void nativeClearTintedResourceCache(long nativeResourceManagerImpl);
 
+    private static native long nativeCreateBitmapResource();
+    private static native long nativeCreateNinePatchBitmapResource(int paddingLeft, int paddingTop,
+            int paddingRight, int paddingBottom, int apertureLeft, int apertureTop,
+            int apertureRight, int apertureBottom);
 }