Refugee from Dead Machine 4: MDB Monster

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"
@@ skipping 31 matching lines @@
     SkMask::Format getFormat() const override;
     virtual bool filterMask(SkMask* dst, const SkMask& src, const SkMatrix&,
                             SkIPoint* margin) const override;
 
 #if SK_SUPPORT_GPU
     virtual bool canFilterMaskGPU(const SkRect& devBounds,
                                   const SkIRect& clipBounds,
                                   const SkMatrix& ctm,
                                   SkRect* maskRect) const override;
     virtual bool directFilterMaskGPU(GrContext* context,
+                                     GrDrawContext* drawContext,
                                      GrRenderTarget* rt,
                                      GrPaint* grp,
                                      const GrClip&,
                                      const SkMatrix& viewMatrix,
                                      const SkStrokeRec& strokeRec,
                                      const SkPath& path) const override;
     virtual bool directFilterRRectMaskGPU(GrContext* context,
                                           GrRenderTarget* rt,
                                           GrPaint* grp,
                                           const GrClip&,
@@ skipping 765 matching lines @@
                                                   GrTexture**) {
     float sigma = random->nextRangeF(3,8);
     float width = random->nextRangeF(200,300);
     float height = random->nextRangeF(200,300);
     return GrRectBlurEffect::Create(context->textureProvider(), SkRect::MakeWH(width, height),
                                     sigma);
 }
 
 
 bool SkBlurMaskFilterImpl::directFilterMaskGPU(GrContext* context,
+                                               GrDrawContext* drawContext,
                                                GrRenderTarget* rt,
                                                GrPaint* grp,
                                                const GrClip& clip,
                                                const SkMatrix& viewMatrix,
                                                const SkStrokeRec& strokeRec,
                                                const SkPath& path) const {
+    SkASSERT(drawContext);
+
     if (fBlurStyle != kNormal_SkBlurStyle) {
         return false;
     }
 
     SkRect rect;
     if (!path.isRect(&rect)) {
         return false;
     }
 
     if (!strokeRec.isFillStyle()) {
         return false;
     }
 
-    SkMatrix ctm = viewMatrix;
-    SkScalar xformedSigma = this->computeXformedSigma(ctm);
+    SkScalar xformedSigma = this->computeXformedSigma(viewMatrix);
 
-    int pad=SkScalarCeilToInt(6*xformedSigma)/2;
+    int pad = SkScalarCeilToInt(6*xformedSigma)/2;
     rect.outset(SkIntToScalar(pad), SkIntToScalar(pad));
 
     SkAutoTUnref<GrFragmentProcessor> fp(GrRectBlurEffect::Create(
         context->textureProvider(), rect, xformedSigma));
     if (!fp) {
         return false;
     }
 
     grp->addCoverageProcessor(fp);
 
     SkMatrix inverse;
     if (!viewMatrix.invert(&inverse)) {
         return false;
     }
 
-    GrDrawContext* drawContext = context->drawContext();
-    if (drawContext) {
-        drawContext->drawNonAARectWithLocalMatrix(rt, clip, *grp, SkMatrix::I(), rect, inverse);
-        return true;
-    }
-
-    return false;
+    drawContext->drawNonAARectWithLocalMatrix(rt, clip, *grp, SkMatrix::I(), rect, inverse);
+    return true;
 }
 
 class GrRRectBlurEffect : public GrFragmentProcessor {
 public:
 
     static GrFragmentProcessor* Create(GrContext* context, float sigma, const SkRRect&);
 
     virtual ~GrRRectBlurEffect() {};
     const char* name() const override { return "GrRRectBlur"; }
 
@@ skipping 399 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