Revert "Revert of add Make variations to return SkImage by sk_sp (patchset #5 id:80001 of https://codereview.chromium.org/1778393002/ )"
Fix was to call get() instead of release() when passing the sp to a bare-ptr method.
This reverts commit e683c56115a210b5993df9294260bb147b408bfa.
BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1789443002
TBR=
Review URL: https://codereview.chromium.org/1789443002
diff --git a/src/c/sk_surface.cpp b/src/c/sk_surface.cpp
index f7fa30f..6bd62a9 100644
--- a/src/c/sk_surface.cpp
+++ b/src/c/sk_surface.cpp
@@ -224,12 +224,12 @@
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 c2a0b74..30dc47f 100644
--- a/src/core/SkPictureShader.cpp
+++ b/src/core/SkPictureShader.cpp
@@ -93,7 +93,7 @@
} // 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 @@
, 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 @@
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 eb9c38b..8f167b8 100644
--- a/src/core/SkPictureShader.h
+++ b/src/core/SkPictureShader.h
@@ -22,7 +22,7 @@
*/
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 @@
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 6823a6c..59d5172 100644
--- a/src/core/SkReadBuffer.cpp
+++ b/src/core/SkReadBuffer.cpp
@@ -298,11 +298,11 @@
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 @@
}
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 7b322fb..1413a6e 100644
--- a/src/core/SkShader.cpp
+++ b/src/core/SkShader.cpp
@@ -238,7 +238,7 @@
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::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 a41ac83..5586069 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 @@
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 @@
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 @@
// 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 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
-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 @@
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 @@
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.get(),
+ matrix, paint));
}
bool SkImage::isLazyGenerated() const {
@@ -348,25 +350,95 @@
#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
diff --git a/src/image/SkImagePriv.h b/src/image/SkImagePriv.h
index acd0beb..a625472 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 @@
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 9e2efe9..ade891f 100644
--- a/src/image/SkImage_Base.h
+++ b/src/image/SkImage_Base.h
@@ -46,7 +46,7 @@
// 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 95cc426..62b492e 100644
--- a/src/image/SkImage_Generator.cpp
+++ b/src/image/SkImage_Generator.cpp
@@ -25,7 +25,7 @@
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 @@
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 @@
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 b87e50b..6494fd1 100644
--- a/src/image/SkImage_Gpu.cpp
+++ b/src/image/SkImage_Gpu.cpp
@@ -134,7 +134,7 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 c640322..8f59af1 100644
--- a/src/image/SkImage_Gpu.h
+++ b/src/image/SkImage_Gpu.h
@@ -35,7 +35,7 @@
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 5bd0e1d..7f2f5c0 100644
--- a/src/image/SkImage_Raster.cpp
+++ b/src/image/SkImage_Raster.cpp
@@ -63,7 +63,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 d07e949..1924153 100644
--- a/src/image/SkSurface_Raster.cpp
+++ b/src/image/SkSurface_Raster.cpp
@@ -131,7 +131,7 @@
// 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 bb783bf..eb66fd9 100644
--- a/src/utils/SkBitmapSourceDeserializer.cpp
+++ b/src/utils/SkBitmapSourceDeserializer.cpp
@@ -29,6 +29,5 @@
}
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);
}