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 "SkRect.h"
 
@@ skipping 21 matching lines @@
     {
         this->init(sizeof(fGenID) + sizeof(fScaleX) + sizeof(fScaleY) + sizeof(fBounds));
     }
     
     uint32_t    fGenID;
     SkScalar    fScaleX;
     SkScalar    fScaleY;
     SkIRect     fBounds;
 };
 
+struct RRectBlurKey : public SkScaledImageCache::Key {
+public:
+    RRectBlurKey(SkScalar sigma, const SkRRect rrect)
+        : fSigma(sigma)
+        , fRRect(rrect) {
+        this->init(sizeof(fSigma) + sizeof(fRRect));
+    }
+
+    SkScalar    fSigma;
+    SkRRect     fRRect;
+};
+
+struct RectsBlurKey : public SkScaledImageCache::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];
+};
+
 //////////////////////////////////////////////////////////////////////////////////////////
 
 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));
@@ skipping 30 matching lines @@
 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);
 }
 
 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* SkBitmapCache::FindAndLock(SkScalar sigma,
+                                                   const SkRRect rrect,
+                                                   SkBitmap* result) {
+    RRectBlurKey key(sigma, rrect);
+    return SkScaledImageCache::FindAndLock(key, result);
+}
+
+SkScaledImageCache::ID* SkBitmapCache::AddAndLock(SkScalar sigma,
+                                                  const SkRRect rrect,
+                                                  const SkBitmap& bitmap) {
+    RRectBlurKey key(sigma, rrect);
+    return SkScaledImageCache::AddAndLock(key, bitmap);
+}
+
+////
+
+SkScaledImageCache::ID* SkBitmapCache::FindAndLock(SkScalar sigma,
+                                                   unsigned count,
+                                                   const SkRect rects[],
+                                                   SkBitmap* result) {
+    RectsBlurKey key(sigma, count, rects);
+    return SkScaledImageCache::FindAndLock(key, result);
+}
+
+SkScaledImageCache::ID* SkBitmapCache::AddAndLock(SkScalar sigma,
+                                                  unsigned count,
+                                                  const SkRect rects[],
+                                                  const SkBitmap& bitmap) {
+    RectsBlurKey key(sigma, count, rects);
+    return SkScaledImageCache::AddAndLock(key, bitmap);
+}
+