add Make variations to return SkImage by sk_sp

src/image/SkImage.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkBitmapCache.h"
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkImageEncoder.h"
 #include "SkImageGenerator.h"
 #include "SkImagePriv.h"
 #include "SkImageShader.h"
 #include "SkImage_Base.h"
 #include "SkNextID.h"
+#include "SkPicture.h"
 #include "SkPixelRef.h"
 #include "SkPixelSerializer.h"
 #include "SkReadPixelsRec.h"
 #include "SkString.h"
 #include "SkSurface.h"
 
 #if SK_SUPPORT_GPU
 #include "GrTexture.h"
 #include "GrContext.h"
 #include "SkImage_Gpu.h"
@@ skipping 115 matching lines @@
     }
 
     return nullptr;
 }
 
 SkData* SkImage::refEncoded() const {
     GrContext* ctx = nullptr;   // should we allow the caller to pass in a ctx?
     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 generator ? SkImage::MakeFromGenerator(generator, subset) : nullptr;

[f(malita), 2016/03/10 18:12:15]

sk_sp<SkImageGenerator> generator =...
SkImage::MakeFromGenerator(std::move(generator)...)
?

Maybe also move the null check to SkImage::MakeFromGenerator()?

[reed1, 2016/03/10 19:12:56]

Generators are not reference counted.

null-check moved.

[f(malita), 2016/03/10 19:24:56]

doh :)

 }
 
 const char* SkImage::toString(SkString* str) const {
     str->appendf("image: (id:%d (%d, %d) %s)", this->uniqueID(), this->width(), this->height(),
                  this->isOpaque() ? "opaque" : "");
     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;
     }
 
     const SkIRect bounds = SkIRect::MakeWH(this->width(), this->height());
     if (!bounds.contains(subset)) {
         return nullptr;
     }
 
     // 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
 
 GrTexture* SkImage::getTexture() const {
     return as_IB(this)->peekTexture();
 }
 
 bool SkImage::isTextureBacked() const { return SkToBool(as_IB(this)->peekTexture()); }
 
@@ skipping 84 matching lines @@
         if (GrTextureToYUVPlanes(texture, sizes, planes, rowBytes, colorSpace)) {
             return true;
         }
     }
 #endif
     return SkRGBAToYUV(this, sizes, planes, rowBytes, colorSpace);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-SkImage* SkImage::NewFromBitmap(const SkBitmap& bm) {
+sk_sp<SkImage> SkImage::MakeFromBitmap(const SkBitmap& bm) {
     SkPixelRef* pr = bm.pixelRef();
     if (nullptr == pr) {
         return nullptr;
     }
 
 #if SK_SUPPORT_GPU
     if (GrTexture* tex = pr->getTexture()) {
         SkAutoTUnref<GrTexture> unrefCopy;
         if (!bm.isImmutable()) {
             tex = GrDeepCopyTexture(tex, SkBudgeted::kNo);
             if (nullptr == tex) {
                 return nullptr;
             }
             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 {
     return as_IB(this)->onAsLegacyBitmap(bitmap, mode);
 }
 
 bool SkImage_Base::onAsLegacyBitmap(SkBitmap* bitmap, LegacyBitmapMode mode) const {
     // As the base-class, all we can do is make a copy (regardless of mode).
     // Subclasses that want to be more optimal should override.
     SkImageInfo info = SkImageInfo::MakeN32(this->width(), this->height(),
                                     this->isOpaque() ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
     if (!bitmap->tryAllocPixels(info)) {
         return false;
     }
     if (!this->readPixels(bitmap->info(), bitmap->getPixels(), bitmap->rowBytes(), 0, 0)) {
         bitmap->reset();
         return false;
     }
 
     if (kRO_LegacyBitmapMode == mode) {
         bitmap->setImmutable();
     }
     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 {
     return as_IB(this)->onIsLazyGenerated();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 
 #if !SK_SUPPORT_GPU
 
-SkImage* SkImage::NewTextureFromPixmap(GrContext*, const SkPixmap&, SkBudgeted budgeted) {
+sk_sp<SkImage> SkImage::MakeTextureFromPixmap(GrContext*, const SkPixmap&, SkBudgeted budgeted) {
     return nullptr;
 }
 
-SkImage* SkImage::NewFromTexture(GrContext*, const GrBackendTextureDesc&, SkAlphaType,
-                                 TextureReleaseProc, ReleaseContext) {
+sk_sp<SkImage> SkImage::MakeFromTexture(GrContext*, const GrBackendTextureDesc&, SkAlphaType,
+                                        TextureReleaseProc, ReleaseContext) {
     return nullptr;
 }
 
-SkImage* SkImage::NewFromAdoptedTexture(GrContext*, const GrBackendTextureDesc&, SkAlphaType) {
+sk_sp<SkImage> SkImage::MakeFromAdoptedTexture(GrContext*, const GrBackendTextureDesc&,
+                                               SkAlphaType) {
     return nullptr;
 }
 
-SkImage* SkImage::NewFromTextureCopy(GrContext*, const GrBackendTextureDesc&, SkAlphaType) {
+sk_sp<SkImage> SkImage::MakeFromTextureCopy(GrContext*, const GrBackendTextureDesc&, SkAlphaType) {
     return nullptr;
 }
 
-SkImage* SkImage::newTextureImage(GrContext*) const {
+sk_sp<SkImage> SkImage::MakeFromYUVTexturesCopy(GrContext* ctx, SkYUVColorSpace space,
+                                                const GrBackendObject yuvTextureHandles[3],
+                                                const SkISize yuvSizes[3],
+                                                GrSurfaceOrigin origin) {
+    return nullptr;
+}
+
+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