sk_sp for gpu.

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 589 matching lines @@
 #if SK_SUPPORT_GPU
 
 class GrGLRectBlurEffect;
 
 class GrRectBlurEffect : public GrFragmentProcessor {
 public:
     ~GrRectBlurEffect() override { }
 
     const char* name() const override { return "RectBlur"; }
 
-    static GrFragmentProcessor* Create(GrTextureProvider *textureProvider,
-                                       const SkRect& rect, float sigma) {
+    static sk_sp<GrFragmentProcessor> Make(GrTextureProvider *textureProvider,
+                                           const SkRect& rect, float sigma) {
         int doubleProfileSize = SkScalarCeilToInt(12*sigma);
 
         if (doubleProfileSize >= rect.width() || doubleProfileSize >= rect.height()) {
             // if the blur sigma is too large so the gaussian overlaps the whole
             // rect in either direction, fall back to CPU path for now.
             return nullptr;
         }
 
         SkAutoTUnref<GrTexture> blurProfile(CreateBlurProfileTexture(textureProvider, sigma));
         if (!blurProfile) {
            return nullptr;
         }
         // in OpenGL ES, mediump floats have a minimum range of 2^14. If we have coordinates bigger
         // than that, the shader math will end up with infinities and result in the blur effect not
         // working correctly. To avoid this, we switch into highp when the coordinates are too big.
         // As 2^14 is the minimum range but the actual range can be bigger, we might end up
         // switching to highp sooner than strictly necessary, but most devices that have a bigger
         // range for mediump also have mediump being exactly the same as highp (e.g. all non-OpenGL
         // ES devices), and thus incur no additional penalty for the switch.
         static const SkScalar kMAX_BLUR_COORD = SkIntToScalar(16000);
         GrSLPrecision precision;
         if (SkScalarAbs(rect.top()) > kMAX_BLUR_COORD ||
             SkScalarAbs(rect.left()) > kMAX_BLUR_COORD ||
             SkScalarAbs(rect.bottom()) > kMAX_BLUR_COORD ||
             SkScalarAbs(rect.right()) > kMAX_BLUR_COORD ||
             SkScalarAbs(rect.width()) > kMAX_BLUR_COORD ||
             SkScalarAbs(rect.height()) > kMAX_BLUR_COORD) {
             precision = kHigh_GrSLPrecision;
-        }
-        else {
+        } else {
             precision = kDefault_GrSLPrecision;
         }
-        return new GrRectBlurEffect(rect, sigma, blurProfile, precision);
+        return sk_sp<GrFragmentProcessor>(
+            new GrRectBlurEffect(rect, sigma, blurProfile, precision));
     }
 
     const SkRect& getRect() const { return fRect; }
     float getSigma() const { return fSigma; }
     GrSLPrecision precision() const { return fPrecision; }
 
 private:
     GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blurProfile,
                      GrSLPrecision fPrecision);
 
@@ skipping 179 matching lines @@
     const GrRectBlurEffect& s = sBase.cast<GrRectBlurEffect>();
     return this->getSigma() == s.getSigma() && this->getRect() == s.getRect();
 }
 
 void GrRectBlurEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     inout->mulByUnknownSingleComponent();
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRectBlurEffect);
 
-const GrFragmentProcessor* GrRectBlurEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> GrRectBlurEffect::TestCreate(GrProcessorTestData* d) {
     float sigma = d->fRandom->nextRangeF(3,8);
     float width = d->fRandom->nextRangeF(200,300);
     float height = d->fRandom->nextRangeF(200,300);
-    return GrRectBlurEffect::Create(d->fContext->textureProvider(), SkRect::MakeWH(width, height),
-                                    sigma);
+    return GrRectBlurEffect::Make(d->fContext->textureProvider(), SkRect::MakeWH(width, height),
+                                  sigma);
 }
 
 
 bool SkBlurMaskFilterImpl::directFilterMaskGPU(GrTextureProvider* texProvider,
                                                GrDrawContext* drawContext,
                                                GrPaint* grp,
                                                const GrClip& clip,
                                                const SkMatrix& viewMatrix,
                                                const SkStrokeRec& strokeRec,
                                                const SkPath& path) const {
     SkASSERT(drawContext);
 
     if (fBlurStyle != kNormal_SkBlurStyle) {
         return false;
     }
 
     // TODO: we could handle blurred stroked circles
     if (!strokeRec.isFillStyle()) {
         return false;
     }
 
     SkScalar xformedSigma = this->computeXformedSigma(viewMatrix);
 
-    SkAutoTUnref<const GrFragmentProcessor> fp;
+    sk_sp<GrFragmentProcessor> fp;
 
     SkRect rect;
     if (path.isRect(&rect)) {
         int pad = SkScalarCeilToInt(6*xformedSigma)/2;
         rect.outset(SkIntToScalar(pad), SkIntToScalar(pad));
 
-        fp.reset(GrRectBlurEffect::Create(texProvider, rect, xformedSigma));
+        fp = GrRectBlurEffect::Make(texProvider, rect, xformedSigma);
     } else if (path.isOval(&rect) && SkScalarNearlyEqual(rect.width(), rect.height())) {
-        fp.reset(GrCircleBlurFragmentProcessor::Create(texProvider, rect, xformedSigma));
+        fp = GrCircleBlurFragmentProcessor::Make(texProvider, rect, xformedSigma);
 
         // expand the rect for the coverage geometry
         int pad = SkScalarCeilToInt(6*xformedSigma)/2;
         rect.outset(SkIntToScalar(pad), SkIntToScalar(pad));
     } else {
         return false;
     }
 
     if (!fp) {
         return false;
     }
 
-    grp->addCoverageFragmentProcessor(fp);
+    grp->addCoverageFragmentProcessor(std::move(fp));
 
     SkMatrix inverse;
     if (!viewMatrix.invert(&inverse)) {
         return false;
     }
 
     drawContext->fillRectWithLocalMatrix(clip, *grp, SkMatrix::I(), rect, inverse);
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GrRRectBlurEffect : public GrFragmentProcessor {
 public:
 
-    static const GrFragmentProcessor* Create(GrTextureProvider*, float sigma, const SkRRect&);
+    static sk_sp<GrFragmentProcessor> Make(GrTextureProvider*, float sigma, const SkRRect&);
 
     virtual ~GrRRectBlurEffect() {};
     const char* name() const override { return "GrRRectBlur"; }
 
     const SkRRect& getRRect() const { return fRRect; }
     float getSigma() const { return fSigma; }
 
 private:
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
 
     GrRRectBlurEffect(float sigma, const SkRRect&, GrTexture* profileTexture);
 
     virtual void onGetGLSLProcessorKey(const GrGLSLCaps& caps,
                                        GrProcessorKeyBuilder* b) const override;
 
     bool onIsEqual(const GrFragmentProcessor& other) const override;
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
 
     SkRRect             fRRect;
     float               fSigma;
     GrTextureAccess     fNinePatchAccess;
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 
-const GrFragmentProcessor* GrRRectBlurEffect::Create(GrTextureProvider* texProvider, float sigma,
+sk_sp<GrFragmentProcessor> GrRRectBlurEffect::Make(GrTextureProvider* texProvider, float sigma,
                                                      const SkRRect& rrect) {
     if (rrect.isCircle()) {
-        return GrCircleBlurFragmentProcessor::Create(texProvider, rrect.rect(), sigma);
+        return GrCircleBlurFragmentProcessor::Make(texProvider, rrect.rect(), sigma);
     }
 
     if (!rrect.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.
 
@@ skipping 52 matching lines @@
         texDesc.fIsMipMapped = false;
 
         blurNinePatchTexture.reset(
             texProvider->createTexture(texDesc, SkBudgeted::kYes , blurredMask.fImage, 0));
         SkMask::FreeImage(blurredMask.fImage);
         if (!blurNinePatchTexture) {
             return nullptr;
         }
         texProvider->assignUniqueKeyToTexture(key, blurNinePatchTexture);
     }
-    return new GrRRectBlurEffect(sigma, rrect, blurNinePatchTexture);
+    return sk_sp<GrFragmentProcessor>(new GrRRectBlurEffect(sigma, rrect, blurNinePatchTexture));
 }
 
 void GrRRectBlurEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     inout->mulByUnknownSingleComponent();
 }
 
 GrRRectBlurEffect::GrRRectBlurEffect(float sigma, const SkRRect& rrect, GrTexture *ninePatchTexture)
     : fRRect(rrect),
       fSigma(sigma),
       fNinePatchAccess(ninePatchTexture) {
     this->initClassID<GrRRectBlurEffect>();
     this->addTextureAccess(&fNinePatchAccess);
     this->setWillReadFragmentPosition();
 }
 
 bool GrRRectBlurEffect::onIsEqual(const GrFragmentProcessor& other) const {
     const GrRRectBlurEffect& rrbe = other.cast<GrRRectBlurEffect>();
     return fRRect.getSimpleRadii().fX == rrbe.fRRect.getSimpleRadii().fX &&
            fSigma == rrbe.fSigma &&
            fRRect.rect() == rrbe.fRRect.rect();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRRectBlurEffect);
 
-const GrFragmentProcessor* GrRRectBlurEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> GrRRectBlurEffect::TestCreate(GrProcessorTestData* d) {
     SkScalar w = d->fRandom->nextRangeScalar(100.f, 1000.f);
     SkScalar h = d->fRandom->nextRangeScalar(100.f, 1000.f);
     SkScalar r = d->fRandom->nextRangeF(1.f, 9.f);
     SkScalar sigma = d->fRandom->nextRangeF(1.f,10.f);
     SkRRect rrect;
     rrect.setRectXY(SkRect::MakeWH(w, h), r, r);
-    return GrRRectBlurEffect::Create(d->fContext->textureProvider(), sigma, rrect);
+    return GrRRectBlurEffect::Make(d->fContext->textureProvider(), sigma, rrect);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GrGLRRectBlurEffect : public GrGLSLFragmentProcessor {
 public:
     void emitCode(EmitArgs&) override;
 
 protected:
     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
@@ skipping 105 matching lines @@
     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);
 
-    SkAutoTUnref<const GrFragmentProcessor> fp(GrRRectBlurEffect::Create(texProvider,
-                                                                         xformedSigma, rrect));
+    sk_sp<GrFragmentProcessor> fp(GrRRectBlurEffect::Make(texProvider, xformedSigma, rrect));
     if (!fp) {
         return false;
     }
 
-    grp->addCoverageFragmentProcessor(fp);
+    grp->addCoverageFragmentProcessor(std::move(fp));
 
     SkMatrix inverse;
     if (!viewMatrix.invert(&inverse)) {
         return false;
     }
 
     drawContext->fillRectWithLocalMatrix(clip, *grp, SkMatrix::I(), proxyRect, inverse);
     return true;
 }
 
@@ skipping 61 matching lines @@
                                                                   xformedSigma, xformedSigma));
     if (!drawContext) {
         return false;
     }
 
     if (!isNormalBlur) {
         GrPaint paint;
         SkMatrix matrix;
         matrix.setIDiv(src->width(), src->height());
         // Blend pathTexture over blurTexture.
-        paint.addCoverageFragmentProcessor(GrSimpleTextureEffect::Create(src, matrix))->unref();
+        paint.addCoverageFragmentProcessor(GrSimpleTextureEffect::Make(src, matrix));
         if (kInner_SkBlurStyle == fBlurStyle) {
             // inner:  dst = dst * src
             paint.setCoverageSetOpXPFactory(SkRegion::kIntersect_Op);
         } else if (kSolid_SkBlurStyle == fBlurStyle) {
             // solid:  dst = src + dst - src * dst
             //             = src + (1 - src) * dst
             paint.setCoverageSetOpXPFactory(SkRegion::kUnion_Op);
         } else if (kOuter_SkBlurStyle == fBlurStyle) {
             // outer:  dst = dst * (1 - src)
             //             = 0 * src + (1 - src) * dst
@@ skipping 37 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