Use SkImageCacherator in SkImages

src/gpu/SkGr.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGr.h"
 
 #include "GrCaps.h"
@@ skipping 137 matching lines @@
         GrUniqueKey::Builder builder(stretchedKey, origKey, kDomain, 2);
         builder[0] = stretch.fType;
         builder[1] = width | (height << 16);
         builder.finish();
         return true;
     }
     SkASSERT(!stretchedKey->isValid());
     return false;
 }
 
-static void make_unstretched_key(GrUniqueKey* key, uint32_t imageID,
-                                 U16CPU width, U16CPU height, SkIPoint origin) {
-    SkASSERT((uint16_t)width == width);
-    SkASSERT((uint16_t)height == height);
+static void make_unstretched_key(GrUniqueKey* key, uint32_t imageID, const SkIRect& subset) {
+    SkASSERT(SkIsU16(subset.width()));
+    SkASSERT(SkIsU16(subset.height()));
 
     static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey::Builder builder(key, kDomain, 4);
     builder[0] = imageID;
-    builder[1] = origin.fX;
-    builder[2] = origin.fY;
-    builder[3] = width | (height << 16);
+    builder[1] = subset.x();
+    builder[2] = subset.y();
+    builder[3] = subset.width() | (subset.height() << 16);
 }
 
-void GrMakeKeyFromImageID(GrUniqueKey* key, uint32_t imageID,
-                          U16CPU width, U16CPU height, SkIPoint origin,
+void GrMakeKeyFromImageID(GrUniqueKey* key, uint32_t imageID, const SkIRect& subset,
                           const GrCaps& caps, SkImageUsageType usage) {
     const Stretch::Type stretches[] = {
         Stretch::kNone_Type,        // kUntiled_SkImageUsageType
         Stretch::kNearest_Type,     // kTiled_Unfiltered_SkImageUsageType
         Stretch::kBilerp_Type,      // kTiled_Filtered_SkImageUsageType
     };
 
-    const bool isPow2 = SkIsPow2(width) && SkIsPow2(height);
+    const bool isPow2 = SkIsPow2(subset.width()) && SkIsPow2(subset.height());
     const bool needToStretch = !isPow2 &&
                                usage != kUntiled_SkImageUsageType &&
                                !caps.npotTextureTileSupport();
 
     if (needToStretch) {
         GrUniqueKey tmpKey;
-        make_unstretched_key(&tmpKey, imageID, width, height, origin);
+        make_unstretched_key(&tmpKey, imageID, subset);
 
         Stretch stretch;
         stretch.fType = stretches[usage];
-        stretch.fWidth = SkNextPow2(width);
-        stretch.fHeight = SkNextPow2(height);
+        stretch.fWidth = SkNextPow2(subset.width());
+        stretch.fHeight = SkNextPow2(subset.height());
         if (!make_stretched_key(tmpKey, stretch, key)) {
             goto UNSTRETCHED;
         }
     } else {
         UNSTRETCHED:
-        make_unstretched_key(key, imageID, width, height, origin);
+        make_unstretched_key(key, imageID, subset);
     }
 }
 
-static void make_unstretched_key(const SkBitmap& bitmap, GrUniqueKey* key) {
-    make_unstretched_key(key, bitmap.getGenerationID(), bitmap.width(), bitmap.height(),
-                         bitmap.pixelRefOrigin());
-}
-
-static void make_bitmap_keys(const SkBitmap& bitmap,
-                             const Stretch& stretch,
-                             GrUniqueKey* key,
-                             GrUniqueKey* stretchedKey) {
-    make_unstretched_key(bitmap, key);
+static void make_image_keys(uint32_t imageID, const SkIRect& subset, const Stretch& stretch,
+                            GrUniqueKey* key, GrUniqueKey* stretchedKey) {
+    make_unstretched_key(key, imageID, subset);
     if (Stretch::kNone_Type != stretch.fType) {
         make_stretched_key(*key, stretch, stretchedKey);
     }
 }
 
 static void generate_bitmap_texture_desc(const SkBitmap& bitmap, GrSurfaceDesc* desc) {
     desc->fFlags = kNone_GrSurfaceFlags;
     desc->fWidth = bitmap.width();
     desc->fHeight = bitmap.height();
     desc->fConfig = SkImageInfo2GrPixelConfig(bitmap.info());
@@ skipping 305 matching lines @@
                 // than the min texture size. In that case do cpu stretching.
                 SkBitmap stretchedBmp = stretch_on_cpu(bmp, stretch);
                 return create_unstretched_bitmap_texture(ctx, stretchedBmp, stretchedKey);
             }
         }
         return stretch_texture(unstretched, stretch, bmp.pixelRef(), stretchedKey);
     }
     return create_unstretched_bitmap_texture(ctx, bmp, unstretchedKey);
 }
 
-bool GrIsBitmapInCache(const GrContext* ctx,
-                       const SkBitmap& bitmap,
-                       const GrTextureParams* params) {
+bool GrIsImageInCache(const GrContext* ctx, uint32_t imageID, const SkIRect& subset,
+                      GrTexture* nativeTexture, const GrTextureParams* params) {
     Stretch stretch;
-    get_stretch(ctx, bitmap.width(), bitmap.height(), params, &stretch);
+    get_stretch(ctx, subset.width(), subset.height(), params, &stretch);
 
-    // Handle the case where the bitmap is explicitly texture backed.
-    GrTexture* texture = bitmap.getTexture();
-    if (texture) {
+    // Handle the case where the bitmap/image is explicitly texture backed.
+    if (nativeTexture) {
         if (Stretch::kNone_Type == stretch.fType) {
             return true;
         }
-        // No keys for volatile bitmaps.
-        if (bitmap.isVolatile()) {
-            return false;
-        }
-        const GrUniqueKey& key = texture->getUniqueKey();
+        const GrUniqueKey& key = nativeTexture->getUniqueKey();
         if (!key.isValid()) {
             return false;
         }
         GrUniqueKey stretchedKey;
         make_stretched_key(key, stretch, &stretchedKey);
         return ctx->textureProvider()->existsTextureWithUniqueKey(stretchedKey);
     }
 
-    // We don't cache volatile bitmaps
-    if (bitmap.isVolatile()) {
-        return false;
-    }
-
     GrUniqueKey key, stretchedKey;
-    make_bitmap_keys(bitmap, stretch, &key, &stretchedKey);
+    make_image_keys(imageID, subset, stretch, &key, &stretchedKey);
     return ctx->textureProvider()->existsTextureWithUniqueKey(
         (Stretch::kNone_Type == stretch.fType) ? key : stretchedKey);
 }
 
+bool GrIsBitmapInCache(const GrContext* ctx, const SkBitmap& bitmap,
+                       const GrTextureParams* params) {
+    if (bitmap.isVolatile()) {
+        return false;   // we don't cache volatile bitmaps.
+    }
+    return GrIsImageInCache(ctx, bitmap.getGenerationID(), bitmap.getSubset(), bitmap.getTexture(),
+                            params);
+}
+
 GrTexture* GrRefCachedBitmapTexture(GrContext* ctx,
                                     const SkBitmap& bitmap,
                                     const GrTextureParams* params) {
 
     Stretch stretch;
     get_stretch(ctx, bitmap.width(), bitmap.height(), params, &stretch);
 
     GrTexture* result = bitmap.getTexture();
     if (result) {
         if (Stretch::kNone_Type == stretch.fType) {
@@ skipping 12 matching lines @@
                 }
             }
         }
         return stretch_texture(result, stretch, bitmap.pixelRef(), stretchedKey);
     }
 
     GrUniqueKey key, resizedKey;
 
     if (!bitmap.isVolatile()) {
         // If the bitmap isn't changing try to find a cached copy first.
-        make_bitmap_keys(bitmap, stretch, &key, &resizedKey);
+        make_image_keys(bitmap.getGenerationID(), bitmap.getSubset(), stretch, &key, &resizedKey);
 
         result = ctx->textureProvider()->findAndRefTextureByUniqueKey(
             resizedKey.isValid() ? resizedKey : key);
         if (result) {
             return result;
         }
     }
 
     result = create_bitmap_texture(ctx, bitmap, stretch, key, resizedKey);
     if (result) {
@@ skipping 244 matching lines @@
             SkErrorInternals::SetError( kInvalidPaint_SkError,
                                         "Sorry, I don't understand the filtering "
                                         "mode you asked for.  Falling back to "
                                         "MIPMaps.");
             textureFilterMode = GrTextureParams::kMipMap_FilterMode;
             break;
 
     }
     return textureFilterMode;
 }