expose generalized imagecache key

src/core/SkScaledImageCache.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkChecksum.h"
 #include "SkScaledImageCache.h"
 #include "SkMipMap.h"
@@ skipping 261 matching lines @@
 
     uint32_t    fGenID;
     SkScalar    fScaleX;
     SkScalar    fScaleY;
     SkIRect     fBounds;
 };
 
 SkScaledImageCache::Rec* SkScaledImageCache::findAndLock(uint32_t genID,
                                                         SkScalar scaleX,
                                                         SkScalar scaleY,
                                                         const SkIRect& bounds) {

[qiankun, 2014/08/21 16:15:03]

This function doesn't need any more.

[reed1, 2014/08/21 16:32:46]

Good catch. Done.

     return this->findAndLock(GenWHKey(genID, scaleX, scaleY, bounds));
 }
 
 /**
    This private method is the fully general record finder. All other
    record finders should call this function or the one above. */
 SkScaledImageCache::Rec* SkScaledImageCache::findAndLock(const SkScaledImageCache::Key& key) {
 #ifdef USE_HASH
     Rec* rec = fHash->find(key);
 #else
     Rec* rec = find_rec_in_list(fHead, key);
 #endif
     if (rec) {
         this->moveToHead(rec);  // for our LRU
         rec->fLockCount += 1;
     }
     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));
+SkScaledImageCache::ID* SkScaledImageCache::findAndLock(const Key& key, SkBitmap* result) {
+    Rec* rec = this->findAndLock(key);
     if (rec) {
         SkASSERT(NULL == rec->fMip);
         SkASSERT(rec->fBitmap.pixelRef());
-        *bitmap = rec->fBitmap;
+        *result = 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));
-    if (rec) {
-        SkASSERT(NULL == rec->fMip);
-        SkASSERT(rec->fBitmap.pixelRef());
-        *scaled = 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());
         *mip = rec->fMip;
     }
     return rec_to_id(rec);
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 16 matching lines @@
     SkASSERT(1 == rec->fLockCount);
 #ifdef USE_HASH
     SkASSERT(fHash);
     fHash->add(rec);
 #endif
     // We may (now) be overbudget, so see if we need to purge something.
     this->purgeAsNeeded();
     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);
 }
 
 void SkScaledImageCache::unlock(SkScaledImageCache::ID* id) {
     SkASSERT(id);
 
 #ifdef SK_DEBUG
     {
         bool found = false;
@@ skipping 225 matching lines @@
 #ifdef SK_USE_DISCARDABLE_SCALEDIMAGECACHE
         gScaledImageCache = SkNEW_ARGS(SkScaledImageCache, (SkDiscardableMemory::Create));
 #else
         gScaledImageCache = SkNEW_ARGS(SkScaledImageCache, (SK_DEFAULT_IMAGE_CACHE_LIMIT));
 #endif
         atexit(cleanup_gScaledImageCache);
     }
     return gScaledImageCache;
 }
 
-
-SkScaledImageCache::ID* SkScaledImageCache::FindAndLock(
-                                uint32_t pixelGenerationID,
-                                int32_t width,
-                                int32_t height,
-                                SkBitmap* scaled) {
+SkScaledImageCache::ID* SkScaledImageCache::FindAndLock(const Key& key, SkBitmap* result) {
     SkAutoMutexAcquire am(gMutex);
-    return get_cache()->findAndLock(pixelGenerationID, width, height, scaled);
+    return get_cache()->findAndLock(key, result);
 }
 
-SkScaledImageCache::ID* SkScaledImageCache::AddAndLock(
-                               uint32_t pixelGenerationID,
-                               int32_t width,
-                               int32_t height,
-                               const SkBitmap& scaled) {
+SkScaledImageCache::ID* SkScaledImageCache::FindAndLock(const Key& key, SkMipMap const ** mip) {
     SkAutoMutexAcquire am(gMutex);
-    return get_cache()->addAndLock(pixelGenerationID, width, height, scaled);
+    return get_cache()->findAndLock(key, mip);
 }
 
-
-SkScaledImageCache::ID* SkScaledImageCache::FindAndLock(const SkBitmap& orig,
-                                                        SkScalar scaleX,
-                                                        SkScalar scaleY,
-                                                        SkBitmap* scaled) {
+SkScaledImageCache::ID* SkScaledImageCache::AddAndLock(const Key& key, const SkBitmap& scaled) {
     SkAutoMutexAcquire am(gMutex);
-    return get_cache()->findAndLock(orig, scaleX, scaleY, scaled);
+    return get_cache()->addAndLock(key, scaled);
 }
 
-SkScaledImageCache::ID* SkScaledImageCache::FindAndLockMip(const SkBitmap& orig,
-                                                       SkMipMap const ** mip) {
+SkScaledImageCache::ID* SkScaledImageCache::AddAndLock(const Key& key, const SkMipMap* mip) {
     SkAutoMutexAcquire am(gMutex);
-    return get_cache()->findAndLockMip(orig, mip);
-}
-
-SkScaledImageCache::ID* SkScaledImageCache::AddAndLock(const SkBitmap& orig,
-                                                       SkScalar scaleX,
-                                                       SkScalar scaleY,
-                                                       const SkBitmap& scaled) {
-    SkAutoMutexAcquire am(gMutex);
-    return get_cache()->addAndLock(orig, scaleX, scaleY, scaled);
-}
-
-SkScaledImageCache::ID* SkScaledImageCache::AddAndLockMip(const SkBitmap& orig,
-                                                          const SkMipMap* mip) {
-    SkAutoMutexAcquire am(gMutex);
-    return get_cache()->addAndLockMip(orig, mip);
+    return get_cache()->addAndLock(key, mip);
 }
 
 void SkScaledImageCache::Unlock(SkScaledImageCache::ID* id) {
     SkAutoMutexAcquire am(gMutex);
     get_cache()->unlock(id);
 
 //    get_cache()->dump();
 }
 
 size_t SkScaledImageCache::GetTotalBytesUsed() {
@@ skipping 48 matching lines @@
 }
 
 size_t SkGraphics::GetImageCacheSingleAllocationByteLimit() {
     return SkScaledImageCache::GetSingleAllocationByteLimit();
 }
 
 size_t SkGraphics::SetImageCacheSingleAllocationByteLimit(size_t newLimit) {
     return SkScaledImageCache::SetSingleAllocationByteLimit(newLimit);
 }