change flattenable factory to return sk_sp

BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1855733002

Review URL: https://codereview.chromium.org/1855733002

75 files changed, 189 insertions, 194 deletions

diff --git a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
index f6885408ad..09762b3326 100644
--- a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
+++ b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
@@ -352,7 +352,7 @@ SkPerlinNoiseShader2::SkPerlinNoiseShader2(SkPerlinNoiseShader2::Type type,
 SkPerlinNoiseShader2::~SkPerlinNoiseShader2() {
 }
 
-SkFlattenable* SkPerlinNoiseShader2::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkPerlinNoiseShader2::CreateProc(SkReadBuffer& buffer) {
     Type type = (Type)buffer.readInt();
     SkScalar freqX = buffer.readScalar();
     SkScalar freqY = buffer.readScalar();
@@ -364,13 +364,11 @@ SkFlattenable* SkPerlinNoiseShader2::CreateProc(SkReadBuffer& buffer) {
 
     switch (type) {
         case kFractalNoise_Type:
-            return SkPerlinNoiseShader2::MakeFractalNoise(freqX, freqY, octaves, seed,
-                                                          &tileSize).release();
+            return SkPerlinNoiseShader2::MakeFractalNoise(freqX, freqY, octaves, seed, &tileSize);
         case kTurbulence_Type:
-            return SkPerlinNoiseShader2::MakeTubulence(freqX, freqY, octaves, seed,
-                                                       &tileSize).release();
+            return SkPerlinNoiseShader2::MakeTubulence(freqX, freqY, octaves, seed, &tileSize);
         case kImprovedNoise_Type:
-            return SkPerlinNoiseShader2::MakeImprovedNoise(freqX, freqY, octaves, seed).release();
+            return SkPerlinNoiseShader2::MakeImprovedNoise(freqX, freqY, octaves, seed);
         default:
             return nullptr;
     }
diff --git a/gm/dcshader.cpp b/gm/dcshader.cpp
index 487f7671ee..e402fc0c2b 100644
--- a/gm/dcshader.cpp
+++ b/gm/dcshader.cpp
@@ -50,10 +50,10 @@ private:
     const SkMatrix fDeviceMatrix;
 };
 
-SkFlattenable* DCShader::CreateProc(SkReadBuffer& buf) {
+sk_sp<SkFlattenable> DCShader::CreateProc(SkReadBuffer& buf) {
     SkMatrix matrix;
     buf.readMatrix(&matrix);
-    return new DCShader(matrix);
+    return sk_make_sp<DCShader>(matrix);
 }
 
 class DCFP : public GrFragmentProcessor {
diff --git a/gm/imagefiltersbase.cpp b/gm/imagefiltersbase.cpp
index 4a5f5e5977..3c1cf0991c 100644
--- a/gm/imagefiltersbase.cpp
+++ b/gm/imagefiltersbase.cpp
@@ -45,9 +45,9 @@ private:
 
 static FailImageFilter::Registrar gReg0;
 
-SkFlattenable* FailImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> FailImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 0);
-    return FailImageFilter::Create();
+    return sk_sp<SkFlattenable>(FailImageFilter::Create());
 }
 
 #ifndef SK_IGNORE_TO_STRING
@@ -89,9 +89,9 @@ private:
 
 static IdentityImageFilter::Registrar gReg1;
 
-SkFlattenable* IdentityImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> IdentityImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
-    return IdentityImageFilter::Create(common.getInput(0).get());
+    return sk_sp<SkFlattenable>(IdentityImageFilter::Create(common.getInput(0).get()));
 }
 
 #ifndef SK_IGNORE_TO_STRING
diff --git a/gm/imagefiltersgraph.cpp b/gm/imagefiltersgraph.cpp
index 537287124a..c0c652b46d 100644
--- a/gm/imagefiltersgraph.cpp
+++ b/gm/imagefiltersgraph.cpp
@@ -84,11 +84,11 @@ private:
 
 static SimpleOffsetFilter::Registrar gReg;
 
-SkFlattenable* SimpleOffsetFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SimpleOffsetFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkScalar dx = buffer.readScalar();
     SkScalar dy = buffer.readScalar();
-    return Create(dx, dy, common.getInput(0).get());
+    return sk_sp<SkFlattenable>(Create(dx, dy, common.getInput(0).get()));
 }
 
 #ifndef SK_IGNORE_TO_STRING
diff --git a/include/core/SkFlattenable.h b/include/core/SkFlattenable.h
index 10cba1a2ec..c76f119c13 100644
--- a/include/core/SkFlattenable.h
+++ b/include/core/SkFlattenable.h
@@ -48,7 +48,7 @@ class SkPrivateEffectInitializer;
 
 #define SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(flattenable)    \
     private:                                                                \
-    static SkFlattenable* CreateProc(SkReadBuffer&);                        \
+    static sk_sp<SkFlattenable> CreateProc(SkReadBuffer&);                        \
     friend class SkFlattenable::PrivateInitializer;                         \
     public:                                                                 \
     Factory getFactory() const override { return CreateProc; }
@@ -82,7 +82,7 @@ public:
         kSkXfermode_Type,
     };
 
-    typedef SkFlattenable* (*Factory)(SkReadBuffer&);
+    typedef sk_sp<SkFlattenable> (*Factory)(SkReadBuffer&);
 
     SkFlattenable() {}
 
diff --git a/include/effects/SkLayerDrawLooper.h b/include/effects/SkLayerDrawLooper.h
index 6ddde888eb..186d44a656 100644
--- a/include/effects/SkLayerDrawLooper.h
+++ b/include/effects/SkLayerDrawLooper.h
@@ -80,7 +80,7 @@ public:
     SK_TO_STRING_OVERRIDE()
 
     Factory getFactory() const override { return CreateProc; }
-    static SkFlattenable* CreateProc(SkReadBuffer& buffer);
+    static sk_sp<SkFlattenable> CreateProc(SkReadBuffer& buffer);
 
 protected:
     SkLayerDrawLooper();
diff --git a/samplecode/ClockFaceView.cpp b/samplecode/ClockFaceView.cpp
index a282c317c0..6e2b2b1585 100644
--- a/samplecode/ClockFaceView.cpp
+++ b/samplecode/ClockFaceView.cpp
@@ -101,10 +101,10 @@ private:
     typedef Sk2DPathEffect INHERITED;
 };
 
-SkFlattenable* Dot2DPathEffect::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> Dot2DPathEffect::CreateProc(SkReadBuffer& buffer) {
     SkMatrix matrix;
     buffer.readMatrix(&matrix);
-    return new Dot2DPathEffect(buffer.readScalar(), matrix, nullptr);
+    return sk_make_sp<Dot2DPathEffect>(buffer.readScalar(), matrix, nullptr);
 }
 
 class InverseFillPE : public SkPathEffect {
@@ -129,7 +129,9 @@ private:
     typedef SkPathEffect INHERITED;
 };
 
-SkFlattenable* InverseFillPE::CreateProc(SkReadBuffer& buffer) { return new InverseFillPE; }
+sk_sp<SkFlattenable> InverseFillPE::CreateProc(SkReadBuffer& buffer) {
+    return sk_make_sp<InverseFillPE>();
+}
 
 static sk_sp<SkPathEffect> makepe(float interp, SkTDArray<SkPoint>* pts) {
     SkMatrix    lattice;
diff --git a/src/core/SkBitmapProcShader.cpp b/src/core/SkBitmapProcShader.cpp
index 14114c0893..c9df4ce248 100644
--- a/src/core/SkBitmapProcShader.cpp
+++ b/src/core/SkBitmapProcShader.cpp
@@ -275,7 +275,7 @@ bool SkBitmapProcShader::onIsABitmap(SkBitmap* texture, SkMatrix* texM, TileMode
     return true;
 }
 
-SkFlattenable* SkBitmapProcShader::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkBitmapProcShader::CreateProc(SkReadBuffer& buffer) {
     SkMatrix lm;
     buffer.readMatrix(&lm);
     SkBitmap bm;
@@ -285,7 +285,7 @@ SkFlattenable* SkBitmapProcShader::CreateProc(SkReadBuffer& buffer) {
     bm.setImmutable();
     TileMode mx = (TileMode)buffer.readUInt();
     TileMode my = (TileMode)buffer.readUInt();
-    return SkShader::MakeBitmapShader(bm, mx, my, &lm).release();
+    return SkShader::MakeBitmapShader(bm, mx, my, &lm);
 }
 
 void SkBitmapProcShader::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/core/SkBlitter.cpp b/src/core/SkBlitter.cpp
index d8e81d59b8..8f0031cd46 100644
--- a/src/core/SkBlitter.cpp
+++ b/src/core/SkBlitter.cpp
@@ -730,8 +730,8 @@ private:
     typedef SkShader INHERITED;
 };
 
-SkFlattenable* Sk3DShader::CreateProc(SkReadBuffer& buffer) {
-    return new Sk3DShader(buffer.readShader());
+sk_sp<SkFlattenable> Sk3DShader::CreateProc(SkReadBuffer& buffer) {
+    return sk_make_sp<Sk3DShader>(buffer.readShader());
 }
 
 class Sk3DBlitter : public SkBlitter {
@@ -745,8 +745,7 @@ public:
         fProxy->blitH(x, y, width);
     }
 
-    virtual void blitAntiH(int x, int y, const SkAlpha antialias[],
-                           const int16_t runs[]) override {
+    void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]) override {
         fProxy->blitAntiH(x, y, antialias, runs);
     }
 
diff --git a/src/core/SkColorFilter.cpp b/src/core/SkColorFilter.cpp
index 3e0a2ec46f..e3d8957947 100644
--- a/src/core/SkColorFilter.cpp
+++ b/src/core/SkColorFilter.cpp
@@ -142,10 +142,10 @@ private:
     typedef SkColorFilter INHERITED;
 };
 
-SkFlattenable* SkComposeColorFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkComposeColorFilter::CreateProc(SkReadBuffer& buffer) {
     sk_sp<SkColorFilter> outer(buffer.readColorFilter());
     sk_sp<SkColorFilter> inner(buffer.readColorFilter());
-    return MakeComposeFilter(std::move(outer), std::move(inner)).release();
+    return MakeComposeFilter(std::move(outer), std::move(inner));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/SkColorFilterShader.cpp b/src/core/SkColorFilterShader.cpp
index 8a175024de..500ead4f74 100644
--- a/src/core/SkColorFilterShader.cpp
+++ b/src/core/SkColorFilterShader.cpp
@@ -23,13 +23,13 @@ SkColorFilterShader::SkColorFilterShader(sk_sp<SkShader> shader, sk_sp<SkColorFi
     SkASSERT(fFilter);
 }
 
-SkFlattenable* SkColorFilterShader::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkColorFilterShader::CreateProc(SkReadBuffer& buffer) {
     auto shader = buffer.readShader();
     auto filter = buffer.readColorFilter();
     if (!shader || !filter) {
         return nullptr;
     }
-    return new SkColorFilterShader(shader, filter);
+    return sk_make_sp<SkColorFilterShader>(shader, filter);
 }
 
 void SkColorFilterShader::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/core/SkColorMatrixFilterRowMajor255.cpp b/src/core/SkColorMatrixFilterRowMajor255.cpp
index bd9a66a561..c158a7948f 100644
--- a/src/core/SkColorMatrixFilterRowMajor255.cpp
+++ b/src/core/SkColorMatrixFilterRowMajor255.cpp
@@ -157,10 +157,10 @@ void SkColorMatrixFilterRowMajor255::flatten(SkWriteBuffer& buffer) const {
     buffer.writeScalarArray(fMatrix, 20);
 }
 
-SkFlattenable* SkColorMatrixFilterRowMajor255::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkColorMatrixFilterRowMajor255::CreateProc(SkReadBuffer& buffer) {
     SkScalar matrix[20];
     if (buffer.readScalarArray(matrix, 20)) {
-        return new SkColorMatrixFilterRowMajor255(matrix);
+        return sk_make_sp<SkColorMatrixFilterRowMajor255>(matrix);
     }
     return nullptr;
 }
diff --git a/src/core/SkComposeShader.cpp b/src/core/SkComposeShader.cpp
index f39f20c46c..46b7724944 100644
--- a/src/core/SkComposeShader.cpp
+++ b/src/core/SkComposeShader.cpp
@@ -39,14 +39,14 @@ private:
 };
 #define SkAutoAlphaRestore(...) SK_REQUIRE_LOCAL_VAR(SkAutoAlphaRestore)
 
-SkFlattenable* SkComposeShader::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkComposeShader::CreateProc(SkReadBuffer& buffer) {
     sk_sp<SkShader> shaderA(buffer.readShader());
     sk_sp<SkShader> shaderB(buffer.readShader());
     sk_sp<SkXfermode> mode(buffer.readXfermode());
     if (!shaderA || !shaderB) {
         return nullptr;
     }
-    return new SkComposeShader(std::move(shaderA), std::move(shaderB), std::move(mode));
+    return sk_make_sp<SkComposeShader>(std::move(shaderA), std::move(shaderB), std::move(mode));
 }
 
 void SkComposeShader::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/core/SkLightingShader.cpp b/src/core/SkLightingShader.cpp
index fdd0a04aee..eba7d652eb 100644
--- a/src/core/SkLightingShader.cpp
+++ b/src/core/SkLightingShader.cpp
@@ -552,7 +552,7 @@ void SkLightingShaderImpl::toString(SkString* str) const {
 }
 #endif
 
-SkFlattenable* SkLightingShaderImpl::CreateProc(SkReadBuffer& buf) {
+sk_sp<SkFlattenable> SkLightingShaderImpl::CreateProc(SkReadBuffer& buf) {
     SkMatrix diffLocalM;
     bool hasDiffLocalM = buf.readBool();
     if (hasDiffLocalM) {
@@ -606,8 +606,8 @@ SkFlattenable* SkLightingShaderImpl::CreateProc(SkReadBuffer& buf) {
 
     SkAutoTUnref<const SkLightingShader::Lights> lights(builder.finish());
 
-    return new SkLightingShaderImpl(diffuse, normal, lights, SkVector::Make(1.0f, 0.0f),
-                                    &diffLocalM, &normLocalM);
+    return sk_make_sp<SkLightingShaderImpl>(diffuse, normal, lights, SkVector::Make(1.0f, 0.0f),
+                                            &diffLocalM, &normLocalM);
 }
 
 void SkLightingShaderImpl::flatten(SkWriteBuffer& buf) const {
diff --git a/src/core/SkLocalMatrixImageFilter.cpp b/src/core/SkLocalMatrixImageFilter.cpp
index bf29bd235b..42acee0c22 100644
--- a/src/core/SkLocalMatrixImageFilter.cpp
+++ b/src/core/SkLocalMatrixImageFilter.cpp
@@ -16,11 +16,11 @@ SkLocalMatrixImageFilter::SkLocalMatrixImageFilter(const SkMatrix& localM,
     , fLocalM(localM) {
 }
 
-SkFlattenable* SkLocalMatrixImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkLocalMatrixImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkMatrix lm;
     buffer.readMatrix(&lm);
-    return SkLocalMatrixImageFilter::Make(lm, common.getInput(0)).release();
+    return SkLocalMatrixImageFilter::Make(lm, common.getInput(0));
 }
 
 void SkLocalMatrixImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/core/SkLocalMatrixShader.cpp b/src/core/SkLocalMatrixShader.cpp
index ddd6114ca8..ea4db5352c 100644
--- a/src/core/SkLocalMatrixShader.cpp
+++ b/src/core/SkLocalMatrixShader.cpp
@@ -7,14 +7,14 @@
 
 #include "SkLocalMatrixShader.h"
 
-SkFlattenable* SkLocalMatrixShader::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkLocalMatrixShader::CreateProc(SkReadBuffer& buffer) {
     SkMatrix lm;
     buffer.readMatrix(&lm);
     auto baseShader(buffer.readShader());
     if (!baseShader) {
         return nullptr;
     }
-    return baseShader->makeWithLocalMatrix(lm).release();
+    return baseShader->makeWithLocalMatrix(lm);
 }
 
 void SkLocalMatrixShader::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/core/SkMatrixImageFilter.cpp b/src/core/SkMatrixImageFilter.cpp
index d66772c244..70bc81af43 100644
--- a/src/core/SkMatrixImageFilter.cpp
+++ b/src/core/SkMatrixImageFilter.cpp
@@ -28,12 +28,12 @@ SkMatrixImageFilter* SkMatrixImageFilter::Create(const SkMatrix& transform,
     return new SkMatrixImageFilter(transform, filterQuality, input);
 }
 
-SkFlattenable* SkMatrixImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkMatrixImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkMatrix matrix;
     buffer.readMatrix(&matrix);
     SkFilterQuality quality = static_cast<SkFilterQuality>(buffer.readInt());
-    return Create(matrix, quality, common.getInput(0).get());
+    return sk_sp<SkImageFilter>(Create(matrix, quality, common.getInput(0).get()));
 }
 
 void SkMatrixImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/core/SkModeColorFilter.cpp b/src/core/SkModeColorFilter.cpp
index 84c6491f3a..eacd261b5c 100644
--- a/src/core/SkModeColorFilter.cpp
+++ b/src/core/SkModeColorFilter.cpp
@@ -77,10 +77,10 @@ void SkModeColorFilter::updateCache() {
     fProc = SkXfermode::GetProc(fMode);
 }
 
-SkFlattenable* SkModeColorFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkModeColorFilter::CreateProc(SkReadBuffer& buffer) {
     SkColor color = buffer.readColor();
     SkXfermode::Mode mode = (SkXfermode::Mode)buffer.readUInt();
-    return SkColorFilter::MakeModeFilter(color, mode).release();
+    return SkColorFilter::MakeModeFilter(color, mode);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index e4eca0cf99..d5e4c08c1f 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -1930,11 +1930,11 @@ void SkPaint::unflatten(SkReadBuffer& buffer) {
         this->setPathEffect(buffer.readPathEffect());
         this->setShader(buffer.readShader());
         this->setXfermode(buffer.readXfermode());
-        SkSafeUnref(this->setMaskFilter(buffer.readMaskFilter()));
+        this->setMaskFilter(buffer.readMaskFilter());
         this->setColorFilter(buffer.readColorFilter());
         this->setRasterizer(buffer.readRasterizer());
         this->setLooper(buffer.readDrawLooper());
-        SkSafeUnref(this->setImageFilter(buffer.readImageFilter()));
+        this->setImageFilter(buffer.readImageFilter());
 
         if (buffer.isVersionLT(SkReadBuffer::kAnnotationsMovedToCanvas_Version)) {
             // We used to store annotations here (string+skdata) if this bool was true
diff --git a/src/core/SkPathEffect.cpp b/src/core/SkPathEffect.cpp
index b2e29bc09d..1178348af5 100644
--- a/src/core/SkPathEffect.cpp
+++ b/src/core/SkPathEffect.cpp
@@ -57,10 +57,10 @@ void SkPairPathEffect::toString(SkString* str) const {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkFlattenable* SkComposePathEffect::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkComposePathEffect::CreateProc(SkReadBuffer& buffer) {
     sk_sp<SkPathEffect> pe0(buffer.readPathEffect());
     sk_sp<SkPathEffect> pe1(buffer.readPathEffect());
-    return SkComposePathEffect::Make(std::move(pe0), std::move(pe1)).release();
+    return SkComposePathEffect::Make(std::move(pe0), std::move(pe1));
 }
 
 bool SkComposePathEffect::filterPath(SkPath* dst, const SkPath& src,
@@ -85,10 +85,10 @@ void SkComposePathEffect::toString(SkString* str) const {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkFlattenable* SkSumPathEffect::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkSumPathEffect::CreateProc(SkReadBuffer& buffer) {
     sk_sp<SkPathEffect> pe0(buffer.readPathEffect());
     sk_sp<SkPathEffect> pe1(buffer.readPathEffect());
-    return SkSumPathEffect::Make(pe0, pe1).release();
+    return SkSumPathEffect::Make(pe0, pe1);
 }
 
 bool SkSumPathEffect::filterPath(SkPath* dst, const SkPath& src,
diff --git a/src/core/SkPictureShader.cpp b/src/core/SkPictureShader.cpp
index 76ecfc1570..b6f4d02a55 100644
--- a/src/core/SkPictureShader.cpp
+++ b/src/core/SkPictureShader.cpp
@@ -110,7 +110,7 @@ sk_sp<SkShader> SkPictureShader::Make(sk_sp<SkPicture> picture, TileMode tmx, Ti
     return sk_sp<SkShader>(new SkPictureShader(std::move(picture), tmx, tmy, localMatrix, tile));
 }
 
-SkFlattenable* SkPictureShader::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkPictureShader::CreateProc(SkReadBuffer& buffer) {
     SkMatrix lm;
     buffer.readMatrix(&lm);
     TileMode mx = (TileMode)buffer.read32();
@@ -136,7 +136,7 @@ SkFlattenable* SkPictureShader::CreateProc(SkReadBuffer& buffer) {
             picture = SkPicture::MakeFromBuffer(buffer);
         }
     }
-    return SkPictureShader::Make(picture, mx, my, &lm, &tile).release();
+    return SkPictureShader::Make(picture, mx, my, &lm, &tile);
 }
 
 void SkPictureShader::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/core/SkReadBuffer.cpp b/src/core/SkReadBuffer.cpp
index 2dd9f093ac..f220b5a9e6 100644
--- a/src/core/SkReadBuffer.cpp
+++ b/src/core/SkReadBuffer.cpp
@@ -356,7 +356,7 @@ SkFlattenable* SkReadBuffer::readFlattenable(SkFlattenable::Type ft) {
 
     // if we get here, factory may still be null, but if that is the case, the
     // failure was ours, not the writer.
-    SkFlattenable* obj = nullptr;
+    sk_sp<SkFlattenable> obj;
     uint32_t sizeRecorded = fReader.readU32();
     if (factory) {
         size_t offset = fReader.offset();
@@ -371,7 +371,7 @@ SkFlattenable* SkReadBuffer::readFlattenable(SkFlattenable::Type ft) {
         // we must skip the remaining data
         fReader.skip(sizeRecorded);
     }
-    return obj;
+    return obj.release();
 }
 
 /**
diff --git a/src/core/SkReadBuffer.h b/src/core/SkReadBuffer.h
index a9983989cc..7b12194fc0 100644
--- a/src/core/SkReadBuffer.h
+++ b/src/core/SkReadBuffer.h
@@ -127,27 +127,17 @@ public:
     void readPaint(SkPaint* paint) { paint->unflatten(*this); }
 
     virtual SkFlattenable* readFlattenable(SkFlattenable::Type);
-    template <typename T> T* readFlattenable() {
-        return (T*) this->readFlattenable(T::GetFlattenableType());
-    }
-    sk_sp<SkColorFilter> readColorFilter() {
-        return sk_sp<SkColorFilter>(this->readFlattenable<SkColorFilter>());
-    }
-    sk_sp<SkDrawLooper> readDrawLooper() {
-        return sk_sp<SkDrawLooper>(this->readFlattenable<SkDrawLooper>());
-    }
-    SkImageFilter* readImageFilter() { return this->readFlattenable<SkImageFilter>(); }
-    SkMaskFilter*  readMaskFilter()  { return this->readFlattenable<SkMaskFilter>(); }
-    sk_sp<SkPathEffect> readPathEffect()  {
-        return sk_sp<SkPathEffect>(this->readFlattenable<SkPathEffect>());
-    }
-    sk_sp<SkRasterizer> readRasterizer() {
-        return sk_sp<SkRasterizer>(this->readFlattenable<SkRasterizer>());
-    }
-    sk_sp<SkShader> readShader()     { return sk_sp<SkShader>(this->readFlattenable<SkShader>()); }
-    sk_sp<SkXfermode> readXfermode() {
-        return sk_sp<SkXfermode>(this->readFlattenable<SkXfermode>());
+    template <typename T> sk_sp<T> readFlattenable() {
+        return sk_sp<T>((T*)this->readFlattenable(T::GetFlattenableType()));
     }
+    sk_sp<SkColorFilter> readColorFilter() { return this->readFlattenable<SkColorFilter>(); }
+    sk_sp<SkDrawLooper> readDrawLooper() { return this->readFlattenable<SkDrawLooper>(); }
+    sk_sp<SkImageFilter> readImageFilter() { return this->readFlattenable<SkImageFilter>(); }
+    sk_sp<SkMaskFilter> readMaskFilter() { return this->readFlattenable<SkMaskFilter>(); }
+    sk_sp<SkPathEffect> readPathEffect() { return this->readFlattenable<SkPathEffect>(); }
+    sk_sp<SkRasterizer> readRasterizer() { return this->readFlattenable<SkRasterizer>(); }
+    sk_sp<SkShader> readShader() { return this->readFlattenable<SkShader>(); }
+    sk_sp<SkXfermode> readXfermode() { return this->readFlattenable<SkXfermode>(); }
 
     /**
      *  Like readFlattenable() but explicitly just skips the data that was written for the
diff --git a/src/core/SkShader.cpp b/src/core/SkShader.cpp
index e4cbc7b217..8032cc6e4c 100644
--- a/src/core/SkShader.cpp
+++ b/src/core/SkShader.cpp
@@ -264,8 +264,8 @@ bool SkColorShader::isOpaque() const {
     return SkColorGetA(fColor) == 255;
 }
 
-SkFlattenable* SkColorShader::CreateProc(SkReadBuffer& buffer) {
-    return new SkColorShader(buffer.readColor());
+sk_sp<SkFlattenable> SkColorShader::CreateProc(SkReadBuffer& buffer) {
+    return sk_make_sp<SkColorShader>(buffer.readColor());
 }
 
 void SkColorShader::flatten(SkWriteBuffer& buffer) const {
@@ -419,8 +419,8 @@ bool SkColorShader::ColorShaderContext::onChooseBlitProcs(const SkImageInfo& inf
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkFlattenable* SkEmptyShader::CreateProc(SkReadBuffer&) {
-    return SkShader::MakeEmptyShader().release();
+sk_sp<SkFlattenable> SkEmptyShader::CreateProc(SkReadBuffer&) {
+    return SkShader::MakeEmptyShader();
 }
 
 #ifndef SK_IGNORE_TO_STRING
diff --git a/src/core/SkValidatingReadBuffer.cpp b/src/core/SkValidatingReadBuffer.cpp
index bc5611a3e3..ad4b6c409e 100644
--- a/src/core/SkValidatingReadBuffer.cpp
+++ b/src/core/SkValidatingReadBuffer.cpp
@@ -243,7 +243,7 @@ SkFlattenable* SkValidatingReadBuffer::readFlattenable(SkFlattenable::Type type)
 
     // if we get here, factory may still be null, but if that is the case, the
     // failure was ours, not the writer.
-    SkFlattenable* obj = nullptr;
+    sk_sp<SkFlattenable> obj;
     uint32_t sizeRecorded = this->readUInt();
     if (factory) {
         size_t offset = fReader.offset();
@@ -252,8 +252,6 @@ SkFlattenable* SkValidatingReadBuffer::readFlattenable(SkFlattenable::Type type)
         size_t sizeRead = fReader.offset() - offset;
         this->validate(sizeRecorded == sizeRead);
         if (fError) {
-            // we could try to fix up the offset...
-            SkSafeUnref(obj);
             obj = nullptr;
         }
     } else {
@@ -261,7 +259,7 @@ SkFlattenable* SkValidatingReadBuffer::readFlattenable(SkFlattenable::Type type)
         this->skip(sizeRecorded);
         SkASSERT(false);
     }
-    return obj;
+    return obj.release();
 }
 
 void SkValidatingReadBuffer::skipFlattenable() {
diff --git a/src/core/SkXfermode.cpp b/src/core/SkXfermode.cpp
index 01d6dc53c2..1cfe864751 100644
--- a/src/core/SkXfermode.cpp
+++ b/src/core/SkXfermode.cpp
@@ -1092,12 +1092,12 @@ bool SkXfermode::isOpaque(SkXfermode::SrcColorOpacity opacityType) const {
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-SkFlattenable* SkProcCoeffXfermode::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkProcCoeffXfermode::CreateProc(SkReadBuffer& buffer) {
     uint32_t mode32 = buffer.read32();
     if (!buffer.validate(mode32 < SK_ARRAY_COUNT(gProcCoeffs))) {
         return nullptr;
     }
-    return SkXfermode::Make((SkXfermode::Mode)mode32).release();
+    return SkXfermode::Make((SkXfermode::Mode)mode32);
 }
 
 void SkProcCoeffXfermode::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/Sk1DPathEffect.cpp b/src/effects/Sk1DPathEffect.cpp
index 0d61632175..26cd046aa8 100644
--- a/src/effects/Sk1DPathEffect.cpp
+++ b/src/effects/Sk1DPathEffect.cpp
@@ -145,14 +145,14 @@ SkScalar SkPath1DPathEffect::begin(SkScalar contourLength) const {
     return fInitialOffset;
 }
 
-SkFlattenable* SkPath1DPathEffect::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkPath1DPathEffect::CreateProc(SkReadBuffer& buffer) {
     SkScalar advance = buffer.readScalar();
     if (advance > 0) {
         SkPath path;
         buffer.readPath(&path);
         SkScalar phase = buffer.readScalar();
         Style style = (Style)buffer.readUInt();
-        return SkPath1DPathEffect::Make(path, advance, phase, style).release();
+        return SkPath1DPathEffect::Make(path, advance, phase, style);
     }
     return nullptr;
 }
diff --git a/src/effects/Sk2DPathEffect.cpp b/src/effects/Sk2DPathEffect.cpp
index da43d22487..52e3fa5e1c 100644
--- a/src/effects/Sk2DPathEffect.cpp
+++ b/src/effects/Sk2DPathEffect.cpp
@@ -106,11 +106,11 @@ void SkLine2DPathEffect::nextSpan(int u, int v, int ucount, SkPath* dst) const {
     }
 }
 
-SkFlattenable* SkLine2DPathEffect::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkLine2DPathEffect::CreateProc(SkReadBuffer& buffer) {
     SkMatrix matrix;
     buffer.readMatrix(&matrix);
     SkScalar width = buffer.readScalar();
-    return SkLine2DPathEffect::Make(width, matrix).release();
+    return SkLine2DPathEffect::Make(width, matrix);
 }
 
 void SkLine2DPathEffect::flatten(SkWriteBuffer &buffer) const {
@@ -134,12 +134,12 @@ SkPath2DPathEffect::SkPath2DPathEffect(const SkMatrix& m, const SkPath& p)
     : INHERITED(m), fPath(p) {
 }
 
-SkFlattenable* SkPath2DPathEffect::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkPath2DPathEffect::CreateProc(SkReadBuffer& buffer) {
     SkMatrix matrix;
     buffer.readMatrix(&matrix);
     SkPath path;
     buffer.readPath(&path);
-    return SkPath2DPathEffect::Make(matrix, path).release();
+    return SkPath2DPathEffect::Make(matrix, path);
 }
 
 void SkPath2DPathEffect::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkAlphaThresholdFilter.cpp b/src/effects/SkAlphaThresholdFilter.cpp
index 1c79c45194..5a9ad79a9d 100644
--- a/src/effects/SkAlphaThresholdFilter.cpp
+++ b/src/effects/SkAlphaThresholdFilter.cpp
@@ -265,13 +265,13 @@ void AlphaThresholdEffect::onComputeInvariantOutput(GrInvariantOutput* inout) co
 
 #endif
 
-SkFlattenable* SkAlphaThresholdFilterImpl::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkAlphaThresholdFilterImpl::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkScalar inner = buffer.readScalar();
     SkScalar outer = buffer.readScalar();
     SkRegion rgn;
     buffer.readRegion(&rgn);
-    return SkAlphaThresholdFilter::Make(rgn, inner, outer, common.getInput(0)).release();
+    return SkAlphaThresholdFilter::Make(rgn, inner, outer, common.getInput(0));
 }
 
 SkAlphaThresholdFilterImpl::SkAlphaThresholdFilterImpl(const SkRegion& region,
diff --git a/src/effects/SkArcToPathEffect.cpp b/src/effects/SkArcToPathEffect.cpp
index c660de9db4..a6273db092 100644
--- a/src/effects/SkArcToPathEffect.cpp
+++ b/src/effects/SkArcToPathEffect.cpp
@@ -61,8 +61,8 @@ DONE:
     return true;
 }
 
-SkFlattenable* SkArcToPathEffect::CreateProc(SkReadBuffer& buffer) {
-    return SkArcToPathEffect::Make(buffer.readScalar()).release();
+sk_sp<SkFlattenable> SkArcToPathEffect::CreateProc(SkReadBuffer& buffer) {
+    return SkArcToPathEffect::Make(buffer.readScalar());
 }
 
 void SkArcToPathEffect::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkArithmeticMode.cpp b/src/effects/SkArithmeticMode.cpp
index b225e6d4c1..fbe6358ae4 100644
--- a/src/effects/SkArithmeticMode.cpp
+++ b/src/effects/SkArithmeticMode.cpp
@@ -54,13 +54,13 @@ private:
     typedef SkXfermode INHERITED;
 };
 
-SkFlattenable* SkArithmeticMode_scalar::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkArithmeticMode_scalar::CreateProc(SkReadBuffer& buffer) {
     const SkScalar k1 = buffer.readScalar();
     const SkScalar k2 = buffer.readScalar();
     const SkScalar k3 = buffer.readScalar();
     const SkScalar k4 = buffer.readScalar();
     const bool enforcePMColor = buffer.readBool();
-    return SkArithmeticMode::Make(k1, k2, k3, k4, enforcePMColor).release();
+    return SkArithmeticMode::Make(k1, k2, k3, k4, enforcePMColor);
 }
 
 static int pinToByte(int value) {
diff --git a/src/effects/SkAvoidXfermode.cpp b/src/effects/SkAvoidXfermode.cpp
index 4b7e63667a..58051288ee 100644
--- a/src/effects/SkAvoidXfermode.cpp
+++ b/src/effects/SkAvoidXfermode.cpp
@@ -21,11 +21,11 @@ SkAvoidXfermode::SkAvoidXfermode(SkColor opColor, U8CPU tolerance, Mode mode) {
     fMode = mode;
 }
 
-SkFlattenable* SkAvoidXfermode::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkAvoidXfermode::CreateProc(SkReadBuffer& buffer) {
     const SkColor color = buffer.readColor();
     const unsigned tolerance = buffer.readUInt();
     const unsigned mode = buffer.readUInt();
-    return Make(color, tolerance, (Mode)mode).release();
+    return Make(color, tolerance, (Mode)mode);
 }
 
 void SkAvoidXfermode::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkBlurDrawLooper.cpp b/src/effects/SkBlurDrawLooper.cpp
index c8e20e1265..2578d092bb 100644
--- a/src/effects/SkBlurDrawLooper.cpp
+++ b/src/effects/SkBlurDrawLooper.cpp
@@ -61,13 +61,13 @@ void SkBlurDrawLooper::init(SkScalar sigma, SkScalar dx, SkScalar dy,
     this->initEffects();
 }
 
-SkFlattenable* SkBlurDrawLooper::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkBlurDrawLooper::CreateProc(SkReadBuffer& buffer) {
     const SkColor color = buffer.readColor();
     const SkScalar sigma = buffer.readScalar();
     const SkScalar dx = buffer.readScalar();
     const SkScalar dy = buffer.readScalar();
     const uint32_t flags = buffer.read32();
-    return Make(color, sigma, dx, dy, flags).release();
+    return Make(color, sigma, dx, dy, flags);
 }
 
 void SkBlurDrawLooper::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkBlurImageFilter.cpp b/src/effects/SkBlurImageFilter.cpp
index c7964c3218..e7b326b7a9 100644
--- a/src/effects/SkBlurImageFilter.cpp
+++ b/src/effects/SkBlurImageFilter.cpp
@@ -42,11 +42,12 @@ SkBlurImageFilter::SkBlurImageFilter(SkScalar sigmaX,
     : INHERITED(1, &input, cropRect), fSigma(SkSize::Make(sigmaX, sigmaY)) {
 }
 
-SkFlattenable* SkBlurImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkBlurImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkScalar sigmaX = buffer.readScalar();
     SkScalar sigmaY = buffer.readScalar();
-    return Create(sigmaX, sigmaY, common.getInput(0).get(), &common.cropRect());
+    return sk_sp<SkFlattenable>(Create(sigmaX, sigmaY, common.getInput(0).get(),
+                                       &common.cropRect()));
 }
 
 void SkBlurImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index 517aa3a88d..ec4fd939fa 100644
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -581,12 +581,12 @@ void SkBlurMaskFilterImpl::computeFastBounds(const SkRect& src,
              src.fRight + pad, src.fBottom + pad);
 }
 
-SkFlattenable* SkBlurMaskFilterImpl::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkBlurMaskFilterImpl::CreateProc(SkReadBuffer& buffer) {
     const SkScalar sigma = buffer.readScalar();
     const unsigned style = buffer.readUInt();
     const unsigned flags = buffer.readUInt();
     if (style <= kLastEnum_SkBlurStyle) {
-        return SkBlurMaskFilter::Create((SkBlurStyle)style, sigma, flags);
+        return sk_sp<SkFlattenable>(SkBlurMaskFilter::Create((SkBlurStyle)style, sigma, flags));
     }
     return nullptr;
 }
diff --git a/src/effects/SkColorCubeFilter.cpp b/src/effects/SkColorCubeFilter.cpp
index d80a02fef2..23241c0255 100644
--- a/src/effects/SkColorCubeFilter.cpp
+++ b/src/effects/SkColorCubeFilter.cpp
@@ -136,13 +136,13 @@ void SkColorCubeFilter::filterSpan(const SkPMColor src[], int count, SkPMColor d
                                    (const SkColor*)fCubeData->data());
 }
 
-SkFlattenable* SkColorCubeFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkColorCubeFilter::CreateProc(SkReadBuffer& buffer) {
     int cubeDimension = buffer.readInt();
     auto cubeData(buffer.readByteArrayAsData());
     if (!buffer.validate(is_valid_3D_lut(cubeData.get(), cubeDimension))) {
         return nullptr;
     }
-    return Make(std::move(cubeData), cubeDimension).release();
+    return Make(std::move(cubeData), cubeDimension);
 }
 
 void SkColorCubeFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkColorFilterImageFilter.cpp b/src/effects/SkColorFilterImageFilter.cpp
index a5904ea60b..c1637d8128 100644
--- a/src/effects/SkColorFilterImageFilter.cpp
+++ b/src/effects/SkColorFilterImageFilter.cpp
@@ -41,10 +41,10 @@ SkColorFilterImageFilter::SkColorFilterImageFilter(SkColorFilter* cf,
     , fColorFilter(SkRef(cf)) {
 }
 
-SkFlattenable* SkColorFilterImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkColorFilterImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     sk_sp<SkColorFilter> cf(buffer.readColorFilter());
-    return Create(cf.get(), common.getInput(0).get(), &common.cropRect());
+    return sk_sp<SkFlattenable>(Create(cf.get(), common.getInput(0).get(), &common.cropRect()));
 }
 
 void SkColorFilterImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkComposeImageFilter.cpp b/src/effects/SkComposeImageFilter.cpp
index e2a27a8312..e960f966c5 100644
--- a/src/effects/SkComposeImageFilter.cpp
+++ b/src/effects/SkComposeImageFilter.cpp
@@ -58,9 +58,9 @@ SkIRect SkComposeImageFilter::onFilterBounds(const SkIRect& src, const SkMatrix&
     return outer->filterBounds(inner->filterBounds(src, ctm, direction), ctm, direction);
 }
 
-SkFlattenable* SkComposeImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkComposeImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
-    return SkComposeImageFilter::Make(common.getInput(0), common.getInput(1)).release();
+    return SkComposeImageFilter::Make(common.getInput(0), common.getInput(1));
 }
 
 #ifndef SK_IGNORE_TO_STRING
diff --git a/src/effects/SkCornerPathEffect.cpp b/src/effects/SkCornerPathEffect.cpp
index c38889c608..909ef31478 100644
--- a/src/effects/SkCornerPathEffect.cpp
+++ b/src/effects/SkCornerPathEffect.cpp
@@ -138,8 +138,8 @@ DONE:
     return true;
 }
 
-SkFlattenable* SkCornerPathEffect::CreateProc(SkReadBuffer& buffer) {
-    return SkCornerPathEffect::Make(buffer.readScalar()).release();
+sk_sp<SkFlattenable> SkCornerPathEffect::CreateProc(SkReadBuffer& buffer) {
+    return SkCornerPathEffect::Make(buffer.readScalar());
 }
 
 void SkCornerPathEffect::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkDashPathEffect.cpp b/src/effects/SkDashPathEffect.cpp
index 51bf54839c..90af32ec5b 100644
--- a/src/effects/SkDashPathEffect.cpp
+++ b/src/effects/SkDashPathEffect.cpp
@@ -360,12 +360,12 @@ void SkDashPathEffect::flatten(SkWriteBuffer& buffer) const {
     buffer.writeScalarArray(fIntervals, fCount);
 }
 
-SkFlattenable* SkDashPathEffect::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkDashPathEffect::CreateProc(SkReadBuffer& buffer) {
     const SkScalar phase = buffer.readScalar();
     uint32_t count = buffer.getArrayCount();
     SkAutoSTArray<32, SkScalar> intervals(count);
     if (buffer.readScalarArray(intervals.get(), count)) {
-        return Make(intervals.get(), SkToInt(count), phase).release();
+        return Make(intervals.get(), SkToInt(count), phase);
     }
     return nullptr;
 }
diff --git a/src/effects/SkDiscretePathEffect.cpp b/src/effects/SkDiscretePathEffect.cpp
index 1c6039c842..5d5fc6528c 100644
--- a/src/effects/SkDiscretePathEffect.cpp
+++ b/src/effects/SkDiscretePathEffect.cpp
@@ -127,11 +127,11 @@ bool SkDiscretePathEffect::filterPath(SkPath* dst, const SkPath& src,
     return true;
 }
 
-SkFlattenable* SkDiscretePathEffect::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkDiscretePathEffect::CreateProc(SkReadBuffer& buffer) {
     SkScalar segLength = buffer.readScalar();
     SkScalar perterb = buffer.readScalar();
     uint32_t seed = buffer.readUInt();
-    return Make(segLength, perterb, seed).release();
+    return Make(segLength, perterb, seed);
 }
 
 void SkDiscretePathEffect::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp
index d054e58e51..447a20bcb2 100644
--- a/src/effects/SkDisplacementMapEffect.cpp
+++ b/src/effects/SkDisplacementMapEffect.cpp
@@ -195,13 +195,13 @@ SkDisplacementMapEffect::SkDisplacementMapEffect(ChannelSelectorType xChannelSel
 SkDisplacementMapEffect::~SkDisplacementMapEffect() {
 }
 
-SkFlattenable* SkDisplacementMapEffect::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkDisplacementMapEffect::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
     ChannelSelectorType xsel = (ChannelSelectorType)buffer.readInt();
     ChannelSelectorType ysel = (ChannelSelectorType)buffer.readInt();
     SkScalar scale = buffer.readScalar();
-    return Create(xsel, ysel, scale,
-                  common.getInput(0).get(), common.getInput(1).get(), &common.cropRect());
+    return sk_sp<SkFlattenable>(Create(xsel, ysel, scale, common.getInput(0).get(),
+                                       common.getInput(1).get(), &common.cropRect()));
 }
 
 void SkDisplacementMapEffect::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkDropShadowImageFilter.cpp b/src/effects/SkDropShadowImageFilter.cpp
index 6e750ca74c..331cfbd68b 100644
--- a/src/effects/SkDropShadowImageFilter.cpp
+++ b/src/effects/SkDropShadowImageFilter.cpp
@@ -27,7 +27,7 @@ SkDropShadowImageFilter::SkDropShadowImageFilter(SkScalar dx, SkScalar dy,
     , fShadowMode(shadowMode) {
 }
 
-SkFlattenable* SkDropShadowImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkDropShadowImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkScalar dx = buffer.readScalar();
     SkScalar dy = buffer.readScalar();
@@ -37,8 +37,8 @@ SkFlattenable* SkDropShadowImageFilter::CreateProc(SkReadBuffer& buffer) {
     ShadowMode shadowMode = buffer.isVersionLT(SkReadBuffer::kDropShadowMode_Version) ?
                             kDrawShadowAndForeground_ShadowMode :
                             static_cast<ShadowMode>(buffer.readInt());
-    return Create(dx, dy, sigmaX, sigmaY, color, shadowMode, common.getInput(0).get(),
-                  &common.cropRect());
+    return sk_sp<SkFlattenable>(Create(dx, dy, sigmaX, sigmaY, color, shadowMode,
+                                       common.getInput(0).get(), &common.cropRect()));
 }
 
 void SkDropShadowImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkEmbossMaskFilter.cpp b/src/effects/SkEmbossMaskFilter.cpp
index aacc191ff7..aa93e5a594 100644
--- a/src/effects/SkEmbossMaskFilter.cpp
+++ b/src/effects/SkEmbossMaskFilter.cpp
@@ -112,12 +112,12 @@ bool SkEmbossMaskFilter::filterMask(SkMask* dst, const SkMask& src,
     return true;
 }
 
-SkFlattenable* SkEmbossMaskFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkEmbossMaskFilter::CreateProc(SkReadBuffer& buffer) {
     Light light;
     if (buffer.readByteArray(&light, sizeof(Light))) {
         light.fPad = 0; // for the font-cache lookup to be clean
         const SkScalar sigma = buffer.readScalar();
-        return Create(sigma, light);
+        return sk_sp<SkFlattenable>(Create(sigma, light));
     }
     return nullptr;
 }
diff --git a/src/effects/SkImageSource.cpp b/src/effects/SkImageSource.cpp
index f16e5a140f..cf8cae2c39 100644
--- a/src/effects/SkImageSource.cpp
+++ b/src/effects/SkImageSource.cpp
@@ -35,7 +35,7 @@ SkImageSource::SkImageSource(sk_sp<SkImage> image,
     , fFilterQuality(filterQuality) {
 }
 
-SkFlattenable* SkImageSource::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkImageSource::CreateProc(SkReadBuffer& buffer) {
     SkFilterQuality filterQuality = (SkFilterQuality)buffer.readInt();
 
     SkRect src, dst;
@@ -47,7 +47,7 @@ SkFlattenable* SkImageSource::CreateProc(SkReadBuffer& buffer) {
         return nullptr;
     }
 
-    return SkImageSource::Make(std::move(image), src, dst, filterQuality).release();
+    return SkImageSource::Make(std::move(image), src, dst, filterQuality);
 }
 
 void SkImageSource::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkLayerDrawLooper.cpp b/src/effects/SkLayerDrawLooper.cpp
index b3430bb1e4..ffcaa43e20 100644
--- a/src/effects/SkLayerDrawLooper.cpp
+++ b/src/effects/SkLayerDrawLooper.cpp
@@ -214,7 +214,7 @@ void SkLayerDrawLooper::flatten(SkWriteBuffer& buffer) const {
     }
 }
 
-SkFlattenable* SkLayerDrawLooper::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkLayerDrawLooper::CreateProc(SkReadBuffer& buffer) {
     int count = buffer.readInt();
 
     Builder builder;
@@ -229,7 +229,7 @@ SkFlattenable* SkLayerDrawLooper::CreateProc(SkReadBuffer& buffer) {
         info.fPostTranslate = buffer.readBool();
         buffer.readPaint(builder.addLayerOnTop(info));
     }
-    return builder.detach().release();
+    return builder.detach();
 }
 
 #ifndef SK_IGNORE_TO_STRING
diff --git a/src/effects/SkLayerRasterizer.cpp b/src/effects/SkLayerRasterizer.cpp
index a51613a162..91502b7e84 100644
--- a/src/effects/SkLayerRasterizer.cpp
+++ b/src/effects/SkLayerRasterizer.cpp
@@ -144,8 +144,8 @@ bool SkLayerRasterizer::onRasterize(const SkPath& path, const SkMatrix& matrix,
     return true;
 }
 
-SkFlattenable* SkLayerRasterizer::CreateProc(SkReadBuffer& buffer) {
-    return new SkLayerRasterizer(ReadLayers(buffer));
+sk_sp<SkFlattenable> SkLayerRasterizer::CreateProc(SkReadBuffer& buffer) {
+    return sk_sp<SkFlattenable>(new SkLayerRasterizer(ReadLayers(buffer)));
 }
 
 SkDeque* SkLayerRasterizer::ReadLayers(SkReadBuffer& buffer) {
diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index 55a1f22909..c27a55476f 100644
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -1210,12 +1210,13 @@ SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(SkImageFilterLight* l
 {
 }
 
-SkFlattenable* SkDiffuseLightingImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkDiffuseLightingImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkAutoTUnref<SkImageFilterLight> light(SkImageFilterLight::UnflattenLight(buffer));
     SkScalar surfaceScale = buffer.readScalar();
     SkScalar kd = buffer.readScalar();
-    return Create(light, surfaceScale, kd, common.getInput(0).get(), &common.cropRect());
+    return sk_sp<SkFlattenable>(Create(light, surfaceScale, kd, common.getInput(0).get(),
+                                       &common.cropRect()));
 }
 
 void SkDiffuseLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
@@ -1352,13 +1353,14 @@ SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkImageFilterLight*
 {
 }
 
-SkFlattenable* SkSpecularLightingImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkSpecularLightingImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkAutoTUnref<SkImageFilterLight> light(SkImageFilterLight::UnflattenLight(buffer));
     SkScalar surfaceScale = buffer.readScalar();
     SkScalar ks = buffer.readScalar();
     SkScalar shine = buffer.readScalar();
-    return Create(light, surfaceScale, ks, shine, common.getInput(0).get(), &common.cropRect());
+    return sk_sp<SkFlattenable>(Create(light, surfaceScale, ks, shine, common.getInput(0).get(),
+                                       &common.cropRect()));
 }
 
 void SkSpecularLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkLumaColorFilter.cpp b/src/effects/SkLumaColorFilter.cpp
index 18b2485a30..28b2e1eb44 100644
--- a/src/effects/SkLumaColorFilter.cpp
+++ b/src/effects/SkLumaColorFilter.cpp
@@ -43,7 +43,9 @@ sk_sp<SkColorFilter> SkLumaColorFilter::Make() {
 
 SkLumaColorFilter::SkLumaColorFilter() : INHERITED() {}
 
-SkFlattenable* SkLumaColorFilter::CreateProc(SkReadBuffer&) { return new SkLumaColorFilter; }
+sk_sp<SkFlattenable> SkLumaColorFilter::CreateProc(SkReadBuffer&) {
+    return Make();
+}
 
 void SkLumaColorFilter::flatten(SkWriteBuffer&) const {}
 
diff --git a/src/effects/SkMagnifierImageFilter.cpp b/src/effects/SkMagnifierImageFilter.cpp
index bfad549485..dfd7f04f6a 100644
--- a/src/effects/SkMagnifierImageFilter.cpp
+++ b/src/effects/SkMagnifierImageFilter.cpp
@@ -281,11 +281,11 @@ bool SkMagnifierImageFilter::asFragmentProcessor(GrFragmentProcessor** fp,
 }
 #endif
 
-SkFlattenable* SkMagnifierImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkMagnifierImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkRect src;
     buffer.readRect(&src);
-    return Create(src, buffer.readScalar(), common.getInput(0).get());
+    return sk_sp<SkFlattenable>(Create(src, buffer.readScalar(), common.getInput(0).get()));
 }
 
 void SkMagnifierImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkMatrixConvolutionImageFilter.cpp b/src/effects/SkMatrixConvolutionImageFilter.cpp
index 2a32fd5cdc..accebb5a4f 100644
--- a/src/effects/SkMatrixConvolutionImageFilter.cpp
+++ b/src/effects/SkMatrixConvolutionImageFilter.cpp
@@ -74,7 +74,7 @@ SkImageFilter* SkMatrixConvolutionImageFilter::Create(
                                               tileMode, convolveAlpha, input, cropRect);
 }
 
-SkFlattenable* SkMatrixConvolutionImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkMatrixConvolutionImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkISize kernelSize;
     kernelSize.fWidth = buffer.readInt();
@@ -96,8 +96,8 @@ SkFlattenable* SkMatrixConvolutionImageFilter::CreateProc(SkReadBuffer& buffer)
     kernelOffset.fY = buffer.readInt();
     TileMode tileMode = (TileMode)buffer.readInt();
     bool convolveAlpha = buffer.readBool();
-    return Create(kernelSize, kernel.get(), gain, bias, kernelOffset, tileMode, convolveAlpha,
-                  common.getInput(0).get(), &common.cropRect());
+    return sk_sp<SkFlattenable>(Create(kernelSize, kernel.get(), gain, bias, kernelOffset, tileMode,
+                                   convolveAlpha, common.getInput(0).get(), &common.cropRect()));
 }
 
 void SkMatrixConvolutionImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkMergeImageFilter.cpp b/src/effects/SkMergeImageFilter.cpp
index cd16d43db3..44e6caf087 100755
--- a/src/effects/SkMergeImageFilter.cpp
+++ b/src/effects/SkMergeImageFilter.cpp
@@ -131,7 +131,7 @@ sk_sp<SkSpecialImage> SkMergeImageFilter::onFilterImage(SkSpecialImage* source,
     return surf->makeImageSnapshot();
 }
 
-SkFlattenable* SkMergeImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkMergeImageFilter::CreateProc(SkReadBuffer& buffer) {
     Common common;
     if (!common.unflatten(buffer, -1)) {
         return nullptr;
@@ -152,9 +152,9 @@ SkFlattenable* SkMergeImageFilter::CreateProc(SkReadBuffer& buffer) {
         if (!buffer.isValid()) {
             return nullptr;
         }
-        return Make(common.inputs(), count, modes.get(), &common.cropRect()).release();
+        return Make(common.inputs(), count, modes.get(), &common.cropRect());
     }
-    return Make(common.inputs(), count, nullptr, &common.cropRect()).release();
+    return Make(common.inputs(), count, nullptr, &common.cropRect());
 }
 
 void SkMergeImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp
index dbb116ed22..bf8811b887 100644
--- a/src/effects/SkMorphologyImageFilter.cpp
+++ b/src/effects/SkMorphologyImageFilter.cpp
@@ -72,18 +72,20 @@ SkIRect SkMorphologyImageFilter::onFilterNodeBounds(const SkIRect& src, const Sk
     return src.makeOutset(SkScalarCeilToInt(radius.x()), SkScalarCeilToInt(radius.y()));
 }
 
-SkFlattenable* SkErodeImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkErodeImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     const int width = buffer.readInt();
     const int height = buffer.readInt();
-    return Create(width, height, common.getInput(0).get(), &common.cropRect());
+    return sk_sp<SkFlattenable>(Create(width, height, common.getInput(0).get(),
+                                       &common.cropRect()));
 }
 
-SkFlattenable* SkDilateImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkDilateImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     const int width = buffer.readInt();
     const int height = buffer.readInt();
-    return Create(width, height, common.getInput(0).get(), &common.cropRect());
+    return sk_sp<SkFlattenable>(Create(width, height, common.getInput(0).get(),
+                                       &common.cropRect()));
 }
 
 #ifndef SK_IGNORE_TO_STRING
diff --git a/src/effects/SkOffsetImageFilter.cpp b/src/effects/SkOffsetImageFilter.cpp
index 69f1895402..1df47d8b6f 100644
--- a/src/effects/SkOffsetImageFilter.cpp
+++ b/src/effects/SkOffsetImageFilter.cpp
@@ -82,11 +82,11 @@ SkIRect SkOffsetImageFilter::onFilterNodeBounds(const SkIRect& src, const SkMatr
     return src.makeOffset(SkScalarCeilToInt(vec.fX), SkScalarCeilToInt(vec.fY));
 }
 
-SkFlattenable* SkOffsetImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkOffsetImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkPoint offset;
     buffer.readPoint(&offset);
-    return Make(offset.x(), offset.y(), common.getInput(0), &common.cropRect()).release();
+    return Make(offset.x(), offset.y(), common.getInput(0), &common.cropRect());
 }
 
 void SkOffsetImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkPaintImageFilter.cpp b/src/effects/SkPaintImageFilter.cpp
index 4462b757f5..f561928684 100644
--- a/src/effects/SkPaintImageFilter.cpp
+++ b/src/effects/SkPaintImageFilter.cpp
@@ -17,11 +17,11 @@ SkPaintImageFilter::SkPaintImageFilter(const SkPaint& paint, const CropRect* cro
     , fPaint(paint) {
 }
 
-SkFlattenable* SkPaintImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkPaintImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 0);
     SkPaint paint;
     buffer.readPaint(&paint);
-    return SkPaintImageFilter::Make(paint, &common.cropRect()).release();
+    return SkPaintImageFilter::Make(paint, &common.cropRect());
 }
 
 void SkPaintImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkPerlinNoiseShader.cpp b/src/effects/SkPerlinNoiseShader.cpp
index 72b7e0280d..c8b04c9975 100644
--- a/src/effects/SkPerlinNoiseShader.cpp
+++ b/src/effects/SkPerlinNoiseShader.cpp
@@ -286,7 +286,7 @@ SkPerlinNoiseShader::SkPerlinNoiseShader(SkPerlinNoiseShader::Type type,
 SkPerlinNoiseShader::~SkPerlinNoiseShader() {
 }
 
-SkFlattenable* SkPerlinNoiseShader::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkPerlinNoiseShader::CreateProc(SkReadBuffer& buffer) {
     Type type = (Type)buffer.readInt();
     SkScalar freqX = buffer.readScalar();
     SkScalar freqY = buffer.readScalar();
@@ -299,10 +299,10 @@ SkFlattenable* SkPerlinNoiseShader::CreateProc(SkReadBuffer& buffer) {
     switch (type) {
         case kFractalNoise_Type:
             return SkPerlinNoiseShader::MakeFractalNoise(freqX, freqY, octaves, seed,
-                                                         &tileSize).release();
+                                                         &tileSize);
         case kTurbulence_Type:
             return SkPerlinNoiseShader::MakeTurbulence(freqX, freqY, octaves, seed,
-                                                       &tileSize).release();
+                                                       &tileSize);
         default:
             return nullptr;
     }
diff --git a/src/effects/SkPictureImageFilter.cpp b/src/effects/SkPictureImageFilter.cpp
index 2005463bd4..2dff41a8d7 100644
--- a/src/effects/SkPictureImageFilter.cpp
+++ b/src/effects/SkPictureImageFilter.cpp
@@ -31,7 +31,7 @@ SkPictureImageFilter::SkPictureImageFilter(sk_sp<SkPicture> picture, const SkRec
     , fFilterQuality(filterQuality) {
 }
 
-SkFlattenable* SkPictureImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkPictureImageFilter::CreateProc(SkReadBuffer& buffer) {
     sk_sp<SkPicture> picture;
     SkRect cropRect;
 
@@ -58,9 +58,9 @@ SkFlattenable* SkPictureImageFilter::CreateProc(SkReadBuffer& buffer) {
         } else {
             filterQuality = (SkFilterQuality)buffer.readInt();
         }
-        return MakeForLocalSpace(picture, cropRect, filterQuality).release();
+        return MakeForLocalSpace(picture, cropRect, filterQuality);
     }
-    return Make(picture, cropRect).release();
+    return Make(picture, cropRect);
 }
 
 void SkPictureImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkPixelXorXfermode.cpp b/src/effects/SkPixelXorXfermode.cpp
index 4ad3f1bd76..d8861e6df1 100644
--- a/src/effects/SkPixelXorXfermode.cpp
+++ b/src/effects/SkPixelXorXfermode.cpp
@@ -26,8 +26,8 @@ void SkPixelXorXfermode::flatten(SkWriteBuffer& wb) const {
                                 SkGetPackedB32(fOpColor)));
 }
 
-SkFlattenable* SkPixelXorXfermode::CreateProc(SkReadBuffer& buffer) {
-    return Make(buffer.readColor()).release();
+sk_sp<SkFlattenable> SkPixelXorXfermode::CreateProc(SkReadBuffer& buffer) {
+    return Make(buffer.readColor());
 }
 
 #ifndef SK_IGNORE_TO_STRING
diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp
index 4ce0b4bb0e..10b71f86c6 100644
--- a/src/effects/SkTableColorFilter.cpp
+++ b/src/effects/SkTableColorFilter.cpp
@@ -207,7 +207,7 @@ void SkTable_ColorFilter::flatten(SkWriteBuffer& buffer) const {
     buffer.writeByteArray(storage, size);
 }
 
-SkFlattenable* SkTable_ColorFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkTable_ColorFilter::CreateProc(SkReadBuffer& buffer) {
     const int flags = buffer.read32();
     const size_t count = gCountNibBits[flags & 0xF];
     SkASSERT(count <= 4);
@@ -251,7 +251,7 @@ SkFlattenable* SkTable_ColorFilter::CreateProc(SkReadBuffer& buffer) {
         b = ptr;
         ptr += 256;
     }
-    return SkTableColorFilter::MakeARGB(a, r, g, b).release();
+    return SkTableColorFilter::MakeARGB(a, r, g, b);
 }
 
 bool SkTable_ColorFilter::asComponentTable(SkBitmap* table) const {
diff --git a/src/effects/SkTableMaskFilter.cpp b/src/effects/SkTableMaskFilter.cpp
index ddf9f33f54..d834652962 100644
--- a/src/effects/SkTableMaskFilter.cpp
+++ b/src/effects/SkTableMaskFilter.cpp
@@ -73,12 +73,12 @@ void SkTableMaskFilter::flatten(SkWriteBuffer& wb) const {
     wb.writeByteArray(fTable, 256);
 }
 
-SkFlattenable* SkTableMaskFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkTableMaskFilter::CreateProc(SkReadBuffer& buffer) {
     uint8_t table[256];
     if (!buffer.readByteArray(table, 256)) {
         return nullptr;
     }
-    return Create(table);
+    return sk_sp<SkFlattenable>(Create(table));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/src/effects/SkTestImageFilters.cpp b/src/effects/SkTestImageFilters.cpp
index a77f5190ff..e9ec7c19ce 100755
--- a/src/effects/SkTestImageFilters.cpp
+++ b/src/effects/SkTestImageFilters.cpp
@@ -75,9 +75,9 @@ bool SkDownSampleImageFilter::onFilterImageDeprecated(Proxy* proxy, const SkBitm
     return true;
 }
 
-SkFlattenable* SkDownSampleImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkDownSampleImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
-    return Create(buffer.readScalar(), common.getInput(0).get());
+    return sk_sp<SkFlattenable>(Create(buffer.readScalar(), common.getInput(0).get()));
 }
 
 void SkDownSampleImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkTileImageFilter.cpp b/src/effects/SkTileImageFilter.cpp
index 8f556ff4d0..0ff19b23ad 100644
--- a/src/effects/SkTileImageFilter.cpp
+++ b/src/effects/SkTileImageFilter.cpp
@@ -123,12 +123,12 @@ SkRect SkTileImageFilter::computeFastBounds(const SkRect& src) const {
     return fDstRect;
 }
 
-SkFlattenable* SkTileImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkTileImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkRect src, dst;
     buffer.readRect(&src);
     buffer.readRect(&dst);
-    return Create(src, dst, common.getInput(0).get());
+    return sk_sp<SkFlattenable>(Create(src, dst, common.getInput(0).get()));
 }
 
 void SkTileImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkXfermodeImageFilter.cpp b/src/effects/SkXfermodeImageFilter.cpp
index db0b5e59bb..45c9f70568 100644
--- a/src/effects/SkXfermodeImageFilter.cpp
+++ b/src/effects/SkXfermodeImageFilter.cpp
@@ -37,11 +37,11 @@ SkXfermodeImageFilter::SkXfermodeImageFilter(sk_sp<SkXfermode> mode,
     , fMode(std::move(mode))
 {}
 
-SkFlattenable* SkXfermodeImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkXfermodeImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
     sk_sp<SkXfermode> mode(buffer.readXfermode());
-    return Make(std::move(mode), common.getInput(0).get(),
-                common.getInput(1).get(), &common.cropRect()).release();
+    return Make(std::move(mode), common.getInput(0).get(), common.getInput(1).get(),
+                &common.cropRect());
 }
 
 void SkXfermodeImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/gradients/SkLinearGradient.cpp b/src/effects/gradients/SkLinearGradient.cpp
index f521bd7024..e9fc865583 100644
--- a/src/effects/gradients/SkLinearGradient.cpp
+++ b/src/effects/gradients/SkLinearGradient.cpp
@@ -54,7 +54,7 @@ SkLinearGradient::SkLinearGradient(const SkPoint pts[2], const Descriptor& desc)
     , fEnd(pts[1]) {
 }
 
-SkFlattenable* SkLinearGradient::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkLinearGradient::CreateProc(SkReadBuffer& buffer) {
     DescriptorScope desc;
     if (!desc.unflatten(buffer)) {
         return nullptr;
@@ -63,7 +63,7 @@ SkFlattenable* SkLinearGradient::CreateProc(SkReadBuffer& buffer) {
     pts[0] = buffer.readPoint();
     pts[1] = buffer.readPoint();
     return SkGradientShader::MakeLinear(pts, desc.fColors, desc.fPos, desc.fCount, desc.fTileMode,
-                                        desc.fGradFlags, desc.fLocalMatrix).release();
+                                        desc.fGradFlags, desc.fLocalMatrix);
 }
 
 void SkLinearGradient::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/gradients/SkRadialGradient.cpp b/src/effects/gradients/SkRadialGradient.cpp
index 1312b36927..e666ac3cbd 100644
--- a/src/effects/gradients/SkRadialGradient.cpp
+++ b/src/effects/gradients/SkRadialGradient.cpp
@@ -60,7 +60,7 @@ SkShader::GradientType SkRadialGradient::asAGradient(GradientInfo* info) const {
     return kRadial_GradientType;
 }
 
-SkFlattenable* SkRadialGradient::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkRadialGradient::CreateProc(SkReadBuffer& buffer) {
     DescriptorScope desc;
     if (!desc.unflatten(buffer)) {
         return nullptr;
@@ -68,8 +68,7 @@ SkFlattenable* SkRadialGradient::CreateProc(SkReadBuffer& buffer) {
     const SkPoint center = buffer.readPoint();
     const SkScalar radius = buffer.readScalar();
     return SkGradientShader::MakeRadial(center, radius, desc.fColors, desc.fPos, desc.fCount,
-                                        desc.fTileMode, desc.fGradFlags,
-                                        desc.fLocalMatrix).release();
+                                        desc.fTileMode, desc.fGradFlags, desc.fLocalMatrix);
 }
 
 void SkRadialGradient::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/gradients/SkSweepGradient.cpp b/src/effects/gradients/SkSweepGradient.cpp
index f14035c526..ccc39d10f9 100644
--- a/src/effects/gradients/SkSweepGradient.cpp
+++ b/src/effects/gradients/SkSweepGradient.cpp
@@ -29,14 +29,14 @@ SkShader::GradientType SkSweepGradient::asAGradient(GradientInfo* info) const {
     return kSweep_GradientType;
 }
 
-SkFlattenable* SkSweepGradient::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkSweepGradient::CreateProc(SkReadBuffer& buffer) {
     DescriptorScope desc;
     if (!desc.unflatten(buffer)) {
         return nullptr;
     }
     const SkPoint center = buffer.readPoint();
     return SkGradientShader::MakeSweep(center.x(), center.y(), desc.fColors, desc.fPos,
-                                       desc.fCount, desc.fGradFlags, desc.fLocalMatrix).release();
+                                       desc.fCount, desc.fGradFlags, desc.fLocalMatrix);
 }
 
 void SkSweepGradient::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/gradients/SkTwoPointConicalGradient.cpp b/src/effects/gradients/SkTwoPointConicalGradient.cpp
index d9fc39c3bc..f33dcc5a75 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient.cpp
+++ b/src/effects/gradients/SkTwoPointConicalGradient.cpp
@@ -305,7 +305,7 @@ SkShader::GradientType SkTwoPointConicalGradient::asAGradient(
     return kConical_GradientType;
 }
 
-SkFlattenable* SkTwoPointConicalGradient::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkTwoPointConicalGradient::CreateProc(SkReadBuffer& buffer) {
     DescriptorScope desc;
     if (!desc.unflatten(buffer)) {
         return nullptr;
@@ -340,7 +340,7 @@ SkFlattenable* SkTwoPointConicalGradient::CreateProc(SkReadBuffer& buffer) {
 
     return SkGradientShader::MakeTwoPointConical(c1, r1, c2, r2, desc.fColors, desc.fPos,
                                                  desc.fCount, desc.fTileMode, desc.fGradFlags,
-                                                 desc.fLocalMatrix).release();
+                                                 desc.fLocalMatrix);
 }
 
 void SkTwoPointConicalGradient::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/image/SkImageShader.cpp b/src/image/SkImageShader.cpp
index 00c038ab88..d12ee030a2 100644
--- a/src/image/SkImageShader.cpp
+++ b/src/image/SkImageShader.cpp
@@ -19,7 +19,7 @@ SkImageShader::SkImageShader(const SkImage* img, TileMode tmx, TileMode tmy, con
     , fTileModeY(tmy)
 {}
 
-SkFlattenable* SkImageShader::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkImageShader::CreateProc(SkReadBuffer& buffer) {
     const TileMode tx = (TileMode)buffer.readUInt();
     const TileMode ty = (TileMode)buffer.readUInt();
     SkMatrix matrix;
@@ -28,7 +28,7 @@ SkFlattenable* SkImageShader::CreateProc(SkReadBuffer& buffer) {
     if (!img) {
         return nullptr;
     }
-    return SkImageShader::Make(img, tx, ty, &matrix).release();
+    return SkImageShader::Make(img, tx, ty, &matrix);
 }
 
 void SkImageShader::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/utils/SkBitmapSourceDeserializer.cpp b/src/utils/SkBitmapSourceDeserializer.cpp
index b4fba275ec..bf4ec60219 100644
--- a/src/utils/SkBitmapSourceDeserializer.cpp
+++ b/src/utils/SkBitmapSourceDeserializer.cpp
@@ -13,7 +13,7 @@
 #include "SkImageSource.h"
 #include "SkReadBuffer.h"
 
-SkFlattenable* SkBitmapSourceDeserializer::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkBitmapSourceDeserializer::CreateProc(SkReadBuffer& buffer) {
     SkFilterQuality filterQuality;
     if (buffer.isVersionLT(SkReadBuffer::kBitmapSourceFilterQuality_Version)) {
         filterQuality = kHigh_SkFilterQuality;
@@ -29,5 +29,5 @@ SkFlattenable* SkBitmapSourceDeserializer::CreateProc(SkReadBuffer& buffer) {
     }
     bitmap.setImmutable();
 
-    return SkImageSource::Make(SkImage::MakeFromBitmap(bitmap), src, dst, filterQuality).release();
+    return SkImageSource::Make(SkImage::MakeFromBitmap(bitmap), src, dst, filterQuality);
 }
diff --git a/tests/ImageFilterTest.cpp b/tests/ImageFilterTest.cpp
index dda899b4f3..3f60286e39 100644
--- a/tests/ImageFilterTest.cpp
+++ b/tests/ImageFilterTest.cpp
@@ -219,12 +219,12 @@ private:
 
 }
 
-SkFlattenable* MatrixTestImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> MatrixTestImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     skiatest::Reporter* reporter = (skiatest::Reporter*)buffer.readFunctionPtr();
     SkMatrix matrix;
     buffer.readMatrix(&matrix);
-    return new MatrixTestImageFilter(reporter, matrix);
+    return sk_make_sp<MatrixTestImageFilter>(reporter, matrix);
 }
 
 #ifndef SK_IGNORE_TO_STRING
diff --git a/tests/LayerRasterizerTest.cpp b/tests/LayerRasterizerTest.cpp
index b71c305d59..9d1fb2937a 100644
--- a/tests/LayerRasterizerTest.cpp
+++ b/tests/LayerRasterizerTest.cpp
@@ -43,7 +43,9 @@ private:
 
 int DummyRasterizer::gCount;
 
-SkFlattenable* DummyRasterizer::CreateProc(SkReadBuffer&) { return new DummyRasterizer; }
+sk_sp<SkFlattenable> DummyRasterizer::CreateProc(SkReadBuffer&) {
+    return sk_make_sp<DummyRasterizer>();
+}
 
 // Check to make sure that the SkPaint in the layer has its destructor called.
 DEF_TEST(LayerRasterizer_destructor, reporter) {
diff --git a/tests/PDFPrimitivesTest.cpp b/tests/PDFPrimitivesTest.cpp
index 57b0b60b87..f4c29b358d 100644
--- a/tests/PDFPrimitivesTest.cpp
+++ b/tests/PDFPrimitivesTest.cpp
@@ -381,10 +381,10 @@ private:
     mutable bool fVisited;
 };
 
-SkFlattenable* DummyImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> DummyImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 0);
     bool visited = buffer.readBool();
-    return new DummyImageFilter(visited);
+    return sk_make_sp<DummyImageFilter>(visited);
 }
 
 #ifndef SK_IGNORE_TO_STRING
diff --git a/tests/QuickRejectTest.cpp b/tests/QuickRejectTest.cpp
index 582789aa75..6a978743f6 100644
--- a/tests/QuickRejectTest.cpp
+++ b/tests/QuickRejectTest.cpp
@@ -49,7 +49,7 @@ private:
     };
 };
 
-SkFlattenable* TestLooper::CreateProc(SkReadBuffer&) { return new TestLooper; }
+sk_sp<SkFlattenable> TestLooper::CreateProc(SkReadBuffer&) { return sk_make_sp<TestLooper>(); }
 
 static void test_drawBitmap(skiatest::Reporter* reporter) {
     SkBitmap src;
diff --git a/tools/debugger/SkDrawCommand.cpp b/tools/debugger/SkDrawCommand.cpp
index a32e0b6211..d868418d54 100644
--- a/tools/debugger/SkDrawCommand.cpp
+++ b/tools/debugger/SkDrawCommand.cpp
@@ -726,12 +726,12 @@ static SkFlattenable* load_flattenable(Json::Value jsonFlattenable,
     const void* data;
     int size = decode_data(jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_DATA], urlDataManager, &data);
     SkValidatingReadBuffer buffer(data, size);
-    SkFlattenable* result = factory(buffer);
+    sk_sp<SkFlattenable> result = factory(buffer);
     if (!buffer.isValid()) {
         SkDebugf("invalid buffer loading flattenable\n");
         return nullptr;
     }
-    return result;
+    return result.release();
 }
 
 static SkColorType colortype_from_name(const char* name) {
diff --git a/tools/debugger/SkOverdrawMode.cpp b/tools/debugger/SkOverdrawMode.cpp
index 7eee387b09..1e018babdb 100644
--- a/tools/debugger/SkOverdrawMode.cpp
+++ b/tools/debugger/SkOverdrawMode.cpp
@@ -313,8 +313,8 @@ private:
     typedef SkXfermode INHERITED;
 };
 
-SkFlattenable* SkOverdrawXfermode::CreateProc(SkReadBuffer& buffer) {
-    return Create();
+sk_sp<SkFlattenable> SkOverdrawXfermode::CreateProc(SkReadBuffer& buffer) {
+    return sk_sp<SkFlattenable>(Create());
 }
 
 sk_sp<SkXfermode> SkOverdrawMode::Make() { return sk_make_sp<SkOverdrawXfermode>(); }