Optimize CSS box-shadow performance

src/effects/SkBlurMaskFilter.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBlurMaskFilter.h"
 #include "SkBlurMask.h"
 #include "SkGpuBlurUtils.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
+#include "SkMaskCache.h"
 #include "SkMaskFilter.h"
 #include "SkRRect.h"
 #include "SkRTConf.h"
 #include "SkStringUtils.h"
 #include "SkStrokeRec.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrTexture.h"
 #include "GrEffect.h"
@@ skipping 337 matching lines @@
     SkRect smallR = SkRect::MakeWH(totalSmallWidth, totalSmallHeight);
 
     SkRRect smallRR;
     SkVector radii[4];
     radii[SkRRect::kUpperLeft_Corner] = UL;
     radii[SkRRect::kUpperRight_Corner] = UR;
     radii[SkRRect::kLowerRight_Corner] = LR;
     radii[SkRRect::kLowerLeft_Corner] = LL;
     smallRR.setRectRadii(smallR, radii);
 
+    SkScalar sigma = this->computeXformedSigma(matrix);
+    if (SkMaskCache::Find(sigma, rrect, &patch->fMask)) {
+        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,
                                   SkMask::kComputeBoundsAndRenderImage_CreateMode);
     }
 
     if (!analyticBlurWorked) {
         if (!draw_rrect_into_mask(smallRR, &srcM)) {
             return kFalse_FilterReturn;
         }
 
         SkAutoMaskFreeImage amf(srcM.fImage);
 
         if (!this->filterMask(&patch->fMask, srcM, matrix, &margin)) {
             return kFalse_FilterReturn;
         }
     }
 
     patch->fMask.fBounds.offsetTo(0, 0);
     patch->fOuterRect = dstM.fBounds;
     patch->fCenter.fX = SkScalarCeilToInt(leftUnstretched) + 1;
     patch->fCenter.fY = SkScalarCeilToInt(topUnstretched) + 1;
+    SkMaskCache::Add(sigma, rrect, patch->fMask);
+
     return kTrue_FilterReturn;
 }
 
 SK_CONF_DECLARE( bool, c_analyticBlurNinepatch, "mask.filter.analyticNinePatch", true, "Use the faster analytic blur approach for ninepatch rects" );
 
 SkMaskFilter::FilterReturn
 SkBlurMaskFilterImpl::filterRectsToNine(const SkRect rects[], int count,
                                         const SkMatrix& matrix,
                                         const SkIRect& clipBounds,
                                         NinePatch* patch) const {
@@ skipping 59 matching lines @@
     if (1 == count) {
         innerIR = srcM.fBounds;
         center.set(smallW, smallH);
     } else {
         SkASSERT(2 == count);
         rects[1].roundIn(&innerIR);
         center.set(smallW + (innerIR.left() - srcM.fBounds.left()),
                    smallH + (innerIR.top() - srcM.fBounds.top()));
     }
 
+    SkScalar sigma = this->computeXformedSigma(matrix);
+    if (SkMaskCache::Find(sigma, count, rects, &patch->fMask)) {
+        patch->fOuterRect = dstM.fBounds;
+        patch->fCenter = center;
+        return kTrue_FilterReturn;
+    }
+
     // +1 so we get a clean, stretchable, center row/col
     smallW += 1;
     smallH += 1;
 
     // we want the inset amounts to be integral, so we don't change any
     // fractional phase on the fRight or fBottom of our smallR.
     const SkScalar dx = SkIntToScalar(innerIR.width() - smallW);
     const SkScalar dy = SkIntToScalar(innerIR.height() - smallH);
     if (dx < 0 || dy < 0) {
         // we're too small, relative to our blur, to break into nine-patch,
@@ skipping 23 matching lines @@
         }
     } else {
         if (!this->filterRectMask(&patch->fMask, smallR[0], matrix, &margin,
                                   SkMask::kComputeBoundsAndRenderImage_CreateMode)) {
             return kFalse_FilterReturn;
         }
     }
     patch->fMask.fBounds.offsetTo(0, 0);
     patch->fOuterRect = dstM.fBounds;
     patch->fCenter = center;
+    SkMaskCache::Add(sigma, count, rects, patch->fMask);
+
     return kTrue_FilterReturn;
 }
 
 void SkBlurMaskFilterImpl::computeFastBounds(const SkRect& src,
                                              SkRect* dst) const {
     SkScalar pad = 3.0f * fSigma;
 
     dst->set(src.fLeft  - pad, src.fTop    - pad,
              src.fRight + pad, src.fBottom + pad);
 }
@@ skipping 384 matching lines @@
 
         SkPath path;
         path.addRRect( smallRRect );
 
         SkDraw::DrawToMask(path, &mask.fBounds, NULL, NULL, &mask, SkMask::kJustRenderImage_CreateMode, SkPaint::kFill_Style);
 
         SkMask blurred_mask;
         SkBlurMask::BoxBlur(&blurred_mask, mask, sigma, kNormal_SkBlurStyle, kHigh_SkBlurQuality, NULL, true );
 
         blurNinePatchTexture = context->createTexture(&params, texDesc, blurRRectNinePatchID, blurred_mask.fImage, 0);
-        SkMask::FreeImage(blurred_mask.fImage);
     }
 
     SkAutoTUnref<GrTexture> blurunref(blurNinePatchTexture);
     if (NULL == blurNinePatchTexture) {
         return NULL;
     }
 
     return SkNEW_ARGS(GrRRectBlurEffect, (sigma, rrect, blurNinePatchTexture));
 }
 
@@ skipping 288 matching lines @@
     } else {
         str->append("None");
     }
     str->append("))");
 }
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkBlurMaskFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkBlurMaskFilterImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END