The key for SkBitmapCache can now be genID+SkIRect

src/core/SkBitmapCache.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapCache.h"
 #include "SkResourceCache.h"
 #include "SkMipMap.h"
@@ skipping 38 matching lines @@
 
 struct BitmapRec : public SkResourceCache::Rec {
     BitmapRec(uint32_t genID, SkScalar scaleX, SkScalar scaleY, const SkIRect& bounds,
               const SkBitmap& result)
         : fKey(genID, scaleX, scaleY, bounds)
         , fBitmap(result)
     {}
 
     BitmapKey   fKey;
     SkBitmap    fBitmap;
-    
+
     virtual const Key& getKey() const SK_OVERRIDE { return fKey; }
     virtual size_t bytesUsed() const SK_OVERRIDE { return sizeof(fKey) + fBitmap.getSize(); }
 };
 
 static bool find_and_return(const BitmapKey& key, SkBitmap* result) {
     const BitmapRec* rec = (BitmapRec*)SkResourceCache::FindAndLock(key);
     if (rec) {
         *result = rec->fBitmap;
         SkResourceCache::Unlock(rec);
 
@@ skipping 24 matching lines @@
     if (0 == invScaleX || 0 == invScaleY) {
         // degenerate, and the key we use for mipmaps
         return;
     }
     SkASSERT(result.isImmutable());
     SkResourceCache::Add(SkNEW_ARGS(BitmapRec, (src.getGenerationID(), invScaleX, invScaleY,
                                                 get_bounds_from_bitmap(src), result)));
 }
 
 bool SkBitmapCache::Find(uint32_t genID, int width, int height, SkBitmap* result) {
-    BitmapKey key(genID, SK_Scalar1, SK_Scalar1, SkIRect::MakeWH(width, height));
+    return Find(genID, SkIRect::MakeWH(width, height), result);
+}
+
+void SkBitmapCache::Add(uint32_t genID, int width, int height, const SkBitmap& result) {
+    Add(genID, SkIRect::MakeWH(width, height), result);
+}
+
+bool SkBitmapCache::Find(uint32_t genID, const SkIRect& subset, SkBitmap* result) {
+    BitmapKey key(genID, SK_Scalar1, SK_Scalar1, subset);
     return find_and_return(key, result);
 }
 
-void SkBitmapCache::Add(uint32_t genID, int width, int height, const SkBitmap& result) {
+void SkBitmapCache::Add(uint32_t genID, const SkIRect& subset, const SkBitmap& result) {
     SkASSERT(result.isImmutable());
-    SkResourceCache::Add(SkNEW_ARGS(BitmapRec, (genID, SK_Scalar1, SK_Scalar1,
-                                                SkIRect::MakeWH(width, height), result)));
+
+    // We need to take only the width and height of 'subset' to compute the intersection

[reed1, 2014/09/02 20:38:45]

Actually the subset rect is very interesting because it can have non-zero
left/top (in the general case). Why are you explicitly zapping those?

[Rémi Piotaix, 2014/09/02 20:48:44]

Because the given subset is relative to the original bitmap from which the
'result' has been extracted.
If we extract, from a 100x100 bitmap, a subset at 90,90 of width 10x10, we will
have:
intersect(rect(0, 0, 10, 10), rect(90, 90, 10, 10)) which will be always empty.

+    SkIRect localSubset = SkIRect::MakeWH(subset.width(), subset.height());
+    SkIRect bitmapBounds = SkIRect::MakeWH(result.width(), result.height());
+
+    if (localSubset.intersect(bitmapBounds)) {
+        SkResourceCache::Add(SkNEW_ARGS(BitmapRec, (genID, SK_Scalar1, SK_Scalar1,
+                                                    localSubset, result)));
+    }
 }
-
 //////////////////////////////////////////////////////////////////////////////////////////
 
 struct MipMapRec : public SkResourceCache::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 sizeof(fKey) + fMipMap->getSize(); }
 };
 
 
 const SkMipMap* SkMipMapCache::FindAndRef(const SkBitmap& src) {
     BitmapKey key(src.getGenerationID(), 0, 0, get_bounds_from_bitmap(src));
     const MipMapRec* rec = (MipMapRec*)SkResourceCache::FindAndLock(key);
     const SkMipMap* result = NULL;
     if (rec) {
         result = SkRef(rec->fMipMap);
         SkResourceCache::Unlock(rec);
     }
     return result;
 }
 
 void SkMipMapCache::Add(const SkBitmap& src, const SkMipMap* result) {
     if (result) {
         SkResourceCache::Add(SkNEW_ARGS(MipMapRec, (src, result)));
     }
 }