Minor clean up related to blur mask filters

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 71 matching lines @@
 
     FilterReturn filterRRectToNine(const SkRRect&, const SkMatrix&,
                                    const SkIRect& clipBounds,
                                    NinePatch*) const override;
 
     bool filterRectMask(SkMask* dstM, const SkRect& r, const SkMatrix& matrix,
                         SkIPoint* margin, SkMask::CreateMode createMode) const;
     bool filterRRectMask(SkMask* dstM, const SkRRect& r, const SkMatrix& matrix,
                         SkIPoint* margin, SkMask::CreateMode createMode) const;
 
+    bool ignoreXform() const {
+        return SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag);
+    }
+
 private:
     // To avoid unseemly allocation requests (esp. for finite platforms like
     // handset) we limit the radius so something manageable. (as opposed to
     // a request like 10,000)
     static const SkScalar kMAX_BLUR_SIGMA;
 
     SkScalar    fSigma;
     SkBlurStyle fBlurStyle;
     uint32_t    fBlurFlags;
 
     SkBlurQuality getQuality() const {
         return (fBlurFlags & SkBlurMaskFilter::kHighQuality_BlurFlag) ?
                 kHigh_SkBlurQuality : kLow_SkBlurQuality;
     }
 
     SkBlurMaskFilterImpl(SkReadBuffer&);
     void flatten(SkWriteBuffer&) const override;
 
     SkScalar computeXformedSigma(const SkMatrix& ctm) const {
-        bool ignoreTransform = SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag);
-
-        SkScalar xformedSigma = ignoreTransform ? fSigma : ctm.mapRadius(fSigma);
+        SkScalar xformedSigma = this->ignoreXform() ? fSigma : ctm.mapRadius(fSigma);
         return SkMinScalar(xformedSigma, kMAX_BLUR_SIGMA);
     }
 
     friend class SkBlurMaskFilter;
 
     typedef SkMaskFilter INHERITED;
 };
 
 const SkScalar SkBlurMaskFilterImpl::kMAX_BLUR_SIGMA = SkIntToScalar(128);
 
 sk_sp<SkMaskFilter> SkBlurMaskFilter::Make(SkBlurStyle style, SkScalar sigma, uint32_t flags) {
     if (!SkScalarIsFinite(sigma) || sigma <= 0) {
         return nullptr;
     }
     if ((unsigned)style > (unsigned)kLastEnum_SkBlurStyle) {
         return nullptr;
     }
-    if (flags > SkBlurMaskFilter::kAll_BlurFlag) {
-        return nullptr;
-    }
+    SkASSERT(flags <= SkBlurMaskFilter::kAll_BlurFlag);
+    flags &= SkBlurMaskFilter::kAll_BlurFlag;
+
     return sk_sp<SkMaskFilter>(new SkBlurMaskFilterImpl(sigma, style, flags));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkScalar sigma, SkBlurStyle style, uint32_t flags)
     : fSigma(sigma)
     , fBlurStyle(style)
     , fBlurFlags(flags) {
     SkASSERT(fSigma > 0);
     SkASSERT((unsigned)style <= kLastEnum_SkBlurStyle);
     SkASSERT(flags <= SkBlurMaskFilter::kAll_BlurFlag);
 }
 
 SkMask::Format SkBlurMaskFilterImpl::getFormat() const {
     return SkMask::kA8_Format;
 }
 
 bool SkBlurMaskFilterImpl::asABlur(BlurRec* rec) const {
-    if (fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag) {
+    if (this->ignoreXform()) {
         return false;
     }
 
     if (rec) {
         rec->fSigma = fSigma;
         rec->fStyle = fBlurStyle;
         rec->fQuality = this->getQuality();
     }
     return true;
 }
@@ skipping 998 matching lines @@
 
     if (fBlurStyle != kNormal_SkBlurStyle) {
         return false;
     }
 
     if (!strokeRec.isFillStyle()) {
         return false;
     }
 
     SkScalar xformedSigma = this->computeXformedSigma(viewMatrix);
-    float extra=3.f*SkScalarCeilToScalar(xformedSigma-1/6.0f);
-
-    SkRect proxyRect = rrect.rect();
-    proxyRect.outset(extra, extra);
 
     sk_sp<GrFragmentProcessor> fp(GrRRectBlurEffect::Make(texProvider, xformedSigma, rrect));
     if (!fp) {
         return false;
     }
 
     grp->addCoverageFragmentProcessor(std::move(fp));
 
     SkMatrix inverse;
     if (!viewMatrix.invert(&inverse)) {
         return false;
     }
 
+    float extra=3.f*SkScalarCeilToScalar(xformedSigma-1/6.0f);
+
+    SkRect proxyRect = rrect.rect();
+    proxyRect.outset(extra, extra);
+
     drawContext->fillRectWithLocalMatrix(clip, *grp, SkMatrix::I(), proxyRect, inverse);
     return true;
 }
 
 bool SkBlurMaskFilterImpl::canFilterMaskGPU(const SkRRect& devRRect,
                                             const SkIRect& clipBounds,
                                             const SkMatrix& ctm,
                                             SkRect* maskRect) const {
     SkScalar xformedSigma = this->computeXformedSigma(ctm);
     if (xformedSigma <= 0) {
@@ skipping 111 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