Optimize CSS box-shadow performance

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 43 matching lines @@
         , 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(); }
 };
 
+struct RRectBlurKey : public SkResourceCache::Key {
+public:
+    RRectBlurKey(SkScalar sigma, const SkRRect& rrect)
+        : fSigma(sigma)
+        , fRRect(rrect) {
+        this->init(sizeof(fSigma) + sizeof(fRRect));
+    }
+
+    SkScalar    fSigma;
+    SkRRect     fRRect;
+};
+
+struct RRectBlurRec : public SkResourceCache::Rec {
+    RRectBlurRec(SkScalar sigma, const SkRRect& rrect, const SkBitmap& result)
+        : fKey(sigma, rrect)
+        , fBitmap(result)
+    {}
+
+    RRectBlurKey   fKey;
+    SkBitmap       fBitmap;
+
+    virtual const Key& getKey() const SK_OVERRIDE { return fKey; }
+    virtual size_t bytesUsed() const SK_OVERRIDE { return sizeof(fKey) + sizeof(fBitmap); }

[reed1, 2014/09/04 14:15:39]

sizeof(fBitmap) does not account for the ram of the pixels. should be
fBitmap.getSize()

[qiankun, 2014/09/09 03:03:03]

Done.

+};
+
+struct RectsBlurKey : public SkResourceCache::Key {
+public:
+    RectsBlurKey(SkScalar sigma, int32_t count, const SkRect rects[])
+        : fSigma(sigma)
+        , fRecCount(count) {
+        for (int i = 0; i < count; i++) {
+            fRects[i] = rects[i];
+        }
+        this->init(sizeof(fSigma) + sizeof(fRecCount) + sizeof(SkRect) * fRecCount);
+    }
+
+    SkScalar    fSigma;
+    int32_t     fRecCount;
+    SkRect      fRects[2];
+};
+
+struct RectsBlurRec : public SkResourceCache::Rec {
+    RectsBlurRec(SkScalar sigma, unsigned count, const SkRect rects[], const SkBitmap& result)
+        : fKey(sigma, count, rects)
+        , fBitmap(result)
+    {}
+
+    RectsBlurKey   fKey;
+    SkBitmap       fBitmap;
+
+    virtual const Key& getKey() const SK_OVERRIDE { return fKey; }
+    virtual size_t bytesUsed() const SK_OVERRIDE { return sizeof(fKey) + sizeof(fBitmap); }
+};
 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);
 
         result->lockPixels();
         if (result->getPixels()) {
             return true;
         }
         // todo: we should explicitly purge rec from the cache at this point, since
         //       it is effectively purged already (has no memory behind it)
         result->reset();
         // fall-through to false
     }
     return false;
 }
 
+static bool find_and_return(const RRectBlurKey& key, SkBitmap* result) {
+    const RRectBlurRec* rec = (RRectBlurRec*)SkResourceCache::FindAndLock(key);
+    if (rec) {
+        *result = rec->fBitmap;
+        SkResourceCache::Unlock(rec);
+
+        result->lockPixels();
+        if (result->getPixels()) {
+            return true;
+        }
+        // todo: we should explicitly purge rec from the cache at this point, since
+        //       it is effectively purged already (has no memory behind it)
+        result->reset();
+        // fall-through to false
+    }
+    return false;
+}
+
+static bool find_and_return(const RectsBlurKey& key, SkBitmap* result) {
+    const RectsBlurRec* rec = (RectsBlurRec*)SkResourceCache::FindAndLock(key);
+    if (rec) {
+        *result = rec->fBitmap;
+        SkResourceCache::Unlock(rec);
+
+        result->lockPixels();
+        if (result->getPixels()) {
+            return true;
+        }
+        // todo: we should explicitly purge rec from the cache at this point, since
+        //       it is effectively purged already (has no memory behind it)
+        result->reset();
+        // fall-through to false
+    }
+    return false;
+}
+
 bool SkBitmapCache::Find(const SkBitmap& src, SkScalar invScaleX, SkScalar invScaleY,
                          SkBitmap* result) {
     if (0 == invScaleX || 0 == invScaleY) {
         // degenerate, and the key we use for mipmaps
         return false;
     }
     BitmapKey key(src.getGenerationID(), invScaleX, invScaleY, get_bounds_from_bitmap(src));
     return find_and_return(key, result);
 }
 
@@ skipping 22 matching lines @@
         || result.width() != subset.width()
         || result.height() != subset.height()) {
         return false;
     } else {
         SkResourceCache::Add(SkNEW_ARGS(BitmapRec, (genID, SK_Scalar1, SK_Scalar1,
                                                     subset, result)));
 
         return true;
     }
 }
+
+bool SkBitmapCache::Find(SkScalar sigma, const SkRRect& rrect, SkBitmap* result) {
+    RRectBlurKey key(sigma, rrect);
+    return find_and_return(key, result);
+}
+
+void SkBitmapCache::Add(SkScalar sigma, const SkRRect& rrect, const SkBitmap& result) {
+    SkResourceCache::Add(SkNEW_ARGS(RRectBlurRec, (sigma, rrect, result)));
+}
+
+bool SkBitmapCache::Find(SkScalar sigma, int32_t count, const SkRect rects[], SkBitmap* result) {
+    RectsBlurKey key(sigma, count, rects);
+    return find_and_return(key, result);
+}
+
+void SkBitmapCache::Add(SkScalar sigma, int32_t count, const SkRect rects[], const SkBitmap& result) {
+    SkResourceCache::Add(SkNEW_ARGS(RectsBlurRec, (sigma, count, rects, 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();
@@ skipping 17 matching lines @@
     }
     return result;
 }
 
 void SkMipMapCache::Add(const SkBitmap& src, const SkMipMap* result) {
     if (result) {
         SkResourceCache::Add(SkNEW_ARGS(MipMapRec, (src, result)));
     }
 }