add Make variations to return SkImage by sk_sp

some internal call-sites update, but not. Will follow-up in future to complete that.

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

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

14 files changed, 190 insertions, 113 deletions

diff --git a/src/c/sk_surface.cpp b/src/c/sk_surface.cpp
index f7fa30f28a..6bd62a9aa9 100644
--- a/src/c/sk_surface.cpp
+++ b/src/c/sk_surface.cpp
@@ -224,12 +224,12 @@ sk_image_t* sk_image_new_raster_copy(const sk_imageinfo_t* cinfo, const void* pi
     if (!from_c_info(*cinfo, &info)) {
         return NULL;
     }
-    return (sk_image_t*)SkImage::NewRasterCopy(info, pixels, rowBytes);
+    return (sk_image_t*)SkImage::MakeRasterCopy(SkPixmap(info, pixels, rowBytes)).release();
 }
 
 sk_image_t* sk_image_new_from_encoded(const sk_data_t* cdata, const sk_irect_t* subset) {
-    return ToImage(SkImage::NewFromEncoded(AsData(cdata),
-                                           reinterpret_cast<const SkIRect*>(subset)));
+    return ToImage(SkImage::MakeFromEncoded(sk_ref_sp(AsData(cdata)),
+                                           reinterpret_cast<const SkIRect*>(subset)).release());
 }
 
 sk_data_t* sk_image_encode(const sk_image_t* cimage) {
diff --git a/src/core/SkPictureShader.cpp b/src/core/SkPictureShader.cpp
index c2a0b74e23..30dc47ffd9 100644
--- a/src/core/SkPictureShader.cpp
+++ b/src/core/SkPictureShader.cpp
@@ -93,7 +93,7 @@ struct BitmapShaderRec : public SkResourceCache::Rec {
 
 } // namespace
 
-SkPictureShader::SkPictureShader(sk_sp<const SkPicture> picture, TileMode tmx, TileMode tmy,
+SkPictureShader::SkPictureShader(sk_sp<SkPicture> picture, TileMode tmx, TileMode tmy,
                                  const SkMatrix* localMatrix, const SkRect* tile)
     : INHERITED(localMatrix)
     , fPicture(std::move(picture))
@@ -102,7 +102,7 @@ SkPictureShader::SkPictureShader(sk_sp<const SkPicture> picture, TileMode tmx, T
     , fTmy(tmy) {
 }
 
-sk_sp<SkShader> SkPictureShader::Make(sk_sp<const SkPicture> picture, TileMode tmx, TileMode tmy,
+sk_sp<SkShader> SkPictureShader::Make(sk_sp<SkPicture> picture, TileMode tmx, TileMode tmy,
                                       const SkMatrix* localMatrix, const SkRect* tile) {
     if (!picture || picture->cullRect().isEmpty() || (tile && tile->isEmpty())) {
         return SkShader::MakeEmptyShader();
@@ -223,8 +223,8 @@ sk_sp<SkShader> SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, con
         tileMatrix.setRectToRect(fTile, SkRect::MakeIWH(tileSize.width(), tileSize.height()),
                                  SkMatrix::kFill_ScaleToFit);
 
-        SkAutoTUnref<SkImage> tileImage(
-            SkImage::NewFromPicture(fPicture.get(), tileSize, &tileMatrix, nullptr));
+        sk_sp<SkImage> tileImage(
+            SkImage::MakeFromPicture(fPicture, tileSize, &tileMatrix, nullptr));
         if (!tileImage) {
             return nullptr;
         }
diff --git a/src/core/SkPictureShader.h b/src/core/SkPictureShader.h
index eb9c38b95b..8f167b815e 100644
--- a/src/core/SkPictureShader.h
+++ b/src/core/SkPictureShader.h
@@ -22,7 +22,7 @@ class SkPicture;
  */
 class SkPictureShader : public SkShader {
 public:
-    static sk_sp<SkShader> Make(sk_sp<const SkPicture>, TileMode, TileMode, const SkMatrix*,
+    static sk_sp<SkShader> Make(sk_sp<SkPicture>, TileMode, TileMode, const SkMatrix*,
                                 const SkRect*);
 
     SK_TO_STRING_OVERRIDE()
@@ -42,14 +42,14 @@ protected:
     Context* onCreateContext(const ContextRec&, void* storage) const override;
 
 private:
-    SkPictureShader(sk_sp<const SkPicture>, TileMode, TileMode, const SkMatrix*, const SkRect*);
+    SkPictureShader(sk_sp<SkPicture>, TileMode, TileMode, const SkMatrix*, const SkRect*);
 
     sk_sp<SkShader> refBitmapShader(const SkMatrix&, const SkMatrix* localMatrix,
                                     const int maxTextureSize = 0) const;
 
-    sk_sp<const SkPicture>  fPicture;
-    SkRect                  fTile;
-    TileMode                fTmx, fTmy;
+    sk_sp<SkPicture>    fPicture;
+    SkRect              fTile;
+    TileMode            fTmx, fTmy;
 
     class PictureShaderContext : public SkShader::Context {
     public:
diff --git a/src/core/SkReadBuffer.cpp b/src/core/SkReadBuffer.cpp
index 6823a6cd8e..59d5172f81 100644
--- a/src/core/SkReadBuffer.cpp
+++ b/src/core/SkReadBuffer.cpp
@@ -298,11 +298,11 @@ SkImage* SkReadBuffer::readImage() {
         return nullptr;
     }
 
-    SkAutoTUnref<SkData> encoded(this->readByteArrayAsData());
+    sk_sp<SkData> encoded(this->readByteArrayAsData());
     if (encoded->size() == 0) {
         // The image could not be encoded at serialization time - return an empty placeholder.
-        return SkImage::NewFromGenerator(
-            new EmptyImageGenerator(SkImageInfo::MakeN32Premul(width, height)));
+        return SkImage::MakeFromGenerator(
+            new EmptyImageGenerator(SkImageInfo::MakeN32Premul(width, height))).release();
     }
 
     int originX = this->read32();
@@ -313,13 +313,13 @@ SkImage* SkReadBuffer::readImage() {
     }
 
     const SkIRect subset = SkIRect::MakeXYWH(originX, originY, width, height);
-    SkImage* image = SkImage::NewFromEncoded(encoded, &subset);
+    SkImage* image = SkImage::MakeFromEncoded(std::move(encoded), &subset).release();
     if (image) {
         return image;
     }
 
-    return SkImage::NewFromGenerator(
-            new EmptyImageGenerator(SkImageInfo::MakeN32Premul(width, height)));
+    return SkImage::MakeFromGenerator(
+            new EmptyImageGenerator(SkImageInfo::MakeN32Premul(width, height))).release();
 }
 
 SkTypeface* SkReadBuffer::readTypeface() {
diff --git a/src/core/SkShader.cpp b/src/core/SkShader.cpp
index 7b322fb627..1413a6ee73 100644
--- a/src/core/SkShader.cpp
+++ b/src/core/SkShader.cpp
@@ -238,7 +238,7 @@ sk_sp<SkShader> SkShader::MakeBitmapShader(const SkBitmap& src, TileMode tmx, Ti
     return SkMakeBitmapShader(src, tmx, tmy, localMatrix, nullptr);
 }
 
-sk_sp<SkShader> SkShader::MakePictureShader(sk_sp<const SkPicture> src, TileMode tmx, TileMode tmy,
+sk_sp<SkShader> SkShader::MakePictureShader(sk_sp<SkPicture> src, TileMode tmx, TileMode tmy,
                                             const SkMatrix* localMatrix, const SkRect* tile) {
     return SkPictureShader::Make(std::move(src), tmx, tmy, localMatrix, tile);
 }
@@ -388,6 +388,7 @@ SkShader* SkShader::CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode
 }
 SkShader* SkShader::CreatePictureShader(const SkPicture* src, TileMode tmx, TileMode tmy,
                                      const SkMatrix* localMatrix, const SkRect* tile) {
-    return MakePictureShader(sk_ref_sp(src), tmx, tmy, localMatrix, tile).release();
+    return MakePictureShader(sk_ref_sp(const_cast<SkPicture*>(src)), tmx, tmy,
+                             localMatrix, tile).release();
 }
 #endif
diff --git a/src/image/SkImage.cpp b/src/image/SkImage.cpp
index a41ac83d19..ee4491e0b1 100644
--- a/src/image/SkImage.cpp
+++ b/src/image/SkImage.cpp
@@ -15,6 +15,7 @@
 #include "SkImageShader.h"
 #include "SkImage_Base.h"
 #include "SkNextID.h"
+#include "SkPicture.h"
 #include "SkPixelRef.h"
 #include "SkPixelSerializer.h"
 #include "SkReadPixelsRec.h"
@@ -150,12 +151,12 @@ SkData* SkImage::refEncoded() const {
     return as_IB(this)->onRefEncoded(ctx);
 }
 
-SkImage* SkImage::NewFromEncoded(SkData* encoded, const SkIRect* subset) {
+sk_sp<SkImage> SkImage::MakeFromEncoded(sk_sp<SkData> encoded, const SkIRect* subset) {
     if (nullptr == encoded || 0 == encoded->size()) {
         return nullptr;
     }
-    SkImageGenerator* generator = SkImageGenerator::NewFromEncoded(encoded);
-    return generator ? SkImage::NewFromGenerator(generator, subset) : nullptr;
+    SkImageGenerator* generator = SkImageGenerator::NewFromEncoded(encoded.get());
+    return SkImage::MakeFromGenerator(generator, subset);
 }
 
 const char* SkImage::toString(SkString* str) const {
@@ -164,7 +165,7 @@ const char* SkImage::toString(SkString* str) const {
     return str->c_str();
 }
 
-SkImage* SkImage::newSubset(const SkIRect& subset) const {
+sk_sp<SkImage> SkImage::makeSubset(const SkIRect& subset) const {
     if (subset.isEmpty()) {
         return nullptr;
     }
@@ -176,9 +177,9 @@ SkImage* SkImage::newSubset(const SkIRect& subset) const {
 
     // optimization : return self if the subset == our bounds
     if (bounds == subset) {
-        return SkRef(const_cast<SkImage*>(this));
+        return sk_ref_sp(const_cast<SkImage*>(this));
     }
-    return as_IB(this)->onNewSubset(subset);
+    return as_IB(this)->onMakeSubset(subset);
 }
 
 #if SK_SUPPORT_GPU
@@ -283,7 +284,7 @@ bool SkImage::readYUV8Planes(const SkISize sizes[3], void* const planes[3],
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-SkImage* SkImage::NewFromBitmap(const SkBitmap& bm) {
+sk_sp<SkImage> SkImage::MakeFromBitmap(const SkBitmap& bm) {
     SkPixelRef* pr = bm.pixelRef();
     if (nullptr == pr) {
         return nullptr;
@@ -300,13 +301,13 @@ SkImage* SkImage::NewFromBitmap(const SkBitmap& bm) {
             unrefCopy.reset(tex);
         }
         const SkImageInfo info = bm.info();
-        return new SkImage_Gpu(info.width(), info.height(), bm.getGenerationID(), info.alphaType(),
-                               tex, SkBudgeted::kNo);
+        return sk_make_sp<SkImage_Gpu>(info.width(), info.height(), bm.getGenerationID(),
+                                       info.alphaType(), tex, SkBudgeted::kNo);
     }
 #endif
 
     // This will check for immutable (share or copy)
-    return SkNewImageFromRasterBitmap(bm);
+    return SkMakeImageFromRasterBitmap(bm);
 }
 
 bool SkImage::asLegacyBitmap(SkBitmap* bitmap, LegacyBitmapMode mode) const {
@@ -332,12 +333,13 @@ bool SkImage_Base::onAsLegacyBitmap(SkBitmap* bitmap, LegacyBitmapMode mode) con
     return true;
 }
 
-SkImage* SkImage::NewFromPicture(const SkPicture* picture, const SkISize& dimensions,
-                                 const SkMatrix* matrix, const SkPaint* paint) {
+sk_sp<SkImage> SkImage::MakeFromPicture(sk_sp<SkPicture> picture, const SkISize& dimensions,
+                                        const SkMatrix* matrix, const SkPaint* paint) {
     if (!picture) {
         return nullptr;
     }
-    return NewFromGenerator(SkImageGenerator::NewFromPicture(dimensions, picture, matrix, paint));
+    return MakeFromGenerator(SkImageGenerator::NewFromPicture(dimensions, picture.release(),
+                                                              matrix, paint));
 }
 
 bool SkImage::isLazyGenerated() const {
@@ -348,25 +350,95 @@ bool SkImage::isLazyGenerated() const {
 
 #if !SK_SUPPORT_GPU
 
-SkImage* SkImage::NewTextureFromPixmap(GrContext*, const SkPixmap&, SkBudgeted budgeted) {
+sk_sp<SkImage> SkImage::MakeTextureFromPixmap(GrContext*, const SkPixmap&, SkBudgeted budgeted) {
+    return nullptr;
+}
+
+sk_sp<SkImage> SkImage::MakeFromTexture(GrContext*, const GrBackendTextureDesc&, SkAlphaType,
+                                        TextureReleaseProc, ReleaseContext) {
     return nullptr;
 }
 
-SkImage* SkImage::NewFromTexture(GrContext*, const GrBackendTextureDesc&, SkAlphaType,
-                                 TextureReleaseProc, ReleaseContext) {
+sk_sp<SkImage> SkImage::MakeFromAdoptedTexture(GrContext*, const GrBackendTextureDesc&,
+                                               SkAlphaType) {
     return nullptr;
 }
 
-SkImage* SkImage::NewFromAdoptedTexture(GrContext*, const GrBackendTextureDesc&, SkAlphaType) {
+sk_sp<SkImage> SkImage::MakeFromTextureCopy(GrContext*, const GrBackendTextureDesc&, SkAlphaType) {
     return nullptr;
 }
 
-SkImage* SkImage::NewFromTextureCopy(GrContext*, const GrBackendTextureDesc&, SkAlphaType) {
+sk_sp<SkImage> SkImage::MakeFromYUVTexturesCopy(GrContext* ctx, SkYUVColorSpace space,
+                                                const GrBackendObject yuvTextureHandles[3],
+                                                const SkISize yuvSizes[3],
+                                                GrSurfaceOrigin origin) {
     return nullptr;
 }
 
-SkImage* SkImage::newTextureImage(GrContext*) const {
+sk_sp<SkImage> SkImage::makeTextureImage(GrContext*) const {
     return nullptr;
 }
 
 #endif
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef SK_SUPPORT_LEGACY_IMAGEFACTORY
+SkImage* SkImage::NewRasterCopy(const Info& info, const void* pixels, size_t rowBytes,
+                                SkColorTable* ctable) {
+    return MakeRasterCopy(SkPixmap(info, pixels, rowBytes, ctable)).release();
+}
+
+SkImage* SkImage::NewRasterData(const Info& info, SkData* pixels, size_t rowBytes) {
+    return MakeRasterData(info, sk_ref_sp(pixels), rowBytes).release();
+}
+
+SkImage* SkImage::NewFromRaster(const Info& info, const void* pixels, size_t rowBytes,
+                                RasterReleaseProc proc, ReleaseContext releasectx) {
+    return MakeFromRaster(SkPixmap(info, pixels, rowBytes), proc, releasectx).release();
+}
+
+SkImage* SkImage::NewFromBitmap(const SkBitmap& bm) {
+    return MakeFromBitmap(bm).release();
+}
+
+SkImage* SkImage::NewFromGenerator(SkImageGenerator* gen, const SkIRect* subset) {
+    return MakeFromGenerator(gen, subset).release();
+}
+
+SkImage* SkImage::NewFromEncoded(SkData* encoded, const SkIRect* subset) {
+    return MakeFromEncoded(sk_ref_sp(encoded), subset).release();
+}
+
+SkImage* SkImage::NewFromTexture(GrContext* ctx, const GrBackendTextureDesc& desc, SkAlphaType at,
+                                 TextureReleaseProc proc, ReleaseContext releasectx) {
+    return MakeFromTexture(ctx, desc, at, proc, releasectx).release();
+}
+
+SkImage* SkImage::NewFromAdoptedTexture(GrContext* ctx, const GrBackendTextureDesc& desc,
+                                        SkAlphaType at) {
+    return MakeFromAdoptedTexture(ctx, desc, at).release();
+}
+
+SkImage* SkImage::NewFromTextureCopy(GrContext* ctx, const GrBackendTextureDesc& desc,
+                                     SkAlphaType at) {
+    return MakeFromTextureCopy(ctx, desc, at).release();
+}
+
+SkImage* SkImage::NewFromYUVTexturesCopy(GrContext* ctx, SkYUVColorSpace space,
+                                         const GrBackendObject yuvTextureHandles[3],
+                                         const SkISize yuvSizes[3],
+                                         GrSurfaceOrigin origin) {
+    return MakeFromYUVTexturesCopy(ctx, space, yuvTextureHandles, yuvSizes, origin).release();
+}
+
+SkImage* SkImage::NewFromPicture(const SkPicture* picture, const SkISize& dimensions,
+                                 const SkMatrix* matrix, const SkPaint* paint) {
+    return MakeFromPicture(sk_ref_sp(const_cast<SkPicture*>(picture)), dimensions,
+                                     matrix, paint).release();
+}
+
+SkImage* SkImage::NewTextureFromPixmap(GrContext* ctx, const SkPixmap& pmap, SkBudgeted budgeted) {
+    return MakeTextureFromPixmap(ctx, pmap, budgeted).release();
+}
+#endif
diff --git a/src/image/SkImagePriv.h b/src/image/SkImagePriv.h
index acd0beb475..a625472eaa 100644
--- a/src/image/SkImagePriv.h
+++ b/src/image/SkImagePriv.h
@@ -12,9 +12,9 @@
 #include "SkSurface.h"
 
 // Call this if you explicitly want to use/share this pixelRef in the image
-extern SkImage* SkNewImageFromPixelRef(const SkImageInfo&, SkPixelRef*,
-                                       const SkIPoint& pixelRefOrigin,
-                                       size_t rowBytes);
+extern sk_sp<SkImage> SkMakeImageFromPixelRef(const SkImageInfo&, SkPixelRef*,
+                                              const SkIPoint& pixelRefOrigin,
+                                              size_t rowBytes);
 
 /**
  *  Examines the bitmap to decide if it can share the existing pixelRef, or
@@ -38,7 +38,8 @@ enum ForceCopyMode {
     kNo_ForceCopyMode,
     kYes_ForceCopyMode, // must copy the pixels even if the bitmap is immutable
 };
-extern SkImage* SkNewImageFromRasterBitmap(const SkBitmap&, ForceCopyMode = kNo_ForceCopyMode);
+extern sk_sp<SkImage> SkMakeImageFromRasterBitmap(const SkBitmap&,
+                                                  ForceCopyMode = kNo_ForceCopyMode);
 
 // Given an image created from SkNewImageFromBitmap, return its pixelref. This
 // may be called to see if the surface and the image share the same pixelref,
diff --git a/src/image/SkImage_Base.h b/src/image/SkImage_Base.h
index 9e2efe98b5..ade891f4cb 100644
--- a/src/image/SkImage_Base.h
+++ b/src/image/SkImage_Base.h
@@ -46,7 +46,7 @@ public:
     // Caller must call unref when they are done.
     virtual GrTexture* asTextureRef(GrContext*, const GrTextureParams&) const = 0;
 
-    virtual SkImage* onNewSubset(const SkIRect&) const = 0;
+    virtual sk_sp<SkImage> onMakeSubset(const SkIRect&) const = 0;
 
     // If a ctx is specified, then only gpu-specific formats are requested.
     virtual SkData* onRefEncoded(GrContext*) const { return nullptr; }
diff --git a/src/image/SkImage_Generator.cpp b/src/image/SkImage_Generator.cpp
index 95cc426a43..62b492e288 100644
--- a/src/image/SkImage_Generator.cpp
+++ b/src/image/SkImage_Generator.cpp
@@ -25,7 +25,7 @@ public:
     SkImageCacherator* peekCacherator() const override { return fCache; }
     SkData* onRefEncoded(GrContext*) const override;
     bool isOpaque() const override { return fCache->info().isOpaque(); }
-    SkImage* onNewSubset(const SkIRect&) const override;
+    sk_sp<SkImage> onMakeSubset(const SkIRect&) const override;
     bool getROPixels(SkBitmap*, CachingHint) const override;
     GrTexture* asTextureRef(GrContext*, const GrTextureParams&) const override;
     bool onIsLazyGenerated() const override { return true; }
@@ -73,7 +73,7 @@ GrTexture* SkImage_Generator::asTextureRef(GrContext* ctx, const GrTextureParams
     return fCache->lockAsTexture(ctx, params, this);
 }
 
-SkImage* SkImage_Generator::onNewSubset(const SkIRect& subset) const {
+sk_sp<SkImage> SkImage_Generator::onMakeSubset(const SkIRect& subset) const {
     // TODO: make this lazy, by wrapping the subset inside a new generator or something
     // For now, we do effectively what we did before, make it a raster
 
@@ -86,13 +86,16 @@ SkImage* SkImage_Generator::onNewSubset(const SkIRect& subset) const {
     surface->getCanvas()->clear(0);
     surface->getCanvas()->drawImage(this, SkIntToScalar(-subset.x()), SkIntToScalar(-subset.y()),
                                     nullptr);
-    return surface->newImageSnapshot();
+    return sk_sp<SkImage>(surface->newImageSnapshot());
 }
 
-SkImage* SkImage::NewFromGenerator(SkImageGenerator* generator, const SkIRect* subset) {
+sk_sp<SkImage> SkImage::MakeFromGenerator(SkImageGenerator* generator, const SkIRect* subset) {
+    if (!generator) {
+        return nullptr;
+    }
     SkImageCacherator* cache = SkImageCacherator::NewFromGenerator(generator, subset);
     if (!cache) {
         return nullptr;
     }
-    return new SkImage_Generator(cache);
+    return sk_make_sp<SkImage_Generator>(cache);
 }
diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp
index b87e50ba0a..6494fd1a17 100644
--- a/src/image/SkImage_Gpu.cpp
+++ b/src/image/SkImage_Gpu.cpp
@@ -134,7 +134,7 @@ bool SkImage_Gpu::onReadPixels(const SkImageInfo& info, void* pixels, size_t row
     return true;
 }
 
-SkImage* SkImage_Gpu::onNewSubset(const SkIRect& subset) const {
+sk_sp<SkImage> SkImage_Gpu::onMakeSubset(const SkIRect& subset) const {
     GrContext* ctx = fTexture->getContext();
     GrSurfaceDesc desc = fTexture->desc();
     desc.fWidth = subset.width();
@@ -145,16 +145,16 @@ SkImage* SkImage_Gpu::onNewSubset(const SkIRect& subset) const {
         return nullptr;
     }
     ctx->copySurface(subTx, fTexture, subset, SkIPoint::Make(0, 0));
-    return new SkImage_Gpu(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, fAlphaType, subTx,
-                           fBudgeted);
+    return sk_make_sp<SkImage_Gpu>(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID,
+                                   fAlphaType, subTx, fBudgeted);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-static SkImage* new_wrapped_texture_common(GrContext* ctx, const GrBackendTextureDesc& desc,
-                                           SkAlphaType at, GrWrapOwnership ownership,
-                                           SkImage::TextureReleaseProc releaseProc,
-                                           SkImage::ReleaseContext releaseCtx) {
+static sk_sp<SkImage> new_wrapped_texture_common(GrContext* ctx, const GrBackendTextureDesc& desc,
+                                                 SkAlphaType at, GrWrapOwnership ownership,
+                                                 SkImage::TextureReleaseProc releaseProc,
+                                                 SkImage::ReleaseContext releaseCtx) {
     if (desc.fWidth <= 0 || desc.fHeight <= 0) {
         return nullptr;
     }
@@ -167,21 +167,23 @@ static SkImage* new_wrapped_texture_common(GrContext* ctx, const GrBackendTextur
     }
 
     const SkBudgeted budgeted = SkBudgeted::kNo;
-    return new SkImage_Gpu(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, at, tex, budgeted);
+    return sk_make_sp<SkImage_Gpu>(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID,
+                                   at, tex, budgeted);
 }
 
-SkImage* SkImage::NewFromTexture(GrContext* ctx, const GrBackendTextureDesc& desc, SkAlphaType at,
-                                 TextureReleaseProc releaseP, ReleaseContext releaseC) {
+sk_sp<SkImage> SkImage::MakeFromTexture(GrContext* ctx, const GrBackendTextureDesc& desc,
+                                        SkAlphaType at, TextureReleaseProc releaseP,
+                                        ReleaseContext releaseC) {
     return new_wrapped_texture_common(ctx, desc, at, kBorrow_GrWrapOwnership, releaseP, releaseC);
 }
 
-SkImage* SkImage::NewFromAdoptedTexture(GrContext* ctx, const GrBackendTextureDesc& desc,
-                                        SkAlphaType at) {
+sk_sp<SkImage> SkImage::MakeFromAdoptedTexture(GrContext* ctx, const GrBackendTextureDesc& desc,
+                                               SkAlphaType at) {
     return new_wrapped_texture_common(ctx, desc, at, kAdopt_GrWrapOwnership, nullptr, nullptr);
 }
 
-SkImage* SkImage::NewFromTextureCopy(GrContext* ctx, const GrBackendTextureDesc& desc,
-                                     SkAlphaType at) {
+sk_sp<SkImage> SkImage::MakeFromTextureCopy(GrContext* ctx, const GrBackendTextureDesc& desc,
+                                            SkAlphaType at) {
     if (desc.fWidth <= 0 || desc.fHeight <= 0) {
         return nullptr;
     }
@@ -197,14 +199,14 @@ SkImage* SkImage::NewFromTextureCopy(GrContext* ctx, const GrBackendTextureDesc&
         return nullptr;
     }
 
-    return new SkImage_Gpu(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, at, dst,
-                           SkBudgeted::kYes);
+    return sk_make_sp<SkImage_Gpu>(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, at, dst,
+                                   SkBudgeted::kYes);
 }
 
-SkImage* SkImage::NewFromYUVTexturesCopy(GrContext* ctx , SkYUVColorSpace colorSpace,
-                                         const GrBackendObject yuvTextureHandles[3],
-                                         const SkISize yuvSizes[3],
-                                         GrSurfaceOrigin origin) {
+sk_sp<SkImage> SkImage::MakeFromYUVTexturesCopy(GrContext* ctx , SkYUVColorSpace colorSpace,
+                                                const GrBackendObject yuvTextureHandles[3],
+                                                const SkISize yuvSizes[3],
+                                                GrSurfaceOrigin origin) {
     const SkBudgeted budgeted = SkBudgeted::kYes;
 
     if (yuvSizes[0].fWidth <= 0 || yuvSizes[0].fHeight <= 0 ||
@@ -275,25 +277,25 @@ SkImage* SkImage::NewFromYUVTexturesCopy(GrContext* ctx , SkYUVColorSpace colorS
 
     drawContext->drawRect(GrClip::WideOpen(), paint, SkMatrix::I(), rect);
     ctx->flushSurfaceWrites(dst);
-    return new SkImage_Gpu(dstDesc.fWidth, dstDesc.fHeight, kNeedNewImageUniqueID,
-                           kOpaque_SkAlphaType, dst, budgeted);
+    return sk_make_sp<SkImage_Gpu>(dstDesc.fWidth, dstDesc.fHeight, kNeedNewImageUniqueID,
+                                   kOpaque_SkAlphaType, dst, budgeted);
 }
 
-static SkImage* create_image_from_maker(GrTextureMaker* maker, SkAlphaType at, uint32_t id) {
+static sk_sp<SkImage> create_image_from_maker(GrTextureMaker* maker, SkAlphaType at, uint32_t id) {
     SkAutoTUnref<GrTexture> texture(maker->refTextureForParams(GrTextureParams::ClampNoFilter()));
     if (!texture) {
         return nullptr;
     }
-    return new SkImage_Gpu(texture->width(), texture->height(), id, at, texture,
-                           SkBudgeted::kNo);
+    return sk_make_sp<SkImage_Gpu>(texture->width(), texture->height(), id, at, texture,
+                                   SkBudgeted::kNo);
 }
 
-SkImage* SkImage::newTextureImage(GrContext *context) const {
+sk_sp<SkImage> SkImage::makeTextureImage(GrContext *context) const {
     if (!context) {
         return nullptr;
     }
     if (GrTexture* peek = as_IB(this)->peekTexture()) {
-        return peek->getContext() == context ? SkRef(const_cast<SkImage*>(this)) : nullptr;
+        return peek->getContext() == context ? sk_ref_sp(const_cast<SkImage*>(this)) : nullptr;
     }
     // No way to check whether a image is premul or not?
     SkAlphaType at = this->isOpaque() ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
@@ -310,8 +312,8 @@ SkImage* SkImage::newTextureImage(GrContext *context) const {
     return create_image_from_maker(&maker, at, this->uniqueID());
 }
 
-SkImage* SkImage::NewTextureFromPixmap(GrContext* ctx, const SkPixmap& pixmap,
-                                       SkBudgeted budgeted) {
+sk_sp<SkImage> SkImage::MakeTextureFromPixmap(GrContext* ctx, const SkPixmap& pixmap,
+                                              SkBudgeted budgeted) {
     if (!ctx) {
         return nullptr;
     }
@@ -319,8 +321,8 @@ SkImage* SkImage::NewTextureFromPixmap(GrContext* ctx, const SkPixmap& pixmap,
     if (!texture) {
         return nullptr;
     }
-    return new SkImage_Gpu(texture->width(), texture->height(), kNeedNewImageUniqueID,
-                           pixmap.alphaType(), texture, budgeted);
+    return sk_make_sp<SkImage_Gpu>(texture->width(), texture->height(), kNeedNewImageUniqueID,
+                                   pixmap.alphaType(), texture, budgeted);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/image/SkImage_Gpu.h b/src/image/SkImage_Gpu.h
index c640322a65..8f59af14a4 100644
--- a/src/image/SkImage_Gpu.h
+++ b/src/image/SkImage_Gpu.h
@@ -35,7 +35,7 @@ public:
 
     bool getROPixels(SkBitmap*, CachingHint) const override;
     GrTexture* asTextureRef(GrContext* ctx, const GrTextureParams& params) const override;
-    SkImage* onNewSubset(const SkIRect&) const override;
+    sk_sp<SkImage> onMakeSubset(const SkIRect&) const override;
 
     GrTexture* peekTexture() const override { return fTexture; }
     bool isOpaque() const override;
diff --git a/src/image/SkImage_Raster.cpp b/src/image/SkImage_Raster.cpp
index 5bd0e1d8f1..7f2f5c07ef 100644
--- a/src/image/SkImage_Raster.cpp
+++ b/src/image/SkImage_Raster.cpp
@@ -63,7 +63,7 @@ public:
         return true;
     }
 
-    SkImage_Raster(const SkImageInfo&, SkData*, size_t rb, SkColorTable*);
+    SkImage_Raster(const SkImageInfo&, sk_sp<SkData>, size_t rb, SkColorTable*);
     virtual ~SkImage_Raster();
 
     bool onReadPixels(const SkImageInfo&, void*, size_t, int srcX, int srcY, CachingHint) const override;
@@ -71,7 +71,7 @@ public:
     SkData* onRefEncoded(GrContext*) const override;
     bool getROPixels(SkBitmap*, CachingHint) const override;
     GrTexture* asTextureRef(GrContext*, const GrTextureParams&) const override;
-    SkImage* onNewSubset(const SkIRect&) const override;
+    sk_sp<SkImage> onMakeSubset(const SkIRect&) const override;
 
     // exposed for SkSurface_Raster via SkNewImageFromPixelRef
     SkImage_Raster(const SkImageInfo&, SkPixelRef*, const SkIPoint& origin, size_t rowBytes);
@@ -110,14 +110,13 @@ static void release_data(void* addr, void* context) {
     data->unref();
 }
 
-SkImage_Raster::SkImage_Raster(const Info& info, SkData* data, size_t rowBytes,
+SkImage_Raster::SkImage_Raster(const Info& info, sk_sp<SkData> data, size_t rowBytes,
                                SkColorTable* ctable)
     : INHERITED(info.width(), info.height(), kNeedNewImageUniqueID)
 {
-    data->ref();
     void* addr = const_cast<void*>(data->data());
 
-    fBitmap.installPixels(info, addr, rowBytes, ctable, release_data, data);
+    fBitmap.installPixels(info, addr, rowBytes, ctable, release_data, data.release());
     fBitmap.setImmutable();
     fBitmap.lockPixels();
 }
@@ -173,7 +172,7 @@ GrTexture* SkImage_Raster::asTextureRef(GrContext* ctx, const GrTextureParams& p
     return nullptr;
 }
 
-SkImage* SkImage_Raster::onNewSubset(const SkIRect& subset) const {
+sk_sp<SkImage> SkImage_Raster::onMakeSubset(const SkIRect& subset) const {
     // TODO : could consider heurist of sharing pixels, if subset is pretty close to complete
 
     SkImageInfo info = SkImageInfo::MakeN32(subset.width(), subset.height(), fBitmap.alphaType());
@@ -184,25 +183,26 @@ SkImage* SkImage_Raster::onNewSubset(const SkIRect& subset) const {
     surface->getCanvas()->clear(0);
     surface->getCanvas()->drawImage(this, SkIntToScalar(-subset.x()), SkIntToScalar(-subset.y()),
                                     nullptr);
-    return surface->newImageSnapshot();
+    return sk_sp<SkImage>(surface->newImageSnapshot());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkImage* SkImage::NewRasterCopy(const SkImageInfo& info, const void* pixels, size_t rowBytes,
-                                SkColorTable* ctable) {
+sk_sp<SkImage> SkImage::MakeRasterCopy(const SkPixmap& pmap) {
     size_t size;
-    if (!SkImage_Raster::ValidArgs(info, rowBytes, ctable != nullptr, &size) || !pixels) {
+    if (!SkImage_Raster::ValidArgs(pmap.info(), pmap.rowBytes(),
+                                   pmap.ctable() != nullptr, &size) || !pmap.addr()) {
         return nullptr;
     }
 
     // Here we actually make a copy of the caller's pixel data
-    SkAutoDataUnref data(SkData::NewWithCopy(pixels, size));
-    return new SkImage_Raster(info, data, rowBytes, ctable);
+    sk_sp<SkData> data(SkData::NewWithCopy(pmap.addr(), size));
+    return sk_make_sp<SkImage_Raster>(pmap.info(), std::move(data), pmap.rowBytes(), pmap.ctable());
 }
 
 
-SkImage* SkImage::NewRasterData(const SkImageInfo& info, SkData* data, size_t rowBytes) {
+sk_sp<SkImage> SkImage::MakeRasterData(const SkImageInfo& info, sk_sp<SkData> data,
+                                       size_t rowBytes) {
     size_t size;
     if (!SkImage_Raster::ValidArgs(info, rowBytes, false, &size) || !data) {
         return nullptr;
@@ -214,30 +214,29 @@ SkImage* SkImage::NewRasterData(const SkImageInfo& info, SkData* data, size_t ro
     }
 
     SkColorTable* ctable = nullptr;
-    return new SkImage_Raster(info, data, rowBytes, ctable);
+    return sk_make_sp<SkImage_Raster>(info, std::move(data), rowBytes, ctable);
 }
 
-SkImage* SkImage::NewFromRaster(const SkImageInfo& info, const void* pixels, size_t rowBytes,
-                                RasterReleaseProc proc, ReleaseContext ctx) {
+sk_sp<SkImage> SkImage::MakeFromRaster(const SkPixmap& pmap, RasterReleaseProc proc,
+                                       ReleaseContext ctx) {
     size_t size;
-    if (!SkImage_Raster::ValidArgs(info, rowBytes, false, &size) || !pixels) {
+    if (!SkImage_Raster::ValidArgs(pmap.info(), pmap.rowBytes(), false, &size) || !pmap.addr()) {
         return nullptr;
     }
 
-    SkColorTable* ctable = nullptr;
-    SkAutoDataUnref data(SkData::NewWithProc(pixels, size, proc, ctx));
-    return new SkImage_Raster(info, data, rowBytes, ctable);
+    sk_sp<SkData> data(SkData::NewWithProc(pmap.addr(), size, proc, ctx));
+    return sk_make_sp<SkImage_Raster>(pmap.info(), std::move(data), pmap.rowBytes(), pmap.ctable());
 }
 
-SkImage* SkNewImageFromPixelRef(const SkImageInfo& info, SkPixelRef* pr,
-                                const SkIPoint& pixelRefOrigin, size_t rowBytes) {
+sk_sp<SkImage> SkMakeImageFromPixelRef(const SkImageInfo& info, SkPixelRef* pr,
+                                       const SkIPoint& pixelRefOrigin, size_t rowBytes) {
     if (!SkImage_Raster::ValidArgs(info, rowBytes, false, nullptr)) {
         return nullptr;
     }
-    return new SkImage_Raster(info, pr, pixelRefOrigin, rowBytes);
+    return sk_make_sp<SkImage_Raster>(info, pr, pixelRefOrigin, rowBytes);
 }
 
-SkImage* SkNewImageFromRasterBitmap(const SkBitmap& bm, ForceCopyMode forceCopy) {
+sk_sp<SkImage> SkMakeImageFromRasterBitmap(const SkBitmap& bm, ForceCopyMode forceCopy) {
     SkASSERT(nullptr == bm.getTexture());
 
     bool hasColorTable = false;
@@ -250,16 +249,16 @@ SkImage* SkNewImageFromRasterBitmap(const SkBitmap& bm, ForceCopyMode forceCopy)
         return nullptr;
     }
 
-    SkImage* image = nullptr;
+    sk_sp<SkImage> image;
     if (kYes_ForceCopyMode == forceCopy || !bm.isImmutable()) {
         SkBitmap tmp(bm);
         tmp.lockPixels();
-        if (tmp.getPixels()) {
-            image = SkImage::NewRasterCopy(tmp.info(), tmp.getPixels(), tmp.rowBytes(),
-                                           tmp.getColorTable());
+        SkPixmap pmap;
+        if (tmp.getPixels() && tmp.peekPixels(&pmap)) {
+            image = SkImage::MakeRasterCopy(pmap);
         }
     } else {
-        image = new SkImage_Raster(bm);
+        image = sk_make_sp<SkImage_Raster>(bm);
     }
     return image;
 }
diff --git a/src/image/SkSurface_Raster.cpp b/src/image/SkSurface_Raster.cpp
index d07e94998f..192415341f 100644
--- a/src/image/SkSurface_Raster.cpp
+++ b/src/image/SkSurface_Raster.cpp
@@ -131,7 +131,7 @@ SkImage* SkSurface_Raster::onNewImageSnapshot(SkBudgeted, ForceCopyMode forceCop
 
     // Our pixels are in memory, so read access on the snapshot SkImage could be cheap.
     // Lock the shared pixel ref to ensure peekPixels() is usable.
-    return SkNewImageFromRasterBitmap(fBitmap, forceCopyMode);
+    return SkMakeImageFromRasterBitmap(fBitmap, forceCopyMode).release();
 }
 
 void SkSurface_Raster::onRestoreBackingMutability() {
diff --git a/src/utils/SkBitmapSourceDeserializer.cpp b/src/utils/SkBitmapSourceDeserializer.cpp
index bb783bfeef..eb66fd909d 100644
--- a/src/utils/SkBitmapSourceDeserializer.cpp
+++ b/src/utils/SkBitmapSourceDeserializer.cpp
@@ -29,6 +29,5 @@ SkFlattenable* SkBitmapSourceDeserializer::CreateProc(SkReadBuffer& buffer) {
     }
     bitmap.setImmutable();
 
-    SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(bitmap));
-    return SkImageSource::Create(image, src, dst, filterQuality);
+    return SkImageSource::Create(SkImage::MakeFromBitmap(bitmap).get(), src, dst, filterQuality);
 }