expose generalized imagecache key

src/core/SkScaledImageCache.cpp

Index: src/core/SkScaledImageCache.cpp
diff --git a/src/core/SkScaledImageCache.cpp b/src/core/SkScaledImageCache.cpp
index 3e8929358c65bbdc2ccaee2da15fcce09fc6d238..80a2b779e3030b06647badd9c1abe9269299495e 100644
--- a/src/core/SkScaledImageCache.cpp
+++ b/src/core/SkScaledImageCache.cpp
@@ -299,56 +299,18 @@ SkScaledImageCache::Rec* SkScaledImageCache::findAndLock(const SkScaledImageCach
     return rec;
 }
 
-/**
-   This function finds the bounds of the bitmap *within its pixelRef*.
-   If the bitmap lacks a pixelRef, it will return an empty rect, since
-   that doesn't make sense.  This may be a useful enough function that
-   it should be somewhere else (in SkBitmap?). */
-static SkIRect get_bounds_from_bitmap(const SkBitmap& bm) {
-    if (!(bm.pixelRef())) {
-        return SkIRect::MakeEmpty();
-    }
-    SkIPoint origin = bm.pixelRefOrigin();
-    return SkIRect::MakeXYWH(origin.fX, origin.fY, bm.width(), bm.height());
-}
-
-
-SkScaledImageCache::ID* SkScaledImageCache::findAndLock(uint32_t genID,
-                                                        int32_t width,
-                                                        int32_t height,
-                                                        SkBitmap* bitmap) {
-    Rec* rec = this->findAndLock(genID, SK_Scalar1, SK_Scalar1,
-                                 SkIRect::MakeWH(width, height));
-    if (rec) {
-        SkASSERT(NULL == rec->fMip);
-        SkASSERT(rec->fBitmap.pixelRef());
-        *bitmap = rec->fBitmap;
-    }
-    return rec_to_id(rec);
-}
-
-SkScaledImageCache::ID* SkScaledImageCache::findAndLock(const SkBitmap& orig,
-                                                        SkScalar scaleX,
-                                                        SkScalar scaleY,
-                                                        SkBitmap* scaled) {
-    if (0 == scaleX || 0 == scaleY) {
-        // degenerate, and the key we use for mipmaps
-        return NULL;
-    }
-    Rec* rec = this->findAndLock(orig.getGenerationID(), scaleX,
-                                 scaleY, get_bounds_from_bitmap(orig));
+SkScaledImageCache::ID* SkScaledImageCache::findAndLock(const Key& key, SkBitmap* result) {
+    Rec* rec = this->findAndLock(key);
     if (rec) {
         SkASSERT(NULL == rec->fMip);
         SkASSERT(rec->fBitmap.pixelRef());
-        *scaled = rec->fBitmap;
+        *result = rec->fBitmap;
     }
     return rec_to_id(rec);
 }
 
-SkScaledImageCache::ID* SkScaledImageCache::findAndLockMip(const SkBitmap& orig,
-                                                           SkMipMap const ** mip) {
-    Rec* rec = this->findAndLock(orig.getGenerationID(), 0, 0,
-                                 get_bounds_from_bitmap(orig));
+SkScaledImageCache::ID* SkScaledImageCache::findAndLock(const Key& key, SkMipMap const ** mip) {
+    Rec* rec = this->findAndLock(key);
     if (rec) {
         SkASSERT(rec->fMip);
         SkASSERT(NULL == rec->fBitmap.pixelRef());
@@ -385,39 +347,12 @@ SkScaledImageCache::ID* SkScaledImageCache::addAndLock(SkScaledImageCache::Rec*
     return rec_to_id(rec);
 }
 
-SkScaledImageCache::ID* SkScaledImageCache::addAndLock(uint32_t genID,
-                                                       int32_t width,
-                                                       int32_t height,
-                                                       const SkBitmap& bitmap) {
-    GenWHKey key(genID, SK_Scalar1, SK_Scalar1, SkIRect::MakeWH(width, height));
-    Rec* rec = SkNEW_ARGS(Rec, (key, bitmap));
-    return this->addAndLock(rec);
-}
-
-SkScaledImageCache::ID* SkScaledImageCache::addAndLock(const SkBitmap& orig,
-                                                       SkScalar scaleX,
-                                                       SkScalar scaleY,
-                                                       const SkBitmap& scaled) {
-    if (0 == scaleX || 0 == scaleY) {
-        // degenerate, and the key we use for mipmaps
-        return NULL;
-    }
-    SkIRect bounds = get_bounds_from_bitmap(orig);
-    if (bounds.isEmpty()) {
-        return NULL;
-    }
-    GenWHKey key(orig.getGenerationID(), scaleX, scaleY, bounds);
+SkScaledImageCache::ID* SkScaledImageCache::addAndLock(const Key& key, const SkBitmap& scaled) {
     Rec* rec = SkNEW_ARGS(Rec, (key, scaled));
     return this->addAndLock(rec);
 }
 
-SkScaledImageCache::ID* SkScaledImageCache::addAndLockMip(const SkBitmap& orig,
-                                                          const SkMipMap* mip) {
-    SkIRect bounds = get_bounds_from_bitmap(orig);
-    if (bounds.isEmpty()) {
-        return NULL;
-    }
-    GenWHKey key(orig.getGenerationID(), 0, 0, bounds);
+SkScaledImageCache::ID* SkScaledImageCache::addAndLock(const Key& key, const SkMipMap* mip) {
     Rec* rec = SkNEW_ARGS(Rec, (key, mip));
     return this->addAndLock(rec);
 }
@@ -663,52 +598,24 @@ static SkScaledImageCache* get_cache() {
     return gScaledImageCache;
 }
 
-
-SkScaledImageCache::ID* SkScaledImageCache::FindAndLock(
-                                uint32_t pixelGenerationID,
-                                int32_t width,
-                                int32_t height,
-                                SkBitmap* scaled) {
-    SkAutoMutexAcquire am(gMutex);
-    return get_cache()->findAndLock(pixelGenerationID, width, height, scaled);
-}
-
-SkScaledImageCache::ID* SkScaledImageCache::AddAndLock(
-                               uint32_t pixelGenerationID,
-                               int32_t width,
-                               int32_t height,
-                               const SkBitmap& scaled) {
-    SkAutoMutexAcquire am(gMutex);
-    return get_cache()->addAndLock(pixelGenerationID, width, height, scaled);
-}
-
-
-SkScaledImageCache::ID* SkScaledImageCache::FindAndLock(const SkBitmap& orig,
-                                                        SkScalar scaleX,
-                                                        SkScalar scaleY,
-                                                        SkBitmap* scaled) {
+SkScaledImageCache::ID* SkScaledImageCache::FindAndLock(const Key& key, SkBitmap* result) {
     SkAutoMutexAcquire am(gMutex);
-    return get_cache()->findAndLock(orig, scaleX, scaleY, scaled);
+    return get_cache()->findAndLock(key, result);
 }
 
-SkScaledImageCache::ID* SkScaledImageCache::FindAndLockMip(const SkBitmap& orig,
-                                                       SkMipMap const ** mip) {
+SkScaledImageCache::ID* SkScaledImageCache::FindAndLock(const Key& key, SkMipMap const ** mip) {
     SkAutoMutexAcquire am(gMutex);
-    return get_cache()->findAndLockMip(orig, mip);
+    return get_cache()->findAndLock(key, mip);
 }
 
-SkScaledImageCache::ID* SkScaledImageCache::AddAndLock(const SkBitmap& orig,
-                                                       SkScalar scaleX,
-                                                       SkScalar scaleY,
-                                                       const SkBitmap& scaled) {
+SkScaledImageCache::ID* SkScaledImageCache::AddAndLock(const Key& key, const SkBitmap& scaled) {
     SkAutoMutexAcquire am(gMutex);
-    return get_cache()->addAndLock(orig, scaleX, scaleY, scaled);
+    return get_cache()->addAndLock(key, scaled);
 }
 
-SkScaledImageCache::ID* SkScaledImageCache::AddAndLockMip(const SkBitmap& orig,
-                                                          const SkMipMap* mip) {
+SkScaledImageCache::ID* SkScaledImageCache::AddAndLock(const Key& key, const SkMipMap* mip) {
     SkAutoMutexAcquire am(gMutex);
-    return get_cache()->addAndLockMip(orig, mip);
+    return get_cache()->addAndLock(key, mip);
 }
 
 void SkScaledImageCache::Unlock(SkScaledImageCache::ID* id) {