Optimize CSS box-shadow performance

src/effects/SkBlurMaskFilter.cpp

Index: src/effects/SkBlurMaskFilter.cpp
diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index e4133a8bceff3ec689c253afb671de8a3113c5fe..fb38cdb07fbf2688617ae77d02d19c5c64c3aff9 100644
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -11,6 +11,7 @@
 #include "SkGpuBlurUtils.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
+#include "SkMaskCache.h"
 #include "SkMaskFilter.h"
 #include "SkRRect.h"
 #include "SkRTConf.h"
@@ -66,6 +67,14 @@ public:
     virtual void computeFastBounds(const SkRect&, SkRect*) const SK_OVERRIDE;
     virtual bool asABlur(BlurRec*) const SK_OVERRIDE;
 
+    static bool getCachedBlurMask(SkScalar sigma,
+                                  unsigned rectCount,
+                                  const SkRect rects[],
+                                  SkCachedMask &mask);
+    static bool getCachedBlurMask(SkScalar sigma,
+                                  const SkRRect rrect,
+                                  SkCachedMask &mask);
+
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBlurMaskFilterImpl)
 
@@ -115,6 +124,23 @@ private:
 
 const SkScalar SkBlurMaskFilterImpl::kMAX_BLUR_SIGMA = SkIntToScalar(128);
 
+bool SkBlurMaskFilterImpl::getCachedBlurMask(SkScalar sigma,

[reed1, 2014/08/25 11:58:42]

Do we really need these helper methods? The caller has to track the cacheID and
remember to unlock it anway, so I think it may be clearer to just have them call
FindAndLock.

[qiankun, 2014/08/26 08:36:33]

Done.

+                                             const SkRRect rrect,
+                                             SkCachedMask &mask) {

[reed1, 2014/08/25 11:58:42]

skia's convention is to only use reference-parameters when they are const (with
the one exception of ReadBuffer). Please pass mask as a ptr.

[qiankun, 2014/08/26 08:36:33]

Done.

+    SkMaskCache::ID* cacheId = SkMaskCache::FindAndLock(sigma, rrect, &mask.fMask);
+    mask.fCacheId = cacheId;

[reed1, 2014/08/25 11:58:42]

Skia's convention is to not set the result fields if we're going to return
false. e.g. mask.fMask should also not be modified if this fails.

[qiankun, 2014/08/26 08:36:33]

Done.

+    return cacheId ? true : false;
+}
+
+bool SkBlurMaskFilterImpl::getCachedBlurMask(SkScalar sigma,
+                                             unsigned rectCount,
+                                             const SkRect rects[],
+                                             SkCachedMask &mask) {
+    SkMaskCache::ID* cacheId = SkMaskCache::FindAndLock(sigma, rectCount, rects, &mask.fMask);
+    mask.fCacheId = cacheId;
+    return cacheId ? true : false;
+}
+
 SkMaskFilter* SkBlurMaskFilter::Create(SkBlurStyle style, SkScalar sigma, uint32_t flags) {
     if (!SkScalarIsFinite(sigma) || sigma <= 0) {
         return NULL;
@@ -368,10 +394,21 @@ SkBlurMaskFilterImpl::filterRRectToNine(const SkRRect& rrect, const SkMatrix& ma
     radii[SkRRect::kLowerLeft_Corner] = LL;
     smallRR.setRectRadii(smallR, radii);
 
+    SkScalar sigma = this->computeXformedSigma(matrix);
+    SkCachedMask cachedBlurMask;
+    cachedBlurMask.fCacheId = NULL;
+    if (getCachedBlurMask(sigma, rrect, cachedBlurMask)) {
+        patch->fCachedMask = cachedBlurMask;
+        patch->fOuterRect = dstM.fBounds;
+        patch->fCenter.fX = SkScalarCeilToInt(leftUnstretched) + 1;
+        patch->fCenter.fY = SkScalarCeilToInt(topUnstretched) + 1;
+        return kTrue_FilterReturn;
+    }
+
     bool analyticBlurWorked = false;
     if (c_analyticBlurRRect) {
         analyticBlurWorked =
-            this->filterRRectMask(&patch->fMask, smallRR, matrix, &margin,
+            this->filterRRectMask(&(patch->fCachedMask.fMask), smallRR, matrix, &margin,
                                   SkMask::kComputeBoundsAndRenderImage_CreateMode);
     }
 
@@ -382,15 +419,20 @@ SkBlurMaskFilterImpl::filterRRectToNine(const SkRRect& rrect, const SkMatrix& ma
 
         SkAutoMaskFreeImage amf(srcM.fImage);
 
-        if (!this->filterMask(&patch->fMask, srcM, matrix, &margin)) {
+        if (!this->filterMask(&(patch->fCachedMask.fMask), srcM, matrix, &margin)) {
             return kFalse_FilterReturn;
         }
     }
 
-    patch->fMask.fBounds.offsetTo(0, 0);
+    patch->fCachedMask.fMask.fBounds.offsetTo(0, 0);
     patch->fOuterRect = dstM.fBounds;
     patch->fCenter.fX = SkScalarCeilToInt(leftUnstretched) + 1;
     patch->fCenter.fY = SkScalarCeilToInt(topUnstretched) + 1;
+    if (!cachedBlurMask.fCacheId) {
+        patch->fCachedMask.fCacheId = SkMaskCache::AddAndLock(sigma, rrect,
+                                                              patch->fCachedMask.fMask);
+    }
+
     return kTrue_FilterReturn;
 }
 
@@ -470,6 +512,16 @@ SkBlurMaskFilterImpl::filterRectsToNine(const SkRect rects[], int count,
                    smallH + (innerIR.top() - srcM.fBounds.top()));
     }
 
+    SkScalar sigma = this->computeXformedSigma(matrix);
+    SkCachedMask cachedBlurMask;
+    cachedBlurMask.fCacheId = NULL;
+    if (getCachedBlurMask(sigma, count, rects, cachedBlurMask)) {
+        patch->fCachedMask = cachedBlurMask;
+        patch->fOuterRect = dstM.fBounds;
+        patch->fCenter = center;
+        return kTrue_FilterReturn;
+    }
+
     // +1 so we get a clean, stretchable, center row/col
     smallW += 1;
     smallH += 1;
@@ -498,21 +550,25 @@ SkBlurMaskFilterImpl::filterRectsToNine(const SkRect rects[], int count,
         if (!draw_rects_into_mask(smallR, count, &srcM)) {
             return kFalse_FilterReturn;
         }
-
         SkAutoMaskFreeImage amf(srcM.fImage);
 
-        if (!this->filterMask(&patch->fMask, srcM, matrix, &margin)) {
+        if (!this->filterMask(&patch->fCachedMask.fMask, srcM, matrix, &margin)) {
             return kFalse_FilterReturn;
         }
     } else {
-        if (!this->filterRectMask(&patch->fMask, smallR[0], matrix, &margin,
+        if (!this->filterRectMask(&patch->fCachedMask.fMask, smallR[0], matrix, &margin,
                                   SkMask::kComputeBoundsAndRenderImage_CreateMode)) {
             return kFalse_FilterReturn;
         }
     }
-    patch->fMask.fBounds.offsetTo(0, 0);
+    patch->fCachedMask.fMask.fBounds.offsetTo(0, 0);
     patch->fOuterRect = dstM.fBounds;
     patch->fCenter = center;
+    if (!cachedBlurMask.fCacheId) {
+        patch->fCachedMask.fCacheId = SkMaskCache::AddAndLock(sigma, count, rects,
+                                                              patch->fCachedMask.fMask);
+    }
+
     return kTrue_FilterReturn;
 }