Pull handling of blurred circles out of GrRRectBlurEffect::Make

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"
@@ skipping 1035 matching lines @@
                                                                           size.fHeight),
                                                           nullptr,
                                                           sigma, sigma, SkBackingFit::kExact));
     if (!dc2) {
         return nullptr;
     }
 
     return dc2->asTexture();
 }
 
-sk_sp<GrFragmentProcessor> GrRRectBlurEffect::Make(GrContext* context, float sigma,
-                                                   const SkRRect& rrect) {
-    if (rrect.isCircle()) {
-        return GrCircleBlurFragmentProcessor::Make(context->textureProvider(),
-                                                   rrect.rect(), sigma);
-    }
+sk_sp<GrFragmentProcessor> GrRRectBlurEffect::Make(GrContext* context,
+                                                   float xformedSigma,
+                                                   const SkRRect& devRRect) {
+    SkASSERT(!devRRect.isCircle()); // Should've been caught up-stream
 
     // TODO: loosen this up
-    if (!rrect.isSimpleCircular()) {
+    if (!devRRect.isSimpleCircular()) {
         return nullptr;
     }
 
     // Make sure we can successfully ninepatch this rrect -- the blur sigma has to be
     // sufficiently small relative to both the size of the corner radius and the
     // width (and height) of the rrect.
 
-    unsigned int blurRadius = 3*SkScalarCeilToInt(sigma-1/6.0f);
-    unsigned int cornerRadius = SkScalarCeilToInt(rrect.getSimpleRadii().x());
-    if (cornerRadius + blurRadius > rrect.width()/2 ||
-        cornerRadius + blurRadius > rrect.height()/2) {
+    unsigned int blurRadius = 3*SkScalarCeilToInt(xformedSigma-1/6.0f);
+    unsigned int cornerRadius = SkScalarCeilToInt(devRRect.getSimpleRadii().x());
+    if (cornerRadius + blurRadius > devRRect.width()/2 ||
+        cornerRadius + blurRadius > devRRect.height()/2) {
         return nullptr;
     }
 
     static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey key;
     GrUniqueKey::Builder builder(&key, kDomain, 2);
     builder[0] = blurRadius;
     builder[1] = cornerRadius;
     builder.finish();
 
     sk_sp<GrTexture> blurNinePatchTexture(
                                 context->textureProvider()->findAndRefTextureByUniqueKey(key));
 
     if (!blurNinePatchTexture) {
-        blurNinePatchTexture = make_rrect_blur_mask(context, rrect, sigma, true);
+        blurNinePatchTexture = make_rrect_blur_mask(context, devRRect, xformedSigma, true);
         if (!blurNinePatchTexture) {
             return nullptr;
         }
         context->textureProvider()->assignUniqueKeyToTexture(key, blurNinePatchTexture.get());
     }
-    return sk_sp<GrFragmentProcessor>(new GrRRectBlurEffect(sigma, rrect, blurNinePatchTexture.get()));
+    return sk_sp<GrFragmentProcessor>(new GrRRectBlurEffect(xformedSigma, devRRect,
+                                                            blurNinePatchTexture.get()));
 }
 
 void GrRRectBlurEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     inout->mulByUnknownSingleComponent();
 }
 
 GrRRectBlurEffect::GrRRectBlurEffect(float sigma, const SkRRect& rrect, GrTexture *ninePatchTexture)
     : fRRect(rrect),
       fSigma(sigma),
       fNinePatchAccess(ninePatchTexture) {
@@ skipping 136 matching lines @@
     if (fBlurStyle != kNormal_SkBlurStyle) {
         return false;
     }
 
     if (!strokeRec.isFillStyle()) {
         return false;
     }
 
     SkScalar xformedSigma = this->computeXformedSigma(viewMatrix);
 
+    if (devRRect.isCircle()) {
+        sk_sp<GrFragmentProcessor> fp(GrCircleBlurFragmentProcessor::Make(
+                                                                        context->textureProvider(),
+                                                                        devRRect.rect(),
+                                                                        xformedSigma));
+        if (!fp) {
+            return false;
+        }
+
+        GrPaint newPaint(*grp);
+        newPaint.addCoverageFragmentProcessor(std::move(fp));
+        newPaint.setAntiAlias(false);
+
+        SkRect srcProxyRect = srcRRect.rect();
+        srcProxyRect.outset(3.0f*fSigma, 3.0f*fSigma);
+
+        drawContext->drawRect(clip, newPaint, viewMatrix, srcProxyRect);
+        return true;
+    }
+
     sk_sp<GrFragmentProcessor> fp(GrRRectBlurEffect::Make(context, xformedSigma, devRRect));
     if (!fp) {
         return false;
     }
 
     GrPaint newPaint(*grp);
     newPaint.addCoverageFragmentProcessor(std::move(fp));
     newPaint.setAntiAlias(false);
 
     if (!this->ignoreXform()) {
@@ skipping 165 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