[Contextual Search] Add support for crushed sprites and animate the search provider icon

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.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")
 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();
         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));
+        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.
      * @param staticResourceManagerPtr A pointer to the native component of this class.
      * @return                         A new instance of a {@link ResourceManager}.
      */
@@ skipping 45 matching lines @@
     /**
      * @param resType The type of the Android resource.
      * @param resId   The id of the Android resource.
      * @return The corresponding {@link LayoutResource}.
      */
     public LayoutResource getResource(int resType, int resId) {
         SparseArray<LayoutResource> bucket = mLoadedResources.get(resType);
         return bucket != null ? bucket.get(resId) : null;
     }
 
+    @SuppressWarnings("cast")
     @Override
     public void onResourceLoaded(int resType, int resId, Resource resource) {
         if (resource == null) return;
 
-        saveMetadataForLoadedResource(resType, resId, resource);
+        if (resType != AndroidResourceType.CRUSHED_SPRITE) {
+            saveMetadataForLoadedResource(resType, resId, resource);
+        }
 
         if (mNativeResourceManagerPtr == 0) return;
+        if (resType == AndroidResourceType.CRUSHED_SPRITE) {
+            if (resource.getBitmap() != null) {
+                CrushedSpriteResource crushedResource = (CrushedSpriteResource) resource;
+                nativeOnCrushedSpriteResourceReady(mNativeResourceManagerPtr, resId,
+                        crushedResource.getBitmap(), crushedResource.getFrameRectangles(),
+                        crushedResource.getSpriteWidth(), crushedResource.getSpriteHeight());
+            }
+            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);
     }
 
     private void saveMetadataForLoadedResource(int resType, int resId, Resource resource) {
         SparseArray<LayoutResource> bucket = mLoadedResources.get(resType);
@@ skipping 16 matching lines @@
         if (loader != null) loader.loadResource(resId);
     }
 
     @CalledByNative
     private void preloadResource(int resType, int resId) {
         ResourceLoader loader = mResourceLoaders.get(resType);
         if (loader != null) loader.preloadResource(resId);
     }
 
     @CalledByNative
+    private void crushedSpriteResourceRequested(int bitmapResId, int metatadataResId,
+            boolean reloading) {
+        if (reloading) {
+            Bitmap bitmap = mCrushedSpriteResourceLoader.reloadResource(bitmapResId);
+            if (bitmap != null) {
+                nativeOnCrushedSpriteResourceReloaded(mNativeResourceManagerPtr, bitmapResId,
+                        bitmap);
+            }
+        } else {
+            mCrushedSpriteResourceLoader.loadResource(bitmapResId, metatadataResId);
+        }
+    }
+
+    @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);
+    private native void nativeOnCrushedSpriteResourceReady(long nativeResourceManagerImpl,
+            int bitmapResId, Bitmap bitmap, int[][] frameRects, int spriteWidth, int spriteHeight);
+    private native void nativeOnCrushedSpriteResourceReloaded(long nativeResourceManagerImpl,
+            int bitmapResId, Bitmap bitmap);
 
 }