retool image cache to be generic cache

src/core/SkBitmapCache.cpp

Index: src/core/SkBitmapCache.cpp
diff --git a/src/core/SkBitmapCache.cpp b/src/core/SkBitmapCache.cpp
index 1713fe4c50f0cdcfe1bd79d9e550096aa6aa2d61..c6baf4d8897637a2a901d61ebc2b989b491421f2 100644
--- a/src/core/SkBitmapCache.cpp
+++ b/src/core/SkBitmapCache.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "SkBitmapCache.h"
+#include "SkMipMap.h"
 #include "SkRect.h"
 
 /**
@@ -41,51 +42,103 @@ public:
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
-SkScaledImageCache::ID* SkBitmapCache::FindAndLock(const SkBitmap& src,
+struct BitmapRec : public SkScaledImageCache::Rec {
+    BitmapRec(uint32_t genID, SkScalar scaleX, SkScalar scaleY, const SkIRect& bounds,
+              const SkBitmap& result)
+        : fKey(genID, scaleX, scaleY, bounds)
+        , fBitmap(result)
+    {}
+
+    BitmapKey   fKey;

[qiankun, 2014/08/26 07:12:40]

Can we use pointer type for fKey to avoid using virtual function? New a Key
object when doing AddAndLock(), and delete it in Rec's destructor.

[reed1, 2014/08/26 14:04:02]

If the virtual call overhead shows up as a problem, we can consider having the
base-class cache the returned address.

+    SkBitmap    fBitmap;
+    
+    virtual const Key& getKey() const SK_OVERRIDE { return fKey; }
+    virtual size_t bytesUsed() const SK_OVERRIDE { return fBitmap.getSize(); }
+};
+
+SkScaledImageCache::ID SkBitmapCache::FindAndLock(const SkBitmap& src,
                                                    SkScalar invScaleX, SkScalar invScaleY,
                                                    SkBitmap* result) {
     if (0 == invScaleX || 0 == invScaleY) {
         // degenerate, and the key we use for mipmaps
         return NULL;
     }
+
     BitmapKey key(src.getGenerationID(), invScaleX, invScaleY, get_bounds_from_bitmap(src));
-    return SkScaledImageCache::FindAndLock(key, result);
+    const BitmapRec* rec = (BitmapRec*)SkScaledImageCache::FindAndLock(key);
+    if (rec) {
+        *result = rec->fBitmap;
+        return rec;
+    }
+    return NULL;
 }
 
-SkScaledImageCache::ID* SkBitmapCache::AddAndLock(const SkBitmap& src,
+SkScaledImageCache::ID SkBitmapCache::AddAndLock(const SkBitmap& src,
                                                   SkScalar invScaleX, SkScalar invScaleY,
                                                   const SkBitmap& result) {
     if (0 == invScaleX || 0 == invScaleY) {
         // degenerate, and the key we use for mipmaps
         return NULL;
     }
-    BitmapKey key(src.getGenerationID(), invScaleX, invScaleY, get_bounds_from_bitmap(src));
-    return SkScaledImageCache::AddAndLock(key, result);
+    return SkScaledImageCache::AddAndLock(SkNEW_ARGS(BitmapRec,
+                                                     (src.getGenerationID(), invScaleX, invScaleY,
+                                                      get_bounds_from_bitmap(src),
+                                                      result)));
 }
 
-////
-
-SkScaledImageCache::ID* SkBitmapCache::FindAndLock(uint32_t genID, int width, int height,
+SkScaledImageCache::ID SkBitmapCache::FindAndLock(uint32_t genID, int width, int height,
                                                    SkBitmap* result) {
     BitmapKey key(genID, SK_Scalar1, SK_Scalar1, SkIRect::MakeWH(width, height));
-    return SkScaledImageCache::FindAndLock(key, result);
+    const BitmapRec* rec = (BitmapRec*)SkScaledImageCache::FindAndLock(key);
+    if (rec) {
+        *result = rec->fBitmap;
+        return rec;
+    }
+    return NULL;
 }
 
-SkScaledImageCache::ID* SkBitmapCache::AddAndLock(uint32_t genID, int width, int height,
+SkScaledImageCache::ID SkBitmapCache::AddAndLock(uint32_t genID, int width, int height,
                                                      const SkBitmap& result) {
-    BitmapKey key(genID, SK_Scalar1, SK_Scalar1, SkIRect::MakeWH(width, height));
-    return SkScaledImageCache::AddAndLock(key, result);
+    return SkScaledImageCache::AddAndLock(SkNEW_ARGS(BitmapRec,
+                                                     (genID, SK_Scalar1, SK_Scalar1,
+                                                      SkIRect::MakeWH(width, height),
+                                                      result)));
 }
 
-////
+//////////////////////////////////////////////////////////////////////////////////////////
 
-SkScaledImageCache::ID* SkMipMapCache::FindAndLock(const SkBitmap& src, const SkMipMap** result) {
-    BitmapKey key(src.getGenerationID(), SK_Scalar1, SK_Scalar1, get_bounds_from_bitmap(src));
-    return SkScaledImageCache::FindAndLock(key, result);
+struct MipMapRec : public SkScaledImageCache::Rec {
+    MipMapRec(const SkBitmap& src, const SkMipMap* result)
+        : fKey(src.getGenerationID(), 0, 0, get_bounds_from_bitmap(src))
+        , fMipMap(SkRef(result))
+    {}
+
+    virtual ~MipMapRec() {
+        fMipMap->unref();
+    }
+
+    BitmapKey       fKey;
+    const SkMipMap* fMipMap;
+    
+    virtual const Key& getKey() const SK_OVERRIDE { return fKey; }
+    virtual size_t bytesUsed() const SK_OVERRIDE { return fMipMap->getSize(); }
+};
+
+
+SkScaledImageCache::ID SkMipMapCache::FindAndLock(const SkBitmap& src, const SkMipMap** result) {
+    BitmapKey key(src.getGenerationID(), 0, 0, get_bounds_from_bitmap(src));
+    const MipMapRec* rec = (MipMapRec*)SkScaledImageCache::FindAndLock(key);
+    if (rec) {
+        *result = rec->fMipMap;
+        return rec;
+    }
+    return NULL;
 }
 
-SkScaledImageCache::ID* SkMipMapCache::AddAndLock(const SkBitmap& src, const SkMipMap* result) {
-    BitmapKey key(src.getGenerationID(), SK_Scalar1, SK_Scalar1, get_bounds_from_bitmap(src));
-    return SkScaledImageCache::AddAndLock(key, result);
+SkScaledImageCache::ID SkMipMapCache::AddAndLock(const SkBitmap& src, const SkMipMap* result) {
+    if (NULL == result) {
+        return NULL;
+    }
+    return SkScaledImageCache::AddAndLock(SkNEW_ARGS(MipMapRec, (src, result)));
 }