diff --git a/src/gpu/effects/GrBezierEffect.cpp b/src/gpu/effects/GrBezierEffect.cpp
index 075ce16..9d3e8ee 100644
--- a/src/gpu/effects/GrBezierEffect.cpp
+++ b/src/gpu/effects/GrBezierEffect.cpp
@@ -272,15 +272,15 @@
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrConicEffect);
 
-const GrGeometryProcessor* GrConicEffect::TestCreate(GrProcessorTestData* d) {
-    GrGeometryProcessor* gp;
+sk_sp<GrGeometryProcessor> GrConicEffect::TestCreate(GrProcessorTestData* d) {
+    sk_sp<GrGeometryProcessor> gp;
     do {
         GrPrimitiveEdgeType edgeType =
                 static_cast<GrPrimitiveEdgeType>(
                         d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt));
-        gp = GrConicEffect::Create(GrRandomColor(d->fRandom), GrTest::TestMatrix(d->fRandom),
-                                   edgeType, *d->fCaps,
-                                   GrTest::TestMatrix(d->fRandom), d->fRandom->nextBool());
+        gp = GrConicEffect::Make(GrRandomColor(d->fRandom), GrTest::TestMatrix(d->fRandom),
+                                 edgeType, *d->fCaps,
+                                 GrTest::TestMatrix(d->fRandom), d->fRandom->nextBool());
     } while (nullptr == gp);
     return gp;
 }
@@ -488,16 +488,16 @@
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrQuadEffect);
 
-const GrGeometryProcessor* GrQuadEffect::TestCreate(GrProcessorTestData* d) {
-    GrGeometryProcessor* gp;
+sk_sp<GrGeometryProcessor> GrQuadEffect::TestCreate(GrProcessorTestData* d) {
+    sk_sp<GrGeometryProcessor> gp;
     do {
         GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>(
                 d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt));
-        gp = GrQuadEffect::Create(GrRandomColor(d->fRandom),
-                                  GrTest::TestMatrix(d->fRandom),
-                                  edgeType, *d->fCaps,
-                                  GrTest::TestMatrix(d->fRandom),
-                                  d->fRandom->nextBool());
+        gp = GrQuadEffect::Make(GrRandomColor(d->fRandom),
+                                GrTest::TestMatrix(d->fRandom),
+                                edgeType, *d->fCaps,
+                                GrTest::TestMatrix(d->fRandom),
+                                d->fRandom->nextBool());
     } while (nullptr == gp);
     return gp;
 }
@@ -716,14 +716,14 @@
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrCubicEffect);
 
-const GrGeometryProcessor* GrCubicEffect::TestCreate(GrProcessorTestData* d) {
-    GrGeometryProcessor* gp;
+sk_sp<GrGeometryProcessor> GrCubicEffect::TestCreate(GrProcessorTestData* d) {
+    sk_sp<GrGeometryProcessor> gp;
     do {
         GrPrimitiveEdgeType edgeType =
                 static_cast<GrPrimitiveEdgeType>(
                         d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt));
-        gp = GrCubicEffect::Create(GrRandomColor(d->fRandom),
-                                   GrTest::TestMatrix(d->fRandom), edgeType, *d->fCaps);
+        gp = GrCubicEffect::Make(GrRandomColor(d->fRandom),
+                                 GrTest::TestMatrix(d->fRandom), edgeType, *d->fCaps);
     } while (nullptr == gp);
     return gp;
 }
diff --git a/src/gpu/effects/GrBezierEffect.h b/src/gpu/effects/GrBezierEffect.h
index ddb249b..50dca99 100644
--- a/src/gpu/effects/GrBezierEffect.h
+++ b/src/gpu/effects/GrBezierEffect.h
@@ -58,30 +58,33 @@
 
 class GrConicEffect : public GrGeometryProcessor {
 public:
-    static GrGeometryProcessor* Create(GrColor color,
-                                       const SkMatrix& viewMatrix,
-                                       const GrPrimitiveEdgeType edgeType,
-                                       const GrCaps& caps,
-                                       const SkMatrix& localMatrix,
-                                       bool usesLocalCoords,
-                                       uint8_t coverage = 0xff) {
+    static sk_sp<GrGeometryProcessor> Make(GrColor color,
+                                           const SkMatrix& viewMatrix,
+                                           const GrPrimitiveEdgeType edgeType,
+                                           const GrCaps& caps,
+                                           const SkMatrix& localMatrix,
+                                           bool usesLocalCoords,
+                                           uint8_t coverage = 0xff) {
         switch (edgeType) {
             case kFillAA_GrProcessorEdgeType:
                 if (!caps.shaderCaps()->shaderDerivativeSupport()) {
                     return nullptr;
                 }
-                return new GrConicEffect(color, viewMatrix, coverage, kFillAA_GrProcessorEdgeType,
-                                         localMatrix, usesLocalCoords);
+                return sk_sp<GrGeometryProcessor>(
+                    new GrConicEffect(color, viewMatrix, coverage, kFillAA_GrProcessorEdgeType,
+                                      localMatrix, usesLocalCoords));
             case kHairlineAA_GrProcessorEdgeType:
                 if (!caps.shaderCaps()->shaderDerivativeSupport()) {
                     return nullptr;
                 }
-                return new GrConicEffect(color, viewMatrix, coverage,
-                                         kHairlineAA_GrProcessorEdgeType, localMatrix,
-                                         usesLocalCoords);
+                return sk_sp<GrGeometryProcessor>(
+                    new GrConicEffect(color, viewMatrix, coverage,
+                                      kHairlineAA_GrProcessorEdgeType, localMatrix,
+                                      usesLocalCoords));
             case kFillBW_GrProcessorEdgeType:
-                return new GrConicEffect(color, viewMatrix, coverage, kFillBW_GrProcessorEdgeType,
-                                         localMatrix, usesLocalCoords);
+                return sk_sp<GrGeometryProcessor>(
+                    new GrConicEffect(color, viewMatrix, coverage, kFillBW_GrProcessorEdgeType,
+                                      localMatrix, usesLocalCoords));
             default:
                 return nullptr;
         }
@@ -138,30 +141,33 @@
 
 class GrQuadEffect : public GrGeometryProcessor {
 public:
-    static GrGeometryProcessor* Create(GrColor color,
-                                       const SkMatrix& viewMatrix,
-                                       const GrPrimitiveEdgeType edgeType,
-                                       const GrCaps& caps,
-                                       const SkMatrix& localMatrix,
-                                       bool usesLocalCoords,
-                                       uint8_t coverage = 0xff) {
+    static sk_sp<GrGeometryProcessor> Make(GrColor color,
+                                           const SkMatrix& viewMatrix,
+                                           const GrPrimitiveEdgeType edgeType,
+                                           const GrCaps& caps,
+                                           const SkMatrix& localMatrix,
+                                           bool usesLocalCoords,
+                                           uint8_t coverage = 0xff) {
         switch (edgeType) {
             case kFillAA_GrProcessorEdgeType:
                 if (!caps.shaderCaps()->shaderDerivativeSupport()) {
                     return nullptr;
                 }
-                return new GrQuadEffect(color, viewMatrix, coverage, kFillAA_GrProcessorEdgeType,
-                                        localMatrix, usesLocalCoords);
+                return sk_sp<GrGeometryProcessor>(
+                    new GrQuadEffect(color, viewMatrix, coverage, kFillAA_GrProcessorEdgeType,
+                                     localMatrix, usesLocalCoords));
             case kHairlineAA_GrProcessorEdgeType:
                 if (!caps.shaderCaps()->shaderDerivativeSupport()) {
                     return nullptr;
                 }
-                return new GrQuadEffect(color, viewMatrix, coverage,
-                                        kHairlineAA_GrProcessorEdgeType, localMatrix,
-                                        usesLocalCoords);
+                return sk_sp<GrGeometryProcessor>(
+                    new GrQuadEffect(color, viewMatrix, coverage,
+                                     kHairlineAA_GrProcessorEdgeType, localMatrix,
+                                     usesLocalCoords));
             case kFillBW_GrProcessorEdgeType:
-                return new GrQuadEffect(color, viewMatrix, coverage, kFillBW_GrProcessorEdgeType,
-                                        localMatrix, usesLocalCoords);
+                return sk_sp<GrGeometryProcessor>(
+                    new GrQuadEffect(color, viewMatrix, coverage, kFillBW_GrProcessorEdgeType,
+                                     localMatrix, usesLocalCoords));
             default:
                 return nullptr;
         }
@@ -220,23 +226,26 @@
 
 class GrCubicEffect : public GrGeometryProcessor {
 public:
-    static GrGeometryProcessor* Create(GrColor color,
-                                       const SkMatrix& viewMatrix,
-                                       const GrPrimitiveEdgeType edgeType,
-                                       const GrCaps& caps) {
+    static sk_sp<GrGeometryProcessor> Make(GrColor color,
+                                           const SkMatrix& viewMatrix,
+                                           const GrPrimitiveEdgeType edgeType,
+                                           const GrCaps& caps) {
         switch (edgeType) {
             case kFillAA_GrProcessorEdgeType:
                 if (!caps.shaderCaps()->shaderDerivativeSupport()) {
                     return nullptr;
                 }
-                return new GrCubicEffect(color, viewMatrix, kFillAA_GrProcessorEdgeType);
+                return sk_sp<GrGeometryProcessor>(
+                    new GrCubicEffect(color, viewMatrix, kFillAA_GrProcessorEdgeType));
             case kHairlineAA_GrProcessorEdgeType:
                 if (!caps.shaderCaps()->shaderDerivativeSupport()) {
                     return nullptr;
                 }
-                return new GrCubicEffect(color, viewMatrix, kHairlineAA_GrProcessorEdgeType);
+                return sk_sp<GrGeometryProcessor>(
+                    new GrCubicEffect(color, viewMatrix, kHairlineAA_GrProcessorEdgeType));
             case kFillBW_GrProcessorEdgeType:
-                return new GrCubicEffect(color, viewMatrix, kFillBW_GrProcessorEdgeType);
+                return sk_sp<GrGeometryProcessor>(
+                    new GrCubicEffect(color, viewMatrix, kFillBW_GrProcessorEdgeType));
             default:
                 return nullptr;
         }
diff --git a/src/gpu/effects/GrBicubicEffect.cpp b/src/gpu/effects/GrBicubicEffect.cpp
index 0a06b62..5e6967c 100644
--- a/src/gpu/effects/GrBicubicEffect.cpp
+++ b/src/gpu/effects/GrBicubicEffect.cpp
@@ -179,14 +179,14 @@
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrBicubicEffect);
 
-const GrFragmentProcessor* GrBicubicEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> GrBicubicEffect::TestCreate(GrProcessorTestData* d) {
     int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
                                           GrProcessorUnitTest::kAlphaTextureIdx;
     SkScalar coefficients[16];
     for (int i = 0; i < 16; i++) {
         coefficients[i] = d->fRandom->nextSScalar1();
     }
-    return GrBicubicEffect::Create(d->fTextures[texIdx], coefficients);
+    return GrBicubicEffect::Make(d->fTextures[texIdx], coefficients);
 }
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/src/gpu/effects/GrBicubicEffect.h b/src/gpu/effects/GrBicubicEffect.h
index 2087192..3c84f97 100644
--- a/src/gpu/effects/GrBicubicEffect.h
+++ b/src/gpu/effects/GrBicubicEffect.h
@@ -32,43 +32,46 @@
     /**
      * Create a simple filter effect with custom bicubic coefficients and optional domain.
      */
-    static const GrFragmentProcessor* Create(GrTexture* tex, const SkScalar coefficients[16],
-                                             const SkRect* domain = nullptr) {
+    static sk_sp<GrFragmentProcessor> Make(GrTexture* tex, const SkScalar coefficients[16],
+                                           const SkRect* domain = nullptr) {
         if (nullptr == domain) {
             static const SkShader::TileMode kTileModes[] = { SkShader::kClamp_TileMode,
                                                              SkShader::kClamp_TileMode };
-            return Create(tex, coefficients, GrCoordTransform::MakeDivByTextureWHMatrix(tex),
-                          kTileModes);
+            return Make(tex, coefficients, GrCoordTransform::MakeDivByTextureWHMatrix(tex),
+                        kTileModes);
         } else {
-            return new GrBicubicEffect(tex, coefficients,
-                                       GrCoordTransform::MakeDivByTextureWHMatrix(tex), *domain);
+            return sk_sp<GrFragmentProcessor>(
+                new GrBicubicEffect(tex, coefficients,
+                                    GrCoordTransform::MakeDivByTextureWHMatrix(tex), *domain));
         }
     }
 
     /**
      * Create a Mitchell filter effect with specified texture matrix and x/y tile modes.
      */
-    static const GrFragmentProcessor* Create(GrTexture* tex, const SkMatrix& matrix,
-                                             const SkShader::TileMode tileModes[2]) {
-        return Create(tex, gMitchellCoefficients, matrix, tileModes);
+    static sk_sp<GrFragmentProcessor> Make(GrTexture* tex, const SkMatrix& matrix,
+                                           const SkShader::TileMode tileModes[2]) {
+        return Make(tex, gMitchellCoefficients, matrix, tileModes);
     }
 
     /**
      * Create a filter effect with custom bicubic coefficients, the texture matrix, and the x/y
      * tilemodes.
      */
-    static const GrFragmentProcessor* Create(GrTexture* tex, const SkScalar coefficients[16],
-                                             const SkMatrix& matrix,
-                                             const SkShader::TileMode tileModes[2]) {
-        return new GrBicubicEffect(tex, coefficients, matrix, tileModes);
+    static sk_sp<GrFragmentProcessor> Make(GrTexture* tex, const SkScalar coefficients[16],
+                                           const SkMatrix& matrix,
+                                           const SkShader::TileMode tileModes[2]) {
+        return sk_sp<GrFragmentProcessor>(new GrBicubicEffect(tex, coefficients, matrix,
+                                                              tileModes));
     }
 
     /**
      * Create a Mitchell filter effect with a texture matrix and a domain.
      */
-    static const GrFragmentProcessor* Create(GrTexture* tex, const SkMatrix& matrix,
-                                             const SkRect& domain) {
-        return new GrBicubicEffect(tex, gMitchellCoefficients, matrix, domain);
+    static sk_sp<GrFragmentProcessor> Make(GrTexture* tex, const SkMatrix& matrix,
+                                           const SkRect& domain) {
+        return sk_sp<GrFragmentProcessor>(new GrBicubicEffect(tex, gMitchellCoefficients, matrix,
+                                                              domain));
     }
 
     /**
diff --git a/src/gpu/effects/GrBitmapTextGeoProc.cpp b/src/gpu/effects/GrBitmapTextGeoProc.cpp
index 246d7be..633a880 100644
--- a/src/gpu/effects/GrBitmapTextGeoProc.cpp
+++ b/src/gpu/effects/GrBitmapTextGeoProc.cpp
@@ -164,7 +164,7 @@
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrBitmapTextGeoProc);
 
-const GrGeometryProcessor* GrBitmapTextGeoProc::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrGeometryProcessor> GrBitmapTextGeoProc::TestCreate(GrProcessorTestData* d) {
     int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
                                           GrProcessorUnitTest::kAlphaTextureIdx;
     static const SkShader::TileMode kTileModes[] = {
@@ -177,7 +177,7 @@
         kTileModes[d->fRandom->nextULessThan(SK_ARRAY_COUNT(kTileModes))],
     };
     GrTextureParams params(tileModes, d->fRandom->nextBool() ? GrTextureParams::kBilerp_FilterMode :
-                                                           GrTextureParams::kNone_FilterMode);
+                                                               GrTextureParams::kNone_FilterMode);
 
     GrMaskFormat format = kARGB_GrMaskFormat; // init to avoid warning
     switch (d->fRandom->nextULessThan(3)) {
@@ -192,7 +192,7 @@
             break;
     }
 
-    return GrBitmapTextGeoProc::Create(GrRandomColor(d->fRandom), d->fTextures[texIdx], params,
-                                       format, GrTest::TestMatrix(d->fRandom),
-                                       d->fRandom->nextBool());
+    return GrBitmapTextGeoProc::Make(GrRandomColor(d->fRandom), d->fTextures[texIdx], params,
+                                     format, GrTest::TestMatrix(d->fRandom),
+                                     d->fRandom->nextBool());
 }
diff --git a/src/gpu/effects/GrBitmapTextGeoProc.h b/src/gpu/effects/GrBitmapTextGeoProc.h
index 5501d93..226ae77 100644
--- a/src/gpu/effects/GrBitmapTextGeoProc.h
+++ b/src/gpu/effects/GrBitmapTextGeoProc.h
@@ -21,10 +21,11 @@
  */
 class GrBitmapTextGeoProc : public GrGeometryProcessor {
 public:
-    static GrGeometryProcessor* Create(GrColor color, GrTexture* tex, const GrTextureParams& p,
+    static sk_sp<GrGeometryProcessor> Make(GrColor color, GrTexture* tex, const GrTextureParams& p,
                                        GrMaskFormat format, const SkMatrix& localMatrix,
                                        bool usesLocalCoords) {
-        return new GrBitmapTextGeoProc(color, tex, p, format, localMatrix, usesLocalCoords);
+        return sk_sp<GrGeometryProcessor>(
+            new GrBitmapTextGeoProc(color, tex, p, format, localMatrix, usesLocalCoords));
     }
 
     virtual ~GrBitmapTextGeoProc() {}
diff --git a/src/gpu/effects/GrConfigConversionEffect.cpp b/src/gpu/effects/GrConfigConversionEffect.cpp
index 9791cb4..d2fde96 100644
--- a/src/gpu/effects/GrConfigConversionEffect.cpp
+++ b/src/gpu/effects/GrConfigConversionEffect.cpp
@@ -125,14 +125,15 @@
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConfigConversionEffect);
 
-const GrFragmentProcessor* GrConfigConversionEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> GrConfigConversionEffect::TestCreate(GrProcessorTestData* d) {
     PMConversion pmConv = static_cast<PMConversion>(d->fRandom->nextULessThan(kPMConversionCnt));
     GrSwizzle swizzle;
     do {
         swizzle = GrSwizzle::CreateRandom(d->fRandom);
     } while (pmConv == kNone_PMConversion && swizzle == GrSwizzle::RGBA());
-    return new GrConfigConversionEffect(d->fTextures[GrProcessorUnitTest::kSkiaPMTextureIdx],
-                                        swizzle, pmConv, GrTest::TestMatrix(d->fRandom));
+    return sk_sp<GrFragmentProcessor>(
+        new GrConfigConversionEffect(d->fTextures[GrProcessorUnitTest::kSkiaPMTextureIdx],
+                                     swizzle, pmConv, GrTest::TestMatrix(d->fRandom)));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -214,17 +215,16 @@
         GrPaint paint1;
         GrPaint paint2;
         GrPaint paint3;
-        SkAutoTUnref<GrFragmentProcessor> pmToUPM1(new GrConfigConversionEffect(
+        sk_sp<GrFragmentProcessor> pmToUPM1(new GrConfigConversionEffect(
                 dataTex, GrSwizzle::RGBA(), *pmToUPMRule, SkMatrix::I()));
-        SkAutoTUnref<GrFragmentProcessor> upmToPM(new GrConfigConversionEffect(
+        sk_sp<GrFragmentProcessor> upmToPM(new GrConfigConversionEffect(
                 readTex, GrSwizzle::RGBA(), *upmToPMRule, SkMatrix::I()));
-        SkAutoTUnref<GrFragmentProcessor> pmToUPM2(new GrConfigConversionEffect(
+        sk_sp<GrFragmentProcessor> pmToUPM2(new GrConfigConversionEffect(
                 tempTex, GrSwizzle::RGBA(), *pmToUPMRule, SkMatrix::I()));
 
-        paint1.addColorFragmentProcessor(pmToUPM1);
+        paint1.addColorFragmentProcessor(std::move(pmToUPM1));
         paint1.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
 
-
         sk_sp<GrDrawContext> readDrawContext(
                                     context->drawContext(sk_ref_sp(readTex->asRenderTarget())));
         if (!readDrawContext) {
@@ -240,7 +240,7 @@
 
         readTex->readPixels(0, 0, 256, 256, kRGBA_8888_GrPixelConfig, firstRead);
 
-        paint2.addColorFragmentProcessor(upmToPM);
+        paint2.addColorFragmentProcessor(std::move(upmToPM));
         paint2.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
 
         sk_sp<GrDrawContext> tempDrawContext(
@@ -255,7 +255,7 @@
                                         kDstRect,
                                         kSrcRect);
 
-        paint3.addColorFragmentProcessor(pmToUPM2);
+        paint3.addColorFragmentProcessor(std::move(pmToUPM2));
         paint3.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
 
         readDrawContext = context->drawContext(sk_ref_sp(readTex->asRenderTarget()));
@@ -288,15 +288,15 @@
     }
 }
 
-const GrFragmentProcessor* GrConfigConversionEffect::Create(GrTexture* texture,
-                                                            const GrSwizzle& swizzle,
-                                                            PMConversion pmConversion,
-                                                            const SkMatrix& matrix) {
+sk_sp<GrFragmentProcessor> GrConfigConversionEffect::Make(GrTexture* texture,
+                                                          const GrSwizzle& swizzle,
+                                                          PMConversion pmConversion,
+                                                          const SkMatrix& matrix) {
     if (swizzle == GrSwizzle::RGBA() && kNone_PMConversion == pmConversion) {
         // If we returned a GrConfigConversionEffect that was equivalent to a GrSimpleTextureEffect
         // then we may pollute our texture cache with redundant shaders. So in the case that no
         // conversions were requested we instead return a GrSimpleTextureEffect.
-        return GrSimpleTextureEffect::Create(texture, matrix);
+        return GrSimpleTextureEffect::Make(texture, matrix);
     } else {
         if (kRGBA_8888_GrPixelConfig != texture->config() &&
             kBGRA_8888_GrPixelConfig != texture->config() &&
@@ -304,6 +304,7 @@
             // The PM conversions assume colors are 0..255
             return nullptr;
         }
-        return new GrConfigConversionEffect(texture, swizzle, pmConversion, matrix);
+        return sk_sp<GrFragmentProcessor>(
+            new GrConfigConversionEffect(texture, swizzle, pmConversion, matrix));
     }
 }
diff --git a/src/gpu/effects/GrConfigConversionEffect.h b/src/gpu/effects/GrConfigConversionEffect.h
index 65c55e7..93b49aa 100644
--- a/src/gpu/effects/GrConfigConversionEffect.h
+++ b/src/gpu/effects/GrConfigConversionEffect.h
@@ -33,8 +33,8 @@
         kPMConversionCnt
     };
 
-    static const GrFragmentProcessor* Create(GrTexture*, const GrSwizzle&, PMConversion,
-                                             const SkMatrix&);
+    static sk_sp<GrFragmentProcessor> Make(GrTexture*, const GrSwizzle&, PMConversion,
+                                           const SkMatrix&);
 
     const char* name() const override { return "Config Conversion"; }
 
diff --git a/src/gpu/effects/GrConstColorProcessor.cpp b/src/gpu/effects/GrConstColorProcessor.cpp
index c51ab8e..0684c9c 100644
--- a/src/gpu/effects/GrConstColorProcessor.cpp
+++ b/src/gpu/effects/GrConstColorProcessor.cpp
@@ -112,7 +112,7 @@
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConstColorProcessor);
 
-const GrFragmentProcessor* GrConstColorProcessor::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> GrConstColorProcessor::TestCreate(GrProcessorTestData* d) {
     GrColor color SK_INIT_TO_AVOID_WARNING;
     int colorPicker = d->fRandom->nextULessThan(3);
     switch (colorPicker) {
@@ -133,5 +133,5 @@
             break;
     }
     InputMode mode = static_cast<InputMode>(d->fRandom->nextULessThan(kInputModeCnt));
-    return GrConstColorProcessor::Create(color, mode);
+    return GrConstColorProcessor::Make(color, mode);
 }
diff --git a/src/gpu/effects/GrConvexPolyEffect.cpp b/src/gpu/effects/GrConvexPolyEffect.cpp
index caf86c2..5ce7867 100644
--- a/src/gpu/effects/GrConvexPolyEffect.cpp
+++ b/src/gpu/effects/GrConvexPolyEffect.cpp
@@ -19,8 +19,8 @@
 public:
     const SkRect& getRect() const { return fRect; }
 
-    static GrFragmentProcessor* Create(GrPrimitiveEdgeType edgeType, const SkRect& rect) {
-        return new AARectEffect(edgeType, rect);
+    static sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType edgeType, const SkRect& rect) {
+        return sk_sp<GrFragmentProcessor>(new AARectEffect(edgeType, rect));
     }
 
     GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
@@ -63,17 +63,17 @@
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(AARectEffect);
 
-const GrFragmentProcessor* AARectEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> AARectEffect::TestCreate(GrProcessorTestData* d) {
     SkRect rect = SkRect::MakeLTRB(d->fRandom->nextSScalar1(),
                                    d->fRandom->nextSScalar1(),
                                    d->fRandom->nextSScalar1(),
                                    d->fRandom->nextSScalar1());
-    GrFragmentProcessor* fp;
+    sk_sp<GrFragmentProcessor> fp;
     do {
         GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>(
                 d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt));
 
-        fp = AARectEffect::Create(edgeType, rect);
+        fp = AARectEffect::Make(edgeType, rect);
     } while (nullptr == fp);
     return fp;
 }
@@ -237,8 +237,8 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-GrFragmentProcessor* GrConvexPolyEffect::Create(GrPrimitiveEdgeType type, const SkPath& path,
-                                                const SkVector* offset) {
+sk_sp<GrFragmentProcessor> GrConvexPolyEffect::Make(GrPrimitiveEdgeType type, const SkPath& path,
+                                                    const SkVector* offset) {
     if (kHairlineAA_GrProcessorEdgeType == type) {
         return nullptr;
     }
@@ -253,10 +253,10 @@
     // skip the draw or omit the clip element.
     if (!SkPathPriv::CheapComputeFirstDirection(path, &dir)) {
         if (GrProcessorEdgeTypeIsInverseFill(type)) {
-            return GrConstColorProcessor::Create(0xFFFFFFFF,
-                                                 GrConstColorProcessor::kModulateRGBA_InputMode);
+            return GrConstColorProcessor::Make(0xFFFFFFFF,
+                                               GrConstColorProcessor::kModulateRGBA_InputMode);
         }
-        return GrConstColorProcessor::Create(0, GrConstColorProcessor::kIgnore_InputMode);
+        return GrConstColorProcessor::Make(0, GrConstColorProcessor::kIgnore_InputMode);
     }
 
     SkVector t;
@@ -308,14 +308,15 @@
     if (path.isInverseFillType()) {
         type = GrInvertProcessorEdgeType(type);
     }
-    return Create(type, n, edges);
+    return Make(type, n, edges);
 }
 
-GrFragmentProcessor* GrConvexPolyEffect::Create(GrPrimitiveEdgeType edgeType, const SkRect& rect) {
+sk_sp<GrFragmentProcessor> GrConvexPolyEffect::Make(GrPrimitiveEdgeType edgeType,
+                                                    const SkRect& rect) {
     if (kHairlineAA_GrProcessorEdgeType == edgeType){
         return nullptr;
     }
-    return AARectEffect::Create(edgeType, rect);
+    return AARectEffect::Make(edgeType, rect);
 }
 
 GrConvexPolyEffect::~GrConvexPolyEffect() {}
@@ -359,18 +360,18 @@
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConvexPolyEffect);
 
-const GrFragmentProcessor* GrConvexPolyEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> GrConvexPolyEffect::TestCreate(GrProcessorTestData* d) {
     int count = d->fRandom->nextULessThan(kMaxEdges) + 1;
     SkScalar edges[kMaxEdges * 3];
     for (int i = 0; i < 3 * count; ++i) {
         edges[i] = d->fRandom->nextSScalar1();
     }
 
-    GrFragmentProcessor* fp;
+    sk_sp<GrFragmentProcessor> fp;
     do {
         GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>(
                 d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt));
-        fp = GrConvexPolyEffect::Create(edgeType, count, edges);
+        fp = GrConvexPolyEffect::Make(edgeType, count, edges);
     } while (nullptr == fp);
     return fp;
 }
diff --git a/src/gpu/effects/GrConvexPolyEffect.h b/src/gpu/effects/GrConvexPolyEffect.h
index 316f111..8fc76fe 100644
--- a/src/gpu/effects/GrConvexPolyEffect.h
+++ b/src/gpu/effects/GrConvexPolyEffect.h
@@ -38,12 +38,12 @@
      * have to modify the effect/shaderbuilder interface to make it possible (e.g. give access
      * to the view matrix or untransformed positions in the fragment shader).
      */
-    static GrFragmentProcessor* Create(GrPrimitiveEdgeType edgeType, int n,
-                                       const SkScalar edges[]) {
+    static sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType edgeType, int n,
+                                           const SkScalar edges[]) {
         if (n <= 0 || n > kMaxEdges || kHairlineAA_GrProcessorEdgeType == edgeType) {
             return nullptr;
         }
-        return new GrConvexPolyEffect(edgeType, n, edges);
+        return sk_sp<GrFragmentProcessor>(new GrConvexPolyEffect(edgeType, n, edges));
     }
 
     /**
@@ -51,13 +51,13 @@
      * inverse filled, or has too many edges, this will return nullptr. If offset is non-nullptr, then
      * the path is translated by the vector.
      */
-    static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkPath&,
-                                       const SkVector* offset = nullptr);
+    static sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkPath&,
+                                           const SkVector* offset = nullptr);
 
     /**
      * Creates an effect that fills inside the rect with AA edges..
      */
-    static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkRect&);
+    static sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkRect&);
 
     virtual ~GrConvexPolyEffect();
 
diff --git a/src/gpu/effects/GrConvolutionEffect.cpp b/src/gpu/effects/GrConvolutionEffect.cpp
index 9567e4c..2266c47 100644
--- a/src/gpu/effects/GrConvolutionEffect.cpp
+++ b/src/gpu/effects/GrConvolutionEffect.cpp
@@ -213,7 +213,7 @@
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConvolutionEffect);
 
-const GrFragmentProcessor* GrConvolutionEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> GrConvolutionEffect::TestCreate(GrProcessorTestData* d) {
     int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
                                           GrProcessorUnitTest::kAlphaTextureIdx;
     Direction dir = d->fRandom->nextBool() ? kX_Direction : kY_Direction;
@@ -228,10 +228,10 @@
     }
 
     bool useBounds = d->fRandom->nextBool();
-    return GrConvolutionEffect::Create(d->fTextures[texIdx],
-                                       dir,
-                                       radius,
-                                       kernel,
-                                       useBounds,
-                                       bounds);
+    return GrConvolutionEffect::Make(d->fTextures[texIdx],
+                                     dir,
+                                     radius,
+                                     kernel,
+                                     useBounds,
+                                     bounds);
 }
diff --git a/src/gpu/effects/GrConvolutionEffect.h b/src/gpu/effects/GrConvolutionEffect.h
index af58021..c353542 100644
--- a/src/gpu/effects/GrConvolutionEffect.h
+++ b/src/gpu/effects/GrConvolutionEffect.h
@@ -21,23 +21,25 @@
 public:
 
     /// Convolve with an arbitrary user-specified kernel
-    static GrFragmentProcessor* Create(GrTexture* tex,
-                                       Direction dir,
-                                       int halfWidth,
-                                       const float* kernel,
-                                       bool useBounds,
-                                       float bounds[2]) {
-        return new GrConvolutionEffect(tex, dir, halfWidth, kernel, useBounds, bounds);
+    static sk_sp<GrFragmentProcessor> Make(GrTexture* tex,
+                                           Direction dir,
+                                           int halfWidth,
+                                           const float* kernel,
+                                           bool useBounds,
+                                           float bounds[2]) {
+        return sk_sp<GrFragmentProcessor>(
+            new GrConvolutionEffect(tex, dir, halfWidth, kernel, useBounds, bounds));
     }
 
     /// Convolve with a Gaussian kernel
-    static GrFragmentProcessor* CreateGaussian(GrTexture* tex,
-                                               Direction dir,
-                                               int halfWidth,
-                                               float gaussianSigma,
-                                               bool useBounds,
-                                               float bounds[2]) {
-        return new GrConvolutionEffect(tex, dir, halfWidth, gaussianSigma, useBounds, bounds);
+    static sk_sp<GrFragmentProcessor> MakeGaussian(GrTexture* tex,
+                                                   Direction dir,
+                                                   int halfWidth,
+                                                   float gaussianSigma,
+                                                   bool useBounds,
+                                                   float bounds[2]) {
+        return sk_sp<GrFragmentProcessor>(
+            new GrConvolutionEffect(tex, dir, halfWidth, gaussianSigma, useBounds, bounds));
     }
 
     virtual ~GrConvolutionEffect();
diff --git a/src/gpu/effects/GrCoverageSetOpXP.cpp b/src/gpu/effects/GrCoverageSetOpXP.cpp
index c0ba62f..90657ea 100644
--- a/src/gpu/effects/GrCoverageSetOpXP.cpp
+++ b/src/gpu/effects/GrCoverageSetOpXP.cpp
@@ -243,65 +243,65 @@
     this->initClassID<GrCoverageSetOpXPFactory>();
 }
 
-GrXPFactory* GrCoverageSetOpXPFactory::Create(SkRegion::Op regionOp, bool invertCoverage) {
+sk_sp<GrXPFactory> GrCoverageSetOpXPFactory::Make(SkRegion::Op regionOp, bool invertCoverage) {
     switch (regionOp) {
         case SkRegion::kReplace_Op: {
             if (invertCoverage) {
                 static GrCoverageSetOpXPFactory gReplaceCDXPFI(regionOp, invertCoverage);
-                return SkRef(&gReplaceCDXPFI);
+                return sk_sp<GrXPFactory>(SkRef(&gReplaceCDXPFI));
             } else {
                 static GrCoverageSetOpXPFactory gReplaceCDXPF(regionOp, invertCoverage);
-                return SkRef(&gReplaceCDXPF);
+                return sk_sp<GrXPFactory>(SkRef(&gReplaceCDXPF));
             }
             break;
         }
         case SkRegion::kIntersect_Op: {
             if (invertCoverage) {
                 static GrCoverageSetOpXPFactory gIntersectCDXPFI(regionOp, invertCoverage);
-                return SkRef(&gIntersectCDXPFI);
+                return sk_sp<GrXPFactory>(SkRef(&gIntersectCDXPFI));
             } else {
                 static GrCoverageSetOpXPFactory gIntersectCDXPF(regionOp, invertCoverage);
-                return SkRef(&gIntersectCDXPF);
+                return sk_sp<GrXPFactory>(SkRef(&gIntersectCDXPF));
             }
             break;
         }
         case SkRegion::kUnion_Op: {
             if (invertCoverage) {
                 static GrCoverageSetOpXPFactory gUnionCDXPFI(regionOp, invertCoverage);
-                return SkRef(&gUnionCDXPFI);
+                return sk_sp<GrXPFactory>(SkRef(&gUnionCDXPFI));
             } else {
                 static GrCoverageSetOpXPFactory gUnionCDXPF(regionOp, invertCoverage);
-                return SkRef(&gUnionCDXPF);
+                return sk_sp<GrXPFactory>(SkRef(&gUnionCDXPF));
             }
             break;
         }
         case SkRegion::kXOR_Op: {
             if (invertCoverage) {
                 static GrCoverageSetOpXPFactory gXORCDXPFI(regionOp, invertCoverage);
-                return SkRef(&gXORCDXPFI);
+                return sk_sp<GrXPFactory>(SkRef(&gXORCDXPFI));
             } else {
                 static GrCoverageSetOpXPFactory gXORCDXPF(regionOp, invertCoverage);
-                return SkRef(&gXORCDXPF);
+                return sk_sp<GrXPFactory>(SkRef(&gXORCDXPF));
             }
             break;
         }
         case SkRegion::kDifference_Op: {
             if (invertCoverage) {
                 static GrCoverageSetOpXPFactory gDifferenceCDXPFI(regionOp, invertCoverage);
-                return SkRef(&gDifferenceCDXPFI);
+                return sk_sp<GrXPFactory>(SkRef(&gDifferenceCDXPFI));
             } else {
                 static GrCoverageSetOpXPFactory gDifferenceCDXPF(regionOp, invertCoverage);
-                return SkRef(&gDifferenceCDXPF);
+                return sk_sp<GrXPFactory>(SkRef(&gDifferenceCDXPF));
             }
             break;
         }
         case SkRegion::kReverseDifference_Op: {
             if (invertCoverage) {
                 static GrCoverageSetOpXPFactory gRevDiffCDXPFI(regionOp, invertCoverage);
-                return SkRef(&gRevDiffCDXPFI);
+                return sk_sp<GrXPFactory>(SkRef(&gRevDiffCDXPFI));
             } else {
                 static GrCoverageSetOpXPFactory gRevDiffCDXPF(regionOp, invertCoverage);
-                return SkRef(&gRevDiffCDXPF);
+                return sk_sp<GrXPFactory>(SkRef(&gRevDiffCDXPF));
             }
             break;
         }
@@ -337,8 +337,8 @@
 
 GR_DEFINE_XP_FACTORY_TEST(GrCoverageSetOpXPFactory);
 
-const GrXPFactory* GrCoverageSetOpXPFactory::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrXPFactory> GrCoverageSetOpXPFactory::TestCreate(GrProcessorTestData* d) {
     SkRegion::Op regionOp = SkRegion::Op(d->fRandom->nextULessThan(SkRegion::kLastOp + 1));
     bool invertCoverage = !d->fDrawContext->hasMixedSamples() && d->fRandom->nextBool();
-    return GrCoverageSetOpXPFactory::Create(regionOp, invertCoverage);
+    return GrCoverageSetOpXPFactory::Make(regionOp, invertCoverage);
 }
diff --git a/src/gpu/effects/GrCustomXfermode.cpp b/src/gpu/effects/GrCustomXfermode.cpp
index 50fe5cb..1b94a6b 100644
--- a/src/gpu/effects/GrCustomXfermode.cpp
+++ b/src/gpu/effects/GrCustomXfermode.cpp
@@ -382,19 +382,19 @@
 }
 
 GR_DEFINE_XP_FACTORY_TEST(CustomXPFactory);
-const GrXPFactory* CustomXPFactory::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrXPFactory> CustomXPFactory::TestCreate(GrProcessorTestData* d) {
     int mode = d->fRandom->nextRangeU(SkXfermode::kLastCoeffMode + 1,
                                       SkXfermode::kLastSeparableMode);
 
-    return new CustomXPFactory(static_cast<SkXfermode::Mode>(mode));
+    return sk_sp<GrXPFactory>(new CustomXPFactory(static_cast<SkXfermode::Mode>(mode)));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrXPFactory* GrCustomXfermode::CreateXPFactory(SkXfermode::Mode mode) {
+sk_sp<GrXPFactory> GrCustomXfermode::MakeXPFactory(SkXfermode::Mode mode) {
     if (!GrCustomXfermode::IsSupportedMode(mode)) {
         return nullptr;
     } else {
-        return new CustomXPFactory(mode);
+        return sk_sp<GrXPFactory>(new CustomXPFactory(mode));
     }
 }
diff --git a/src/gpu/effects/GrDashingEffect.cpp b/src/gpu/effects/GrDashingEffect.cpp
index 8a7cb5e..ae37540 100644
--- a/src/gpu/effects/GrDashingEffect.cpp
+++ b/src/gpu/effects/GrDashingEffect.cpp
@@ -232,11 +232,11 @@
  * Bounding geometry is rendered and the effect computes coverage based on the fragment's
  * position relative to the dashed line.
  */
-static GrGeometryProcessor* create_dash_gp(GrColor,
-                                           AAMode aaMode,
-                                           DashCap cap,
-                                           const SkMatrix& localMatrix,
-                                           bool usesLocalCoords);
+static sk_sp<GrGeometryProcessor> make_dash_gp(GrColor,
+                                               AAMode aaMode,
+                                               DashCap cap,
+                                               const SkMatrix& localMatrix,
+                                               bool usesLocalCoords);
 
 class DashBatch : public GrVertexBatch {
 public:
@@ -331,10 +331,10 @@
         bool isRoundCap = SkPaint::kRound_Cap == cap;
         DashCap capType = isRoundCap ? kRound_DashCap : kNonRound_DashCap;
 
-        SkAutoTUnref<const GrGeometryProcessor> gp;
+        sk_sp<GrGeometryProcessor> gp;
         if (this->fullDash()) {
-            gp.reset(create_dash_gp(this->color(), this->aaMode(), capType, this->viewMatrix(),
-                                    this->usesLocalCoords()));
+            gp = make_dash_gp(this->color(), this->aaMode(), capType, this->viewMatrix(),
+                              this->usesLocalCoords());
         } else {
             // Set up the vertex data for the line and start/end dashes
             using namespace GrDefaultGeoProcFactory;
@@ -343,7 +343,7 @@
                                                         Coverage::kSolid_Type);
             LocalCoords localCoords(this->usesLocalCoords() ? LocalCoords::kUsePosition_Type :
                                                               LocalCoords::kUnused_Type);
-            gp.reset(CreateForDeviceSpace(color, coverage, localCoords, this->viewMatrix()));
+            gp = MakeForDeviceSpace(color, coverage, localCoords, this->viewMatrix());
         }
 
         if (!gp) {
@@ -622,7 +622,7 @@
             rectIndex++;
         }
         SkASSERT(0 == (curVIdx % 4) && (curVIdx / 4) == totalRectCount);
-        helper.recordDraw(target, gp);
+        helper.recordDraw(target, gp.get());
     }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
@@ -757,10 +757,10 @@
 public:
     typedef SkPathEffect::DashInfo DashInfo;
 
-    static GrGeometryProcessor* Create(GrColor,
-                                       AAMode aaMode,
-                                       const SkMatrix& localMatrix,
-                                       bool usesLocalCoords);
+    static sk_sp<GrGeometryProcessor> Make(GrColor,
+                                           AAMode aaMode,
+                                           const SkMatrix& localMatrix,
+                                           bool usesLocalCoords);
 
     const char* name() const override { return "DashingCircleEffect"; }
 
@@ -919,11 +919,12 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-GrGeometryProcessor* DashingCircleEffect::Create(GrColor color,
-                                                 AAMode aaMode,
-                                                 const SkMatrix& localMatrix,
-                                                 bool usesLocalCoords) {
-    return new DashingCircleEffect(color, aaMode, localMatrix, usesLocalCoords);
+sk_sp<GrGeometryProcessor> DashingCircleEffect::Make(GrColor color,
+                                                     AAMode aaMode,
+                                                     const SkMatrix& localMatrix,
+                                                     bool usesLocalCoords) {
+    return sk_sp<GrGeometryProcessor>(
+        new DashingCircleEffect(color, aaMode, localMatrix, usesLocalCoords));
 }
 
 void DashingCircleEffect::getGLSLProcessorKey(const GrGLSLCaps& caps,
@@ -952,11 +953,11 @@
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingCircleEffect);
 
-const GrGeometryProcessor* DashingCircleEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrGeometryProcessor> DashingCircleEffect::TestCreate(GrProcessorTestData* d) {
     AAMode aaMode = static_cast<AAMode>(d->fRandom->nextULessThan(GrDashingEffect::kAAModeCnt));
-    return DashingCircleEffect::Create(GrRandomColor(d->fRandom),
-                                      aaMode, GrTest::TestMatrix(d->fRandom),
-                                      d->fRandom->nextBool());
+    return DashingCircleEffect::Make(GrRandomColor(d->fRandom),
+                                    aaMode, GrTest::TestMatrix(d->fRandom),
+                                    d->fRandom->nextBool());
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -976,10 +977,10 @@
 public:
     typedef SkPathEffect::DashInfo DashInfo;
 
-    static GrGeometryProcessor* Create(GrColor,
-                                       AAMode aaMode,
-                                       const SkMatrix& localMatrix,
-                                       bool usesLocalCoords);
+    static sk_sp<GrGeometryProcessor> Make(GrColor,
+                                           AAMode aaMode,
+                                           const SkMatrix& localMatrix,
+                                           bool usesLocalCoords);
 
     const char* name() const override { return "DashingEffect"; }
 
@@ -1151,11 +1152,12 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-GrGeometryProcessor* DashingLineEffect::Create(GrColor color,
-                                               AAMode aaMode,
-                                               const SkMatrix& localMatrix,
-                                               bool usesLocalCoords) {
-    return new DashingLineEffect(color, aaMode, localMatrix, usesLocalCoords);
+sk_sp<GrGeometryProcessor> DashingLineEffect::Make(GrColor color,
+                                                   AAMode aaMode,
+                                                   const SkMatrix& localMatrix,
+                                                   bool usesLocalCoords) {
+    return sk_sp<GrGeometryProcessor>(
+        new DashingLineEffect(color, aaMode, localMatrix, usesLocalCoords));
 }
 
 void DashingLineEffect::getGLSLProcessorKey(const GrGLSLCaps& caps,
@@ -1183,20 +1185,20 @@
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingLineEffect);
 
-const GrGeometryProcessor* DashingLineEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrGeometryProcessor> DashingLineEffect::TestCreate(GrProcessorTestData* d) {
     AAMode aaMode = static_cast<AAMode>(d->fRandom->nextULessThan(GrDashingEffect::kAAModeCnt));
-    return DashingLineEffect::Create(GrRandomColor(d->fRandom),
-                                     aaMode, GrTest::TestMatrix(d->fRandom),
-                                     d->fRandom->nextBool());
+    return DashingLineEffect::Make(GrRandomColor(d->fRandom),
+                                   aaMode, GrTest::TestMatrix(d->fRandom),
+                                   d->fRandom->nextBool());
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-static GrGeometryProcessor* create_dash_gp(GrColor color,
-                                           AAMode aaMode,
-                                           DashCap cap,
-                                           const SkMatrix& viewMatrix,
-                                           bool usesLocalCoords) {
+static sk_sp<GrGeometryProcessor> make_dash_gp(GrColor color,
+                                               AAMode aaMode,
+                                               DashCap cap,
+                                               const SkMatrix& viewMatrix,
+                                               bool usesLocalCoords) {
     SkMatrix invert;
     if (usesLocalCoords && !viewMatrix.invert(&invert)) {
         SkDebugf("Failed to invert\n");
@@ -1205,9 +1207,9 @@
 
     switch (cap) {
         case kRound_DashCap:
-            return DashingCircleEffect::Create(color, aaMode, invert, usesLocalCoords);
+            return DashingCircleEffect::Make(color, aaMode, invert, usesLocalCoords);
         case kNonRound_DashCap:
-            return DashingLineEffect::Create(color, aaMode, invert, usesLocalCoords);
+            return DashingLineEffect::Make(color, aaMode, invert, usesLocalCoords);
     }
     return nullptr;
 }
diff --git a/src/gpu/effects/GrDisableColorXP.cpp b/src/gpu/effects/GrDisableColorXP.cpp
index 7d776e7..1ff8ad6 100644
--- a/src/gpu/effects/GrDisableColorXP.cpp
+++ b/src/gpu/effects/GrDisableColorXP.cpp
@@ -104,6 +104,6 @@
 
 GR_DEFINE_XP_FACTORY_TEST(GrDisableColorXPFactory);
 
-const GrXPFactory* GrDisableColorXPFactory::TestCreate(GrProcessorTestData*) {
-    return GrDisableColorXPFactory::Create();
+sk_sp<GrXPFactory> GrDisableColorXPFactory::TestCreate(GrProcessorTestData*) {
+    return GrDisableColorXPFactory::Make();
 }
diff --git a/src/gpu/effects/GrDisableColorXP.h b/src/gpu/effects/GrDisableColorXP.h
index 5584954..4aed6b6 100644
--- a/src/gpu/effects/GrDisableColorXP.h
+++ b/src/gpu/effects/GrDisableColorXP.h
@@ -10,12 +10,13 @@
 
 #include "GrTypes.h"
 #include "GrXferProcessor.h"
+#include "SkRefCnt.h"
 
 class GrProcOptInfo;
 
 class GrDisableColorXPFactory : public GrXPFactory {
 public:
-    static GrXPFactory* Create() { return new GrDisableColorXPFactory; }
+    static sk_sp<GrXPFactory> Make() { return sk_sp<GrXPFactory>(new GrDisableColorXPFactory); }
 
     void getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
                                   GrXPFactory::InvariantBlendedColor* blendedColor) const override {
diff --git a/src/gpu/effects/GrDistanceFieldGeoProc.cpp b/src/gpu/effects/GrDistanceFieldGeoProc.cpp
index e87021e..f43a1e8 100644
--- a/src/gpu/effects/GrDistanceFieldGeoProc.cpp
+++ b/src/gpu/effects/GrDistanceFieldGeoProc.cpp
@@ -260,7 +260,7 @@
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldA8TextGeoProc);
 
-const GrGeometryProcessor* GrDistanceFieldA8TextGeoProc::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrGeometryProcessor> GrDistanceFieldA8TextGeoProc::TestCreate(GrProcessorTestData* d) {
     int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
                                           GrProcessorUnitTest::kAlphaTextureIdx;
     static const SkShader::TileMode kTileModes[] = {
@@ -281,14 +281,14 @@
         flags |= d->fRandom->nextBool() ? kScaleOnly_DistanceFieldEffectFlag : 0;
     }
 
-    return GrDistanceFieldA8TextGeoProc::Create(GrRandomColor(d->fRandom),
-                                                GrTest::TestMatrix(d->fRandom),
-                                                d->fTextures[texIdx], params,
+    return GrDistanceFieldA8TextGeoProc::Make(GrRandomColor(d->fRandom),
+                                              GrTest::TestMatrix(d->fRandom),
+                                              d->fTextures[texIdx], params,
 #ifdef SK_GAMMA_APPLY_TO_A8
-                                                d->fRandom->nextF(),
+                                              d->fRandom->nextF(),
 #endif
-                                                flags,
-                                                d->fRandom->nextBool());
+                                              flags,
+                                              d->fRandom->nextBool());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -497,7 +497,7 @@
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldPathGeoProc);
 
-const GrGeometryProcessor* GrDistanceFieldPathGeoProc::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrGeometryProcessor> GrDistanceFieldPathGeoProc::TestCreate(GrProcessorTestData* d) {
     int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
                                         : GrProcessorUnitTest::kAlphaTextureIdx;
     static const SkShader::TileMode kTileModes[] = {
@@ -518,12 +518,12 @@
         flags |= d->fRandom->nextBool() ? kScaleOnly_DistanceFieldEffectFlag : 0;
     }
 
-    return GrDistanceFieldPathGeoProc::Create(GrRandomColor(d->fRandom),
-                                              GrTest::TestMatrix(d->fRandom),
-                                              d->fTextures[texIdx],
-                                              params,
-                                              flags,
-                                              d->fRandom->nextBool());
+    return GrDistanceFieldPathGeoProc::Make(GrRandomColor(d->fRandom),
+                                            GrTest::TestMatrix(d->fRandom),
+                                            d->fTextures[texIdx],
+                                            params,
+                                            flags,
+                                            d->fRandom->nextBool());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -794,7 +794,7 @@
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldLCDTextGeoProc);
 
-const GrGeometryProcessor* GrDistanceFieldLCDTextGeoProc::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrGeometryProcessor> GrDistanceFieldLCDTextGeoProc::TestCreate(GrProcessorTestData* d) {
     int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
                                           GrProcessorUnitTest::kAlphaTextureIdx;
     static const SkShader::TileMode kTileModes[] = {
@@ -815,10 +815,10 @@
         flags |= d->fRandom->nextBool() ? kScaleOnly_DistanceFieldEffectFlag : 0;
     }
     flags |= d->fRandom->nextBool() ? kBGR_DistanceFieldEffectFlag : 0;
-    return GrDistanceFieldLCDTextGeoProc::Create(GrRandomColor(d->fRandom),
-                                                 GrTest::TestMatrix(d->fRandom),
-                                                 d->fTextures[texIdx], params,
-                                                 wa,
-                                                 flags,
-                                                 d->fRandom->nextBool());
+    return GrDistanceFieldLCDTextGeoProc::Make(GrRandomColor(d->fRandom),
+                                               GrTest::TestMatrix(d->fRandom),
+                                               d->fTextures[texIdx], params,
+                                               wa,
+                                               flags,
+                                               d->fRandom->nextBool());
 }
diff --git a/src/gpu/effects/GrDistanceFieldGeoProc.h b/src/gpu/effects/GrDistanceFieldGeoProc.h
index 406c352..0f6d8c1 100644
--- a/src/gpu/effects/GrDistanceFieldGeoProc.h
+++ b/src/gpu/effects/GrDistanceFieldGeoProc.h
@@ -49,18 +49,20 @@
 class GrDistanceFieldA8TextGeoProc : public GrGeometryProcessor {
 public:
 #ifdef SK_GAMMA_APPLY_TO_A8
-    static GrGeometryProcessor* Create(GrColor color, const SkMatrix& viewMatrix,
-                                       GrTexture* tex, const GrTextureParams& params,
-                                       float lum, uint32_t flags, bool usesLocalCoords) {
-        return new GrDistanceFieldA8TextGeoProc(color, viewMatrix, tex, params, lum, flags,
-                                                usesLocalCoords);
+    static sk_sp<GrGeometryProcessor> Make(GrColor color, const SkMatrix& viewMatrix,
+                                           GrTexture* tex, const GrTextureParams& params,
+                                           float lum, uint32_t flags, bool usesLocalCoords) {
+        return sk_sp<GrGeometryProcessor>(
+            new GrDistanceFieldA8TextGeoProc(color, viewMatrix, tex, params, lum, flags,
+                                             usesLocalCoords));
     }
 #else
-    static GrGeometryProcessor* Create(GrColor color, const SkMatrix& viewMatrix,
-                                       GrTexture* tex, const GrTextureParams& params,
-                                       uint32_t flags, bool usesLocalCoords) {
-        return new GrDistanceFieldA8TextGeoProc(color, viewMatrix, tex, params, flags,
-                                                usesLocalCoords);
+    static sk_sp<GrGeometryProcessor> Make(GrColor color, const SkMatrix& viewMatrix,
+                                           GrTexture* tex, const GrTextureParams& params,
+                                           uint32_t flags, bool usesLocalCoords) {
+        return sk_sp<GrGeometryProcessor>(
+            new GrDistanceFieldA8TextGeoProc(color, viewMatrix, tex, params, flags,
+                                             usesLocalCoords));
     }
 #endif
 
@@ -118,11 +120,11 @@
 */
 class GrDistanceFieldPathGeoProc : public GrGeometryProcessor {
 public:
-    static GrGeometryProcessor* Create(GrColor color, const SkMatrix& viewMatrix, GrTexture* tex,
-                                       const GrTextureParams& params,
-                                       uint32_t flags, bool usesLocalCoords) {
-        return new GrDistanceFieldPathGeoProc(color, viewMatrix, tex, params, flags,
-                                              usesLocalCoords);
+    static sk_sp<GrGeometryProcessor> Make(GrColor color, const SkMatrix& viewMatrix,
+                                           GrTexture* tex, const GrTextureParams& params,
+                                           uint32_t flags, bool usesLocalCoords) {
+        return sk_sp<GrGeometryProcessor>(
+            new GrDistanceFieldPathGeoProc(color, viewMatrix, tex, params, flags, usesLocalCoords));
     }
 
     virtual ~GrDistanceFieldPathGeoProc() {}
@@ -184,12 +186,13 @@
         }
     };
 
-    static GrGeometryProcessor* Create(GrColor color, const SkMatrix& viewMatrix,
-                                       GrTexture* tex, const GrTextureParams& params,
-                                       DistanceAdjust distanceAdjust, uint32_t flags,
-                                       bool usesLocalCoords) {
-        return new GrDistanceFieldLCDTextGeoProc(color, viewMatrix, tex, params, distanceAdjust,
-                                                 flags, usesLocalCoords);
+    static sk_sp<GrGeometryProcessor> Make(GrColor color, const SkMatrix& viewMatrix,
+                                           GrTexture* tex, const GrTextureParams& params,
+                                           DistanceAdjust distanceAdjust, uint32_t flags,
+                                           bool usesLocalCoords) {
+        return sk_sp<GrGeometryProcessor>(
+            new GrDistanceFieldLCDTextGeoProc(color, viewMatrix, tex, params, distanceAdjust,
+                                              flags, usesLocalCoords));
     }
 
     virtual ~GrDistanceFieldLCDTextGeoProc() {}
diff --git a/src/gpu/effects/GrDitherEffect.cpp b/src/gpu/effects/GrDitherEffect.cpp
index 39d4063..abce5ca 100644
--- a/src/gpu/effects/GrDitherEffect.cpp
+++ b/src/gpu/effects/GrDitherEffect.cpp
@@ -16,8 +16,8 @@
 
 class DitherEffect : public GrFragmentProcessor {
 public:
-    static GrFragmentProcessor* Create() {
-        return new DitherEffect;
+    static sk_sp<GrFragmentProcessor> Make() {
+        return sk_sp<GrFragmentProcessor>(new DitherEffect);
     }
 
     virtual ~DitherEffect() {};
@@ -52,8 +52,8 @@
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(DitherEffect);
 
-const GrFragmentProcessor* DitherEffect::TestCreate(GrProcessorTestData*) {
-    return DitherEffect::Create();
+sk_sp<GrFragmentProcessor> DitherEffect::TestCreate(GrProcessorTestData*) {
+    return DitherEffect::Make();
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -95,4 +95,4 @@
     return new GLDitherEffect;
 }
 
-GrFragmentProcessor* GrDitherEffect::Create() { return DitherEffect::Create(); }
+sk_sp<GrFragmentProcessor> GrDitherEffect::Make() { return DitherEffect::Make(); }
diff --git a/src/gpu/effects/GrDitherEffect.h b/src/gpu/effects/GrDitherEffect.h
index 64c85f7..b92723d 100644
--- a/src/gpu/effects/GrDitherEffect.h
+++ b/src/gpu/effects/GrDitherEffect.h
@@ -10,6 +10,7 @@
 
 #include "GrTypes.h"
 #include "GrTypesPriv.h"
+#include "SkRefCnt.h"
 
 class GrFragmentProcessor;
 
@@ -17,7 +18,7 @@
     /**
      * Creates an effect that dithers the resulting color to an RGBA8 framebuffer
      */
-    GrFragmentProcessor* Create();
+    sk_sp<GrFragmentProcessor> Make();
 };
 
 #endif
diff --git a/src/gpu/effects/GrGammaEffect.cpp b/src/gpu/effects/GrGammaEffect.cpp
index 71d8c91..63ffc32 100644
--- a/src/gpu/effects/GrGammaEffect.cpp
+++ b/src/gpu/effects/GrGammaEffect.cpp
@@ -116,11 +116,11 @@
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrGammaEffect);
 
-const GrFragmentProcessor* GrGammaEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> GrGammaEffect::TestCreate(GrProcessorTestData* d) {
     // We want to be sure and test sRGB sometimes
     Mode testMode = static_cast<Mode>(d->fRandom->nextRangeU(0, 2));
     SkScalar gamma = d->fRandom->nextRangeScalar(0.5f, 2.0f);
-    return new GrGammaEffect(testMode, gamma);
+    return sk_sp<GrFragmentProcessor>(new GrGammaEffect(testMode, gamma));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -134,15 +134,15 @@
     return new GrGLGammaEffect();
 }
 
-const GrFragmentProcessor* GrGammaEffect::Create(SkScalar gamma) {
+sk_sp<GrFragmentProcessor> GrGammaEffect::Make(SkScalar gamma) {
     // TODO: Once our public-facing API for specifying gamma curves settles down, expose this,
     // and allow clients to explicitly request sRGB, rather than inferring from the exponent.
     // Note that AdobeRGB (for example) is speficied as x^2.2, not the Rec.709 curves.
     if (SkScalarNearlyEqual(gamma, 2.2f)) {
-        return new GrGammaEffect(Mode::kSRGBToLinear, 2.2f);
+        return sk_sp<GrFragmentProcessor>(new GrGammaEffect(Mode::kSRGBToLinear, 2.2f));
     } else if (SkScalarNearlyEqual(gamma, 1.0f / 2.2f)) {
-        return new GrGammaEffect(Mode::kLinearToSRGB, 1.0f / 2.2f);
+        return sk_sp<GrFragmentProcessor>(new GrGammaEffect(Mode::kLinearToSRGB, 1.0f / 2.2f));
     } else {
-        return new GrGammaEffect(Mode::kExponential, gamma);
+        return sk_sp<GrFragmentProcessor>(new GrGammaEffect(Mode::kExponential, gamma));
     }
 }
diff --git a/src/gpu/effects/GrGammaEffect.h b/src/gpu/effects/GrGammaEffect.h
index 2e53b09..3f84ac9 100644
--- a/src/gpu/effects/GrGammaEffect.h
+++ b/src/gpu/effects/GrGammaEffect.h
@@ -21,7 +21,7 @@
     /**
     * Creates an effect that applies a gamma curve.
     */
-    static const GrFragmentProcessor* Create(SkScalar gamma);
+    static sk_sp<GrFragmentProcessor> Make(SkScalar gamma);
 
     const char* name() const override { return "Gamma"; }
 
diff --git a/src/gpu/effects/GrMatrixConvolutionEffect.cpp b/src/gpu/effects/GrMatrixConvolutionEffect.cpp
index 60f518b..5422755 100644
--- a/src/gpu/effects/GrMatrixConvolutionEffect.cpp
+++ b/src/gpu/effects/GrMatrixConvolutionEffect.cpp
@@ -191,17 +191,17 @@
 }
 
 // Static function to create a 2D convolution
-GrFragmentProcessor*
-GrMatrixConvolutionEffect::CreateGaussian(GrTexture* texture,
-                                          const SkIRect& bounds,
-                                          const SkISize& kernelSize,
-                                          SkScalar gain,
-                                          SkScalar bias,
-                                          const SkIPoint& kernelOffset,
-                                          GrTextureDomain::Mode tileMode,
-                                          bool convolveAlpha,
-                                          SkScalar sigmaX,
-                                          SkScalar sigmaY) {
+sk_sp<GrFragmentProcessor>
+GrMatrixConvolutionEffect::MakeGaussian(GrTexture* texture,
+                                        const SkIRect& bounds,
+                                        const SkISize& kernelSize,
+                                        SkScalar gain,
+                                        SkScalar bias,
+                                        const SkIPoint& kernelOffset,
+                                        GrTextureDomain::Mode tileMode,
+                                        bool convolveAlpha,
+                                        SkScalar sigmaX,
+                                        SkScalar sigmaY) {
     float kernel[MAX_KERNEL_SIZE];
     int width = kernelSize.width();
     int height = kernelSize.height();
@@ -228,13 +228,14 @@
     for (int i = 0; i < width * height; ++i) {
         kernel[i] *= scale;
     }
-    return new GrMatrixConvolutionEffect(texture, bounds, kernelSize, kernel, gain, bias,
-                                         kernelOffset, tileMode, convolveAlpha);
+    return sk_sp<GrFragmentProcessor>(
+        new GrMatrixConvolutionEffect(texture, bounds, kernelSize, kernel, gain, bias,
+                                      kernelOffset, tileMode, convolveAlpha));
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMatrixConvolutionEffect);
 
-const GrFragmentProcessor* GrMatrixConvolutionEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> GrMatrixConvolutionEffect::TestCreate(GrProcessorTestData* d) {
     int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
                                           GrProcessorUnitTest::kAlphaTextureIdx;
     int width = d->fRandom->nextRangeU(1, MAX_KERNEL_SIZE);
@@ -255,13 +256,13 @@
     GrTextureDomain::Mode tileMode =
             static_cast<GrTextureDomain::Mode>(d->fRandom->nextRangeU(0, 2));
     bool convolveAlpha = d->fRandom->nextBool();
-    return GrMatrixConvolutionEffect::Create(d->fTextures[texIdx],
-                                             bounds,
-                                             kernelSize,
-                                             kernel.get(),
-                                             gain,
-                                             bias,
-                                             kernelOffset,
-                                             tileMode,
-                                             convolveAlpha);
+    return GrMatrixConvolutionEffect::Make(d->fTextures[texIdx],
+                                           bounds,
+                                           kernelSize,
+                                           kernel.get(),
+                                           gain,
+                                           bias,
+                                           kernelOffset,
+                                           tileMode,
+                                           convolveAlpha);
 }
diff --git a/src/gpu/effects/GrMatrixConvolutionEffect.h b/src/gpu/effects/GrMatrixConvolutionEffect.h
index 066da65..b8df437 100644
--- a/src/gpu/effects/GrMatrixConvolutionEffect.h
+++ b/src/gpu/effects/GrMatrixConvolutionEffect.h
@@ -18,29 +18,30 @@
 
 class GrMatrixConvolutionEffect : public GrSingleTextureEffect {
 public:
-    static GrFragmentProcessor* Create(GrTexture* texture,
-                                       const SkIRect& bounds,
-                                       const SkISize& kernelSize,
-                                       const SkScalar* kernel,
-                                       SkScalar gain,
-                                       SkScalar bias,
-                                       const SkIPoint& kernelOffset,
-                                       GrTextureDomain::Mode tileMode,
-                                       bool convolveAlpha) {
-        return new GrMatrixConvolutionEffect(texture, bounds, kernelSize, kernel, gain, bias,
-                                             kernelOffset, tileMode, convolveAlpha);
+    static sk_sp<GrFragmentProcessor> Make(GrTexture* texture,
+                                           const SkIRect& bounds,
+                                           const SkISize& kernelSize,
+                                           const SkScalar* kernel,
+                                           SkScalar gain,
+                                           SkScalar bias,
+                                           const SkIPoint& kernelOffset,
+                                           GrTextureDomain::Mode tileMode,
+                                           bool convolveAlpha) {
+        return sk_sp<GrFragmentProcessor>(
+            new GrMatrixConvolutionEffect(texture, bounds, kernelSize, kernel, gain, bias,
+                                          kernelOffset, tileMode, convolveAlpha));
     }
 
-    static GrFragmentProcessor* CreateGaussian(GrTexture* texture,
-                                               const SkIRect& bounds,
-                                               const SkISize& kernelSize,
-                                               SkScalar gain,
-                                               SkScalar bias,
-                                               const SkIPoint& kernelOffset,
-                                               GrTextureDomain::Mode tileMode,
-                                               bool convolveAlpha,
-                                               SkScalar sigmaX,
-                                               SkScalar sigmaY);
+    static sk_sp<GrFragmentProcessor> MakeGaussian(GrTexture* texture,
+                                                   const SkIRect& bounds,
+                                                   const SkISize& kernelSize,
+                                                   SkScalar gain,
+                                                   SkScalar bias,
+                                                   const SkIPoint& kernelOffset,
+                                                   GrTextureDomain::Mode tileMode,
+                                                   bool convolveAlpha,
+                                                   SkScalar sigmaX,
+                                                   SkScalar sigmaY);
 
     const SkIRect& bounds() const { return fBounds; }
     const SkISize& kernelSize() const { return fKernelSize; }
diff --git a/src/gpu/effects/GrOvalEffect.cpp b/src/gpu/effects/GrOvalEffect.cpp
index 3e6287b..a288537 100644
--- a/src/gpu/effects/GrOvalEffect.cpp
+++ b/src/gpu/effects/GrOvalEffect.cpp
@@ -19,7 +19,8 @@
 
 class CircleEffect : public GrFragmentProcessor {
 public:
-    static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkPoint& center, SkScalar radius);
+    static sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkPoint& center,
+                                           SkScalar radius);
 
     virtual ~CircleEffect() {};
 
@@ -50,10 +51,10 @@
     typedef GrFragmentProcessor INHERITED;
 };
 
-GrFragmentProcessor* CircleEffect::Create(GrPrimitiveEdgeType edgeType, const SkPoint& center,
-                                          SkScalar radius) {
+sk_sp<GrFragmentProcessor> CircleEffect::Make(GrPrimitiveEdgeType edgeType, const SkPoint& center,
+                                              SkScalar radius) {
     SkASSERT(radius >= 0);
-    return new CircleEffect(edgeType, center, radius);
+    return sk_sp<GrFragmentProcessor>(new CircleEffect(edgeType, center, radius));
 }
 
 void CircleEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
@@ -77,7 +78,7 @@
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleEffect);
 
-const GrFragmentProcessor* CircleEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> CircleEffect::TestCreate(GrProcessorTestData* d) {
     SkPoint center;
     center.fX = d->fRandom->nextRangeScalar(0.f, 1000.f);
     center.fY = d->fRandom->nextRangeScalar(0.f, 1000.f);
@@ -86,7 +87,7 @@
     do {
         et = (GrPrimitiveEdgeType)d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt);
     } while (kHairlineAA_GrProcessorEdgeType == et);
-    return CircleEffect::Create(et, center, radius);
+    return CircleEffect::Make(et, center, radius);
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -183,8 +184,8 @@
 
 class EllipseEffect : public GrFragmentProcessor {
 public:
-    static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkPoint& center, SkScalar rx,
-                                       SkScalar ry);
+    static sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkPoint& center,
+                                           SkScalar rx, SkScalar ry);
 
     virtual ~EllipseEffect() {};
 
@@ -215,12 +216,12 @@
     typedef GrFragmentProcessor INHERITED;
 };
 
-GrFragmentProcessor* EllipseEffect::Create(GrPrimitiveEdgeType edgeType,
-                                           const SkPoint& center,
-                                           SkScalar rx,
-                                           SkScalar ry) {
+sk_sp<GrFragmentProcessor> EllipseEffect::Make(GrPrimitiveEdgeType edgeType,
+                                               const SkPoint& center,
+                                               SkScalar rx,
+                                               SkScalar ry) {
     SkASSERT(rx >= 0 && ry >= 0);
-    return new EllipseEffect(edgeType, center, rx, ry);
+    return sk_sp<GrFragmentProcessor>(new EllipseEffect(edgeType, center, rx, ry));
 }
 
 void EllipseEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
@@ -244,7 +245,7 @@
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(EllipseEffect);
 
-const GrFragmentProcessor* EllipseEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> EllipseEffect::TestCreate(GrProcessorTestData* d) {
     SkPoint center;
     center.fX = d->fRandom->nextRangeScalar(0.f, 1000.f);
     center.fY = d->fRandom->nextRangeScalar(0.f, 1000.f);
@@ -254,7 +255,7 @@
     do {
         et = (GrPrimitiveEdgeType)d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt);
     } while (kHairlineAA_GrProcessorEdgeType == et);
-    return EllipseEffect::Create(et, center, rx, ry);
+    return EllipseEffect::Make(et, center, rx, ry);
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -391,7 +392,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-GrFragmentProcessor* GrOvalEffect::Create(GrPrimitiveEdgeType edgeType, const SkRect& oval) {
+sk_sp<GrFragmentProcessor> GrOvalEffect::Make(GrPrimitiveEdgeType edgeType, const SkRect& oval) {
     if (kHairlineAA_GrProcessorEdgeType == edgeType) {
         return nullptr;
     }
@@ -399,11 +400,11 @@
     SkScalar h = oval.height();
     if (SkScalarNearlyEqual(w, h)) {
         w /= 2;
-        return CircleEffect::Create(edgeType, SkPoint::Make(oval.fLeft + w, oval.fTop + w), w);
+        return CircleEffect::Make(edgeType, SkPoint::Make(oval.fLeft + w, oval.fTop + w), w);
     } else {
         w /= 2;
         h /= 2;
-        return EllipseEffect::Create(edgeType, SkPoint::Make(oval.fLeft + w, oval.fTop + h), w, h);
+        return EllipseEffect::Make(edgeType, SkPoint::Make(oval.fLeft + w, oval.fTop + h), w, h);
     }
 
     return nullptr;
diff --git a/src/gpu/effects/GrOvalEffect.h b/src/gpu/effects/GrOvalEffect.h
index 8f85365..3ff241a 100644
--- a/src/gpu/effects/GrOvalEffect.h
+++ b/src/gpu/effects/GrOvalEffect.h
@@ -10,6 +10,7 @@
 
 #include "GrTypes.h"
 #include "GrTypesPriv.h"
+#include "SkRefCnt.h"
 
 class GrFragmentProcessor;
 struct SkRect;
@@ -18,7 +19,7 @@
     /**
      * Creates an effect that performs clipping against an oval.
      */
-    GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkRect&);
+    sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkRect&);
 };
 
 #endif
diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.cpp b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
index 8168de6..9aae026 100644
--- a/src/gpu/effects/GrPorterDuffXferProcessor.cpp
+++ b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
@@ -704,7 +704,7 @@
     this->initClassID<GrPorterDuffXPFactory>();
 }
 
-GrXPFactory* GrPorterDuffXPFactory::Create(SkXfermode::Mode xfermode) {
+sk_sp<GrXPFactory> GrPorterDuffXPFactory::Make(SkXfermode::Mode xfermode) {
     static GrPorterDuffXPFactory gClearPDXPF(SkXfermode::kClear_Mode);
     static GrPorterDuffXPFactory gSrcPDXPF(SkXfermode::kSrc_Mode);
     static GrPorterDuffXPFactory gDstPDXPF(SkXfermode::kDst_Mode);
@@ -731,7 +731,7 @@
     if (xfermode < 0 || xfermode > SkXfermode::kLastCoeffMode) {
         return nullptr;
     }
-    return SkRef(gFactories[xfermode]);
+    return sk_sp<GrXPFactory>(SkRef(gFactories[xfermode]));
 }
 
 GrXferProcessor*
@@ -826,9 +826,9 @@
 
 GR_DEFINE_XP_FACTORY_TEST(GrPorterDuffXPFactory);
 
-const GrXPFactory* GrPorterDuffXPFactory::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrXPFactory> GrPorterDuffXPFactory::TestCreate(GrProcessorTestData* d) {
     SkXfermode::Mode mode = SkXfermode::Mode(d->fRandom->nextULessThan(SkXfermode::kLastCoeffMode));
-    return GrPorterDuffXPFactory::Create(mode);
+    return GrPorterDuffXPFactory::Make(mode);
 }
 
 void GrPorterDuffXPFactory::TestGetXPOutputTypes(const GrXferProcessor* xp,
diff --git a/src/gpu/effects/GrRRectEffect.cpp b/src/gpu/effects/GrRRectEffect.cpp
index d1d811d..14d03dd 100644
--- a/src/gpu/effects/GrRRectEffect.cpp
+++ b/src/gpu/effects/GrRRectEffect.cpp
@@ -45,8 +45,8 @@
 
     // The flags are used to indicate which corners are circluar (unflagged corners are assumed to
     // be square).
-    static GrFragmentProcessor* Create(GrPrimitiveEdgeType, uint32_t circularCornerFlags,
-                                       const SkRRect&);
+    static sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType, uint32_t circularCornerFlags,
+                                           const SkRRect&);
 
     virtual ~CircularRRectEffect() {};
 
@@ -78,13 +78,14 @@
     typedef GrFragmentProcessor INHERITED;
 };
 
-GrFragmentProcessor* CircularRRectEffect::Create(GrPrimitiveEdgeType edgeType,
-                                                 uint32_t circularCornerFlags,
-                                                 const SkRRect& rrect) {
+sk_sp<GrFragmentProcessor> CircularRRectEffect::Make(GrPrimitiveEdgeType edgeType,
+                                                     uint32_t circularCornerFlags,
+                                                     const SkRRect& rrect) {
     if (kFillAA_GrProcessorEdgeType != edgeType && kInverseFillAA_GrProcessorEdgeType != edgeType) {
         return nullptr;
     }
-    return new CircularRRectEffect(edgeType, circularCornerFlags, rrect);
+    return sk_sp<GrFragmentProcessor>(
+        new CircularRRectEffect(edgeType, circularCornerFlags, rrect));
 }
 
 void CircularRRectEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
@@ -110,17 +111,17 @@
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircularRRectEffect);
 
-const GrFragmentProcessor* CircularRRectEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> CircularRRectEffect::TestCreate(GrProcessorTestData* d) {
     SkScalar w = d->fRandom->nextRangeScalar(20.f, 1000.f);
     SkScalar h = d->fRandom->nextRangeScalar(20.f, 1000.f);
     SkScalar r = d->fRandom->nextRangeF(kRadiusMin, 9.f);
     SkRRect rrect;
     rrect.setRectXY(SkRect::MakeWH(w, h), r, r);
-    GrFragmentProcessor* fp;
+    sk_sp<GrFragmentProcessor> fp;
     do {
         GrPrimitiveEdgeType et =
                 (GrPrimitiveEdgeType)d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt);
-        fp = GrRRectEffect::Create(et, rrect);
+        fp = GrRRectEffect::Make(et, rrect);
     } while (nullptr == fp);
     return fp;
 }
@@ -387,7 +388,7 @@
 
 class EllipticalRRectEffect : public GrFragmentProcessor {
 public:
-    static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkRRect&);
+    static sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkRRect&);
 
     virtual ~EllipticalRRectEffect() {};
 
@@ -416,12 +417,12 @@
     typedef GrFragmentProcessor INHERITED;
 };
 
-GrFragmentProcessor*
-EllipticalRRectEffect::Create(GrPrimitiveEdgeType edgeType, const SkRRect& rrect) {
+sk_sp<GrFragmentProcessor>
+EllipticalRRectEffect::Make(GrPrimitiveEdgeType edgeType, const SkRRect& rrect) {
     if (kFillAA_GrProcessorEdgeType != edgeType && kInverseFillAA_GrProcessorEdgeType != edgeType) {
         return nullptr;
     }
-    return new EllipticalRRectEffect(edgeType, rrect);
+    return sk_sp<GrFragmentProcessor>(new EllipticalRRectEffect(edgeType, rrect));
 }
 
 void EllipticalRRectEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
@@ -444,7 +445,7 @@
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(EllipticalRRectEffect);
 
-const GrFragmentProcessor* EllipticalRRectEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> EllipticalRRectEffect::TestCreate(GrProcessorTestData* d) {
     SkScalar w = d->fRandom->nextRangeScalar(20.f, 1000.f);
     SkScalar h = d->fRandom->nextRangeScalar(20.f, 1000.f);
     SkVector r[4];
@@ -471,11 +472,11 @@
         rrect.setRectXY(SkRect::MakeWH(w, h), r[SkRRect::kUpperLeft_Corner].fX,
                                               r[SkRRect::kUpperLeft_Corner].fY);
     }
-    GrFragmentProcessor* fp;
+    sk_sp<GrFragmentProcessor> fp;
     do {
         GrPrimitiveEdgeType et =
                 (GrPrimitiveEdgeType)d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt);
-        fp = GrRRectEffect::Create(et, rrect);
+        fp = GrRRectEffect::Make(et, rrect);
     } while (nullptr == fp);
     return fp;
 }
@@ -680,26 +681,26 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-GrFragmentProcessor* GrRRectEffect::Create(GrPrimitiveEdgeType edgeType, const SkRRect& rrect) {
+sk_sp<GrFragmentProcessor> GrRRectEffect::Make(GrPrimitiveEdgeType edgeType, const SkRRect& rrect) {
     if (rrect.isRect()) {
-        return GrConvexPolyEffect::Create(edgeType, rrect.getBounds());
+        return GrConvexPolyEffect::Make(edgeType, rrect.getBounds());
     }
 
     if (rrect.isOval()) {
-        return GrOvalEffect::Create(edgeType, rrect.getBounds());
+        return GrOvalEffect::Make(edgeType, rrect.getBounds());
     }
 
     if (rrect.isSimple()) {
         if (rrect.getSimpleRadii().fX < kRadiusMin || rrect.getSimpleRadii().fY < kRadiusMin) {
             // In this case the corners are extremely close to rectangular and we collapse the
             // clip to a rectangular clip.
-            return GrConvexPolyEffect::Create(edgeType, rrect.getBounds());
+            return GrConvexPolyEffect::Make(edgeType, rrect.getBounds());
         }
         if (rrect.getSimpleRadii().fX == rrect.getSimpleRadii().fY) {
-            return CircularRRectEffect::Create(edgeType, CircularRRectEffect::kAll_CornerFlags,
+            return CircularRRectEffect::Make(edgeType, CircularRRectEffect::kAll_CornerFlags,
                                                rrect);
         } else {
-            return EllipticalRRectEffect::Create(edgeType, rrect);
+            return EllipticalRRectEffect::Make(edgeType, rrect);
         }
     }
 
@@ -755,10 +756,10 @@
                 if (squashedRadii) {
                     rr.writable()->setRectRadii(rrect.getBounds(), radii);
                 }
-                return CircularRRectEffect::Create(edgeType, cornerFlags, *rr);
+                return CircularRRectEffect::Make(edgeType, cornerFlags, *rr);
             }
             case CircularRRectEffect::kNone_CornerFlags:
-                return GrConvexPolyEffect::Create(edgeType, rrect.getBounds());
+                return GrConvexPolyEffect::Make(edgeType, rrect.getBounds());
             default: {
                 if (squashedRadii) {
                     // If we got here then we squashed some but not all the radii to zero. (If all
@@ -767,7 +768,7 @@
                     return nullptr;
                 }
                 if (rrect.isNinePatch()) {
-                    return EllipticalRRectEffect::Create(edgeType, rrect);
+                    return EllipticalRRectEffect::Make(edgeType, rrect);
                 }
                 return nullptr;
             }
diff --git a/src/gpu/effects/GrRRectEffect.h b/src/gpu/effects/GrRRectEffect.h
index 63e08a4..6ff2cc9 100644
--- a/src/gpu/effects/GrRRectEffect.h
+++ b/src/gpu/effects/GrRRectEffect.h
@@ -10,6 +10,7 @@
 
 #include "GrTypes.h"
 #include "GrTypesPriv.h"
+#include "SkRefCnt.h"
 
 class GrFragmentProcessor;
 class GrProcessor;
@@ -20,7 +21,7 @@
      * Creates an effect that performs anti-aliased clipping against a SkRRect. It doesn't support
      * all varieties of SkRRect so the caller must check for a nullptr return.
      */
-    GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkRRect&);
+    sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkRRect&);
 };
 
 #endif
diff --git a/src/gpu/effects/GrSimpleTextureEffect.cpp b/src/gpu/effects/GrSimpleTextureEffect.cpp
index f4cbd06..7e7b828 100644
--- a/src/gpu/effects/GrSimpleTextureEffect.cpp
+++ b/src/gpu/effects/GrSimpleTextureEffect.cpp
@@ -46,7 +46,7 @@
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSimpleTextureEffect);
 
-const GrFragmentProcessor* GrSimpleTextureEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> GrSimpleTextureEffect::TestCreate(GrProcessorTestData* d) {
     int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
                                           GrProcessorUnitTest::kAlphaTextureIdx;
     static const SkShader::TileMode kTileModes[] = {
@@ -68,5 +68,5 @@
     GrCoordSet coordSet = kCoordSets[d->fRandom->nextULessThan(SK_ARRAY_COUNT(kCoordSets))];
 
     const SkMatrix& matrix = GrTest::TestMatrix(d->fRandom);
-    return GrSimpleTextureEffect::Create(d->fTextures[texIdx], matrix, coordSet);
+    return GrSimpleTextureEffect::Make(d->fTextures[texIdx], matrix, coordSet);
 }
diff --git a/src/gpu/effects/GrSimpleTextureEffect.h b/src/gpu/effects/GrSimpleTextureEffect.h
index 18a8a78..08eb8c1 100644
--- a/src/gpu/effects/GrSimpleTextureEffect.h
+++ b/src/gpu/effects/GrSimpleTextureEffect.h
@@ -21,25 +21,27 @@
 class GrSimpleTextureEffect : public GrSingleTextureEffect {
 public:
     /* unfiltered, clamp mode */
-    static const GrFragmentProcessor* Create(GrTexture* tex,
-                                             const SkMatrix& matrix,
-                                             GrCoordSet coordSet = kLocal_GrCoordSet) {
-        return new GrSimpleTextureEffect(tex, matrix, GrTextureParams::kNone_FilterMode, coordSet);
+    static sk_sp<GrFragmentProcessor> Make(GrTexture* tex,
+                                           const SkMatrix& matrix,
+                                           GrCoordSet coordSet = kLocal_GrCoordSet) {
+        return sk_sp<GrFragmentProcessor>(
+            new GrSimpleTextureEffect(tex, matrix, GrTextureParams::kNone_FilterMode, coordSet));
     }
 
     /* clamp mode */
-    static GrFragmentProcessor* Create(GrTexture* tex,
-                                       const SkMatrix& matrix,
-                                       GrTextureParams::FilterMode filterMode,
-                                       GrCoordSet coordSet = kLocal_GrCoordSet) {
-        return new GrSimpleTextureEffect(tex, matrix, filterMode, coordSet);
+    static sk_sp<GrFragmentProcessor> Make(GrTexture* tex,
+                                            const SkMatrix& matrix,
+                                            GrTextureParams::FilterMode filterMode,
+                                            GrCoordSet coordSet = kLocal_GrCoordSet) {
+        return sk_sp<GrFragmentProcessor>(
+            new GrSimpleTextureEffect(tex, matrix, filterMode, coordSet));
     }
 
-    static GrFragmentProcessor* Create(GrTexture* tex,
-                                       const SkMatrix& matrix,
-                                       const GrTextureParams& p,
-                                       GrCoordSet coordSet = kLocal_GrCoordSet) {
-        return new GrSimpleTextureEffect(tex, matrix, p, coordSet);
+    static sk_sp<GrFragmentProcessor> Make(GrTexture* tex,
+                                           const SkMatrix& matrix,
+                                           const GrTextureParams& p,
+                                           GrCoordSet coordSet = kLocal_GrCoordSet) {
+        return sk_sp<GrFragmentProcessor>(new GrSimpleTextureEffect(tex, matrix, p, coordSet));
     }
 
     virtual ~GrSimpleTextureEffect() {}
diff --git a/src/gpu/effects/GrTextureDomain.cpp b/src/gpu/effects/GrTextureDomain.cpp
index cf6ebe5..3fbf000 100644
--- a/src/gpu/effects/GrTextureDomain.cpp
+++ b/src/gpu/effects/GrTextureDomain.cpp
@@ -218,18 +218,19 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-const GrFragmentProcessor* GrTextureDomainEffect::Create(GrTexture* texture,
-                                                         const SkMatrix& matrix,
-                                                         const SkRect& domain,
-                                                         GrTextureDomain::Mode mode,
-                                                         GrTextureParams::FilterMode filterMode,
-                                                         GrCoordSet coordSet) {
+sk_sp<GrFragmentProcessor> GrTextureDomainEffect::Make(GrTexture* texture,
+                                                       const SkMatrix& matrix,
+                                                       const SkRect& domain,
+                                                       GrTextureDomain::Mode mode,
+                                                       GrTextureParams::FilterMode filterMode,
+                                                       GrCoordSet coordSet) {
     static const SkRect kFullRect = {0, 0, SK_Scalar1, SK_Scalar1};
     if (GrTextureDomain::kIgnore_Mode == mode ||
         (GrTextureDomain::kClamp_Mode == mode && domain.contains(kFullRect))) {
-        return GrSimpleTextureEffect::Create(texture, matrix, filterMode);
+        return GrSimpleTextureEffect::Make(texture, matrix, filterMode);
     } else {
-        return new GrTextureDomainEffect(texture, matrix, domain, mode, filterMode, coordSet);
+        return sk_sp<GrFragmentProcessor>(
+            new GrTextureDomainEffect(texture, matrix, domain, mode, filterMode, coordSet));
     }
 }
 
@@ -278,7 +279,7 @@
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrTextureDomainEffect);
 
-const GrFragmentProcessor* GrTextureDomainEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> GrTextureDomainEffect::TestCreate(GrProcessorTestData* d) {
     int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
                                           GrProcessorUnitTest::kAlphaTextureIdx;
     SkRect domain;
@@ -291,7 +292,7 @@
     const SkMatrix& matrix = GrTest::TestMatrix(d->fRandom);
     bool bilerp = mode != GrTextureDomain::kRepeat_Mode ? d->fRandom->nextBool() : false;
     GrCoordSet coords = d->fRandom->nextBool() ? kLocal_GrCoordSet : kDevice_GrCoordSet;
-    return GrTextureDomainEffect::Create(
+    return GrTextureDomainEffect::Make(
         d->fTextures[texIdx],
         matrix,
         domain,
diff --git a/src/gpu/effects/GrTextureDomain.h b/src/gpu/effects/GrTextureDomain.h
index 387016e..a86ce95 100644
--- a/src/gpu/effects/GrTextureDomain.h
+++ b/src/gpu/effects/GrTextureDomain.h
@@ -166,12 +166,12 @@
 class GrTextureDomainEffect : public GrSingleTextureEffect {
 
 public:
-    static const GrFragmentProcessor* Create(GrTexture*,
-                                             const SkMatrix&,
-                                             const SkRect& domain,
-                                             GrTextureDomain::Mode,
-                                             GrTextureParams::FilterMode filterMode,
-                                             GrCoordSet = kLocal_GrCoordSet);
+    static sk_sp<GrFragmentProcessor> Make(GrTexture*,
+                                           const SkMatrix&,
+                                           const SkRect& domain,
+                                           GrTextureDomain::Mode,
+                                           GrTextureParams::FilterMode filterMode,
+                                           GrCoordSet = kLocal_GrCoordSet);
 
     virtual ~GrTextureDomainEffect();
 
diff --git a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
index a881999..051061f 100644
--- a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
+++ b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
@@ -17,12 +17,12 @@
 
 class ComposeTwoFragmentProcessor : public GrFragmentProcessor {
 public:
-    ComposeTwoFragmentProcessor(const GrFragmentProcessor* src, const GrFragmentProcessor* dst,
-                    SkXfermode::Mode mode)
+    ComposeTwoFragmentProcessor(sk_sp<GrFragmentProcessor> src, sk_sp<GrFragmentProcessor> dst,
+                                SkXfermode::Mode mode)
         : fMode(mode) {
         this->initClassID<ComposeTwoFragmentProcessor>();
-        SkDEBUGCODE(int shaderAChildIndex = )this->registerChildProcessor(src);
-        SkDEBUGCODE(int shaderBChildIndex = )this->registerChildProcessor(dst);
+        SkDEBUGCODE(int shaderAChildIndex = )this->registerChildProcessor(std::move(src));
+        SkDEBUGCODE(int shaderBChildIndex = )this->registerChildProcessor(std::move(dst));
         SkASSERT(0 == shaderAChildIndex);
         SkASSERT(1 == shaderBChildIndex);
     }
@@ -69,14 +69,15 @@
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ComposeTwoFragmentProcessor);
 
-const GrFragmentProcessor* ComposeTwoFragmentProcessor::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> ComposeTwoFragmentProcessor::TestCreate(GrProcessorTestData* d) {
     // Create two random frag procs.
-    SkAutoTUnref<const GrFragmentProcessor> fpA(GrProcessorUnitTest::CreateChildFP(d));
-    SkAutoTUnref<const GrFragmentProcessor> fpB(GrProcessorUnitTest::CreateChildFP(d));
+    sk_sp<GrFragmentProcessor> fpA(GrProcessorUnitTest::MakeChildFP(d));
+    sk_sp<GrFragmentProcessor> fpB(GrProcessorUnitTest::MakeChildFP(d));
 
     SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(
         d->fRandom->nextRangeU(0, SkXfermode::kLastMode));
-    return new ComposeTwoFragmentProcessor(fpA, fpB, mode);
+    return sk_sp<GrFragmentProcessor>(
+        new ComposeTwoFragmentProcessor(std::move(fpA), std::move(fpB), mode));
 }
 
 GrGLSLFragmentProcessor* ComposeTwoFragmentProcessor::onCreateGLSLInstance() const{
@@ -118,18 +119,19 @@
     }
 }
 
-const GrFragmentProcessor* GrXfermodeFragmentProcessor::CreateFromTwoProcessors(
-         const GrFragmentProcessor* src, const GrFragmentProcessor* dst, SkXfermode::Mode mode) {
+sk_sp<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromTwoProcessors(
+         sk_sp<GrFragmentProcessor> src, sk_sp<GrFragmentProcessor> dst, SkXfermode::Mode mode) {
     switch (mode) {
         case SkXfermode::kClear_Mode:
-            return GrConstColorProcessor::Create(GrColor_TRANSPARENT_BLACK,
-                                                 GrConstColorProcessor::kIgnore_InputMode);
+            return GrConstColorProcessor::Make(GrColor_TRANSPARENT_BLACK,
+                                               GrConstColorProcessor::kIgnore_InputMode);
         case SkXfermode::kSrc_Mode:
-            return SkRef(src);
+            return src;
         case SkXfermode::kDst_Mode:
-            return SkRef(dst);
+            return dst;
         default:
-            return new ComposeTwoFragmentProcessor(src, dst, mode);
+            return sk_sp<GrFragmentProcessor>(
+                new ComposeTwoFragmentProcessor(std::move(src), std::move(dst), mode));
     }
 }
 
@@ -142,11 +144,11 @@
         kSrc_Child,
     };
 
-    ComposeOneFragmentProcessor(const GrFragmentProcessor* dst, SkXfermode::Mode mode, Child child)
+    ComposeOneFragmentProcessor(sk_sp<GrFragmentProcessor> dst, SkXfermode::Mode mode, Child child)
         : fMode(mode)
         , fChild(child) {
         this->initClassID<ComposeOneFragmentProcessor>();
-        SkDEBUGCODE(int dstIndex = )this->registerChildProcessor(dst);
+        SkDEBUGCODE(int dstIndex = )this->registerChildProcessor(std::move(dst));
         SkASSERT(0 == dstIndex);
     }
 
@@ -260,17 +262,17 @@
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ComposeOneFragmentProcessor);
 
-const GrFragmentProcessor* ComposeOneFragmentProcessor::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> ComposeOneFragmentProcessor::TestCreate(GrProcessorTestData* d) {
     // Create one random frag procs.
     // For now, we'll prevent either children from being a shader with children to prevent the
     // possibility of an arbitrarily large tree of procs.
-    SkAutoTUnref<const GrFragmentProcessor> dst(GrProcessorUnitTest::CreateChildFP(d));
+    sk_sp<GrFragmentProcessor> dst(GrProcessorUnitTest::MakeChildFP(d));
     SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(
         d->fRandom->nextRangeU(0, SkXfermode::kLastMode));
     ComposeOneFragmentProcessor::Child child = d->fRandom->nextBool() ?
         ComposeOneFragmentProcessor::kDst_Child :
         ComposeOneFragmentProcessor::kSrc_Child;
-    return new ComposeOneFragmentProcessor(dst, mode, child);
+    return sk_sp<GrFragmentProcessor>(new ComposeOneFragmentProcessor(std::move(dst), mode, child));
 }
 
 GrGLSLFragmentProcessor* ComposeOneFragmentProcessor::onCreateGLSLInstance() const {
@@ -279,30 +281,32 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-const GrFragmentProcessor* GrXfermodeFragmentProcessor::CreateFromDstProcessor(
-    const GrFragmentProcessor* dst, SkXfermode::Mode mode) {
+sk_sp<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromDstProcessor(
+    sk_sp<GrFragmentProcessor> dst, SkXfermode::Mode mode) {
     switch (mode) {
         case SkXfermode::kClear_Mode:
-            return GrConstColorProcessor::Create(GrColor_TRANSPARENT_BLACK,
+            return GrConstColorProcessor::Make(GrColor_TRANSPARENT_BLACK,
                                                  GrConstColorProcessor::kIgnore_InputMode);
         case SkXfermode::kSrc_Mode:
             return nullptr;
         default:
-            return new ComposeOneFragmentProcessor(dst, mode,
-                                                   ComposeOneFragmentProcessor::kDst_Child);
+            return sk_sp<GrFragmentProcessor>(
+                new ComposeOneFragmentProcessor(std::move(dst), mode,
+                                                ComposeOneFragmentProcessor::kDst_Child));
     }
 }
 
-const GrFragmentProcessor* GrXfermodeFragmentProcessor::CreateFromSrcProcessor(
-    const GrFragmentProcessor* src, SkXfermode::Mode mode) {
+sk_sp<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromSrcProcessor(
+    sk_sp<GrFragmentProcessor> src, SkXfermode::Mode mode) {
     switch (mode) {
         case SkXfermode::kClear_Mode:
-            return GrConstColorProcessor::Create(GrColor_TRANSPARENT_BLACK,
+            return GrConstColorProcessor::Make(GrColor_TRANSPARENT_BLACK,
                                                  GrConstColorProcessor::kIgnore_InputMode);
         case SkXfermode::kDst_Mode:
             return nullptr;
         default:
-            return new ComposeOneFragmentProcessor(src, mode,
-                                                   ComposeOneFragmentProcessor::kSrc_Child);
+            return sk_sp<GrFragmentProcessor>(
+                new ComposeOneFragmentProcessor(src, mode,
+                                                ComposeOneFragmentProcessor::kSrc_Child));
     }
 }
diff --git a/src/gpu/effects/GrYUVEffect.cpp b/src/gpu/effects/GrYUVEffect.cpp
index 97ef663..94dca84 100644
--- a/src/gpu/effects/GrYUVEffect.cpp
+++ b/src/gpu/effects/GrYUVEffect.cpp
@@ -62,9 +62,9 @@
 
 class YUVtoRGBEffect : public GrFragmentProcessor {
 public:
-    static GrFragmentProcessor* Create(GrTexture* yTexture, GrTexture* uTexture,
-                                       GrTexture* vTexture, const SkISize sizes[3],
-                                       SkYUVColorSpace colorSpace) {
+    static sk_sp<GrFragmentProcessor> Make(GrTexture* yTexture, GrTexture* uTexture,
+                                           GrTexture* vTexture, const SkISize sizes[3],
+                                           SkYUVColorSpace colorSpace) {
         SkScalar w[3], h[3];
         w[0] = SkIntToScalar(sizes[0].fWidth)  / SkIntToScalar(yTexture->width());
         h[0] = SkIntToScalar(sizes[0].fHeight) / SkIntToScalar(yTexture->height());
@@ -85,8 +85,8 @@
              (sizes[2].fHeight != sizes[0].fHeight)) ?
             GrTextureParams::kBilerp_FilterMode :
             GrTextureParams::kNone_FilterMode;
-        return new YUVtoRGBEffect(yTexture, uTexture, vTexture, yuvMatrix, uvFilterMode,
-                                  colorSpace);
+        return sk_sp<GrFragmentProcessor>(
+            new YUVtoRGBEffect(yTexture, uTexture, vTexture, yuvMatrix, uvFilterMode, colorSpace));
     }
 
     const char* name() const override { return "YUV to RGB"; }
@@ -206,12 +206,12 @@
         kV_OutputChannels
     };
 
-    RGBToYUVEffect(const GrFragmentProcessor* rgbFP, SkYUVColorSpace colorSpace,
+    RGBToYUVEffect(sk_sp<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace,
                    OutputChannels output)
         : fColorSpace(colorSpace)
         , fOutputChannels(output) {
         this->initClassID<RGBToYUVEffect>();
-        this->registerChildProcessor(rgbFP);
+        this->registerChildProcessor(std::move(rgbFP));
     }
 
     const char* name() const override { return "RGBToYUV"; }
@@ -350,39 +350,44 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-const GrFragmentProcessor*
-GrYUVEffect::CreateYUVToRGB(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture,
+sk_sp<GrFragmentProcessor>
+GrYUVEffect::MakeYUVToRGB(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture,
                             const SkISize sizes[3], SkYUVColorSpace colorSpace) {
     SkASSERT(yTexture && uTexture && vTexture && sizes);
-    return YUVtoRGBEffect::Create(yTexture, uTexture, vTexture, sizes, colorSpace);
+    return YUVtoRGBEffect::Make(yTexture, uTexture, vTexture, sizes, colorSpace);
 }
 
-const GrFragmentProcessor*
-GrYUVEffect::CreateRGBToYUV(const GrFragmentProcessor* rgbFP, SkYUVColorSpace colorSpace) {
+sk_sp<GrFragmentProcessor>
+GrYUVEffect::MakeRGBToYUV(sk_sp<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
     SkASSERT(rgbFP);
-    return new RGBToYUVEffect(rgbFP, colorSpace, RGBToYUVEffect::kYUV_OutputChannels);
+    return sk_sp<GrFragmentProcessor>(
+        new RGBToYUVEffect(std::move(rgbFP), colorSpace, RGBToYUVEffect::kYUV_OutputChannels));
 }
 
-const GrFragmentProcessor*
-GrYUVEffect::CreateRGBToY(const GrFragmentProcessor* rgbFP, SkYUVColorSpace colorSpace) {
+sk_sp<GrFragmentProcessor>
+GrYUVEffect::MakeRGBToY(sk_sp<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
     SkASSERT(rgbFP);
-    return new RGBToYUVEffect(rgbFP, colorSpace, RGBToYUVEffect::kY_OutputChannels);
+    return sk_sp<GrFragmentProcessor>(
+        new RGBToYUVEffect(std::move(rgbFP), colorSpace, RGBToYUVEffect::kY_OutputChannels));
 }
 
-const GrFragmentProcessor*
-GrYUVEffect::CreateRGBToUV(const GrFragmentProcessor* rgbFP, SkYUVColorSpace colorSpace) {
+sk_sp<GrFragmentProcessor>
+GrYUVEffect::MakeRGBToUV(sk_sp<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
     SkASSERT(rgbFP);
-    return new RGBToYUVEffect(rgbFP, colorSpace, RGBToYUVEffect::kUV_OutputChannels);
+    return sk_sp<GrFragmentProcessor>(
+        new RGBToYUVEffect(std::move(rgbFP), colorSpace, RGBToYUVEffect::kUV_OutputChannels));
 }
 
-const GrFragmentProcessor*
-GrYUVEffect::CreateRGBToU(const GrFragmentProcessor* rgbFP, SkYUVColorSpace colorSpace) {
+sk_sp<GrFragmentProcessor>
+GrYUVEffect::MakeRGBToU(sk_sp<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
     SkASSERT(rgbFP);
-    return new RGBToYUVEffect(rgbFP, colorSpace, RGBToYUVEffect::kU_OutputChannels);
+    return sk_sp<GrFragmentProcessor>(
+        new RGBToYUVEffect(std::move(rgbFP), colorSpace, RGBToYUVEffect::kU_OutputChannels));
 }
 
-const GrFragmentProcessor*
-GrYUVEffect::CreateRGBToV(const GrFragmentProcessor* rgbFP, SkYUVColorSpace colorSpace) {
+sk_sp<GrFragmentProcessor>
+GrYUVEffect::MakeRGBToV(sk_sp<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
     SkASSERT(rgbFP);
-    return new RGBToYUVEffect(rgbFP, colorSpace, RGBToYUVEffect::kV_OutputChannels);
+    return sk_sp<GrFragmentProcessor>(
+        new RGBToYUVEffect(std::move(rgbFP), colorSpace, RGBToYUVEffect::kV_OutputChannels));
 }
diff --git a/src/gpu/effects/GrYUVEffect.h b/src/gpu/effects/GrYUVEffect.h
index 4f3848e..6d3b158 100644
--- a/src/gpu/effects/GrYUVEffect.h
+++ b/src/gpu/effects/GrYUVEffect.h
@@ -18,33 +18,33 @@
      * Creates an effect that performs color conversion from YUV to RGB. The input textures are
      * assumed to be kA8_GrPixelConfig.
      */
-    const GrFragmentProcessor* CreateYUVToRGB(GrTexture* yTexture, GrTexture* uTexture,
-                                              GrTexture* vTexture, const SkISize sizes[3],
-                                              SkYUVColorSpace colorSpace);
+    sk_sp<GrFragmentProcessor> MakeYUVToRGB(GrTexture* yTexture, GrTexture* uTexture,
+                                            GrTexture* vTexture, const SkISize sizes[3],
+                                            SkYUVColorSpace colorSpace);
 
     /**
      * Creates a processor that performs color conversion from the passed in processor's RGB
      * channels to Y, U ,and V channels. The output color is (y, u, v, a) where a is the passed in
      * processor's alpha output.
      */
-    const GrFragmentProcessor* CreateRGBToYUV(const GrFragmentProcessor*,
-                                              SkYUVColorSpace colorSpace);
+    sk_sp<GrFragmentProcessor> MakeRGBToYUV(sk_sp<GrFragmentProcessor>,
+                                            SkYUVColorSpace colorSpace);
 
     /**
      * Creates a processor that performs color conversion from the passed in processor's RGB
      * channels to U and V channels. The output color is (u, v, 0, a) where a is the passed in
      * processor's alpha output.
      */
-    const GrFragmentProcessor* CreateRGBToUV(const GrFragmentProcessor*,
-                                             SkYUVColorSpace colorSpace);
+    sk_sp<GrFragmentProcessor> MakeRGBToUV(sk_sp<GrFragmentProcessor>,
+                                           SkYUVColorSpace colorSpace);
     /**
      * Creates a processor that performs color conversion from the passed in fragment processors's
      * RGB channels to Y, U, or V (replicated across all four output color channels). The alpha
      * output of the passed in fragment processor is ignored.
      */
-    const GrFragmentProcessor* CreateRGBToY(const GrFragmentProcessor*, SkYUVColorSpace colorSpace);
-    const GrFragmentProcessor* CreateRGBToU(const GrFragmentProcessor*, SkYUVColorSpace colorSpace);
-    const GrFragmentProcessor* CreateRGBToV(const GrFragmentProcessor*, SkYUVColorSpace colorSpace);
+    sk_sp<GrFragmentProcessor> MakeRGBToY(sk_sp<GrFragmentProcessor>, SkYUVColorSpace colorSpace);
+    sk_sp<GrFragmentProcessor> MakeRGBToU(sk_sp<GrFragmentProcessor>, SkYUVColorSpace colorSpace);
+    sk_sp<GrFragmentProcessor> MakeRGBToV(sk_sp<GrFragmentProcessor>, SkYUVColorSpace colorSpace);
 };
 
 #endif