return and take SkImageGenerator as unique_ptr
BUG=skia:
Change-Id: I4bc11042dd1dbf1eabd40af206027bc65acc3186
Reviewed-on: https://skia-review.googlesource.com/8444
Commit-Queue: Mike Reed <reed@google.com>
Reviewed-by: Matt Sarett <msarett@google.com>
Reviewed-by: Brian Osman <brianosman@google.com>
diff --git a/dm/DMSrcSink.cpp b/dm/DMSrcSink.cpp
index 3b849c1..d28c3a2 100644
--- a/dm/DMSrcSink.cpp
+++ b/dm/DMSrcSink.cpp
@@ -907,7 +907,7 @@
std::unique_ptr<SkImageGenerator> gen(nullptr);
switch (fMode) {
case kCodec_Mode:
- gen.reset(SkCodecImageGenerator::NewFromEncodedCodec(encoded.get()));
+ gen = SkCodecImageGenerator::MakeFromEncodedCodec(encoded);
if (!gen) {
return "Could not create codec image generator.";
}
@@ -931,7 +931,7 @@
// Test deferred decoding path on GPU
if (fIsGpu) {
- sk_sp<SkImage> image(SkImage::MakeFromGenerator(gen.release(), nullptr));
+ sk_sp<SkImage> image(SkImage::MakeFromGenerator(std::move(gen), nullptr));
if (!image) {
return "Could not create image from codec image generator.";
}
diff --git a/gm/image_pict.cpp b/gm/image_pict.cpp
index 286470d..387ceb8 100644
--- a/gm/image_pict.cpp
+++ b/gm/image_pict.cpp
@@ -9,6 +9,7 @@
#include "SkCanvas.h"
#include "SkImage.h"
#include "SkImageCacherator.h"
+#include "SkMakeUnique.h"
#include "SkPictureRecorder.h"
#include "SkSurface.h"
@@ -107,10 +108,10 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
-static SkImageGenerator* make_pic_generator(GrContext*, SkPicture* pic) {
+static std::unique_ptr<SkImageGenerator> make_pic_generator(GrContext*, sk_sp<SkPicture> pic) {
SkMatrix matrix;
matrix.setTranslate(-100, -100);
- return SkImageGenerator::NewFromPicture(SkISize::Make(100, 100), pic, &matrix, nullptr,
+ return SkImageGenerator::MakeFromPicture({ 100, 100 }, std::move(pic), &matrix, nullptr,
SkImage::BitDepth::kU8,
SkColorSpace::MakeSRGB());
}
@@ -150,14 +151,14 @@
private:
SkBitmap fBM;
};
-static SkImageGenerator* make_ras_generator(GrContext*, SkPicture* pic) {
+static std::unique_ptr<SkImageGenerator> make_ras_generator(GrContext*, sk_sp<SkPicture> pic) {
SkBitmap bm;
bm.allocN32Pixels(100, 100);
SkCanvas canvas(bm);
canvas.clear(0);
canvas.translate(-100, -100);
canvas.drawPicture(pic);
- return new RasterGenerator(bm);
+ return skstd::make_unique<RasterGenerator>(bm);
}
// so we can create a color-table
@@ -181,7 +182,7 @@
return index;
}
-static SkImageGenerator* make_ctable_generator(GrContext*, SkPicture* pic) {
+static std::unique_ptr<SkImageGenerator> make_ctable_generator(GrContext*, sk_sp<SkPicture> pic) {
SkBitmap bm;
bm.allocN32Pixels(100, 100);
SkCanvas canvas(bm);
@@ -205,7 +206,7 @@
*bm2.getAddr8(x, y) = find_closest(*bm.getAddr32(x, y), colors, count);
}
}
- return new RasterGenerator(bm2);
+ return skstd::make_unique<RasterGenerator>(bm2);
}
class EmptyGenerator : public SkImageGenerator {
@@ -216,7 +217,7 @@
#if SK_SUPPORT_GPU
class TextureGenerator : public SkImageGenerator {
public:
- TextureGenerator(GrContext* ctx, const SkImageInfo& info, SkPicture* pic)
+ TextureGenerator(GrContext* ctx, const SkImageInfo& info, sk_sp<SkPicture> pic)
: SkImageGenerator(info)
, fCtx(SkRef(ctx)) {
@@ -276,25 +277,26 @@
sk_sp<GrContext> fCtx;
sk_sp<GrSurfaceProxy> fProxy;
};
-static SkImageGenerator* make_tex_generator(GrContext* ctx, SkPicture* pic) {
+static std::unique_ptr<SkImageGenerator> make_tex_generator(GrContext* ctx, sk_sp<SkPicture> pic) {
const SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
if (!ctx) {
- return new EmptyGenerator(info);
+ return skstd::make_unique<EmptyGenerator>(info);
}
- return new TextureGenerator(ctx, info, pic);
+ return skstd::make_unique<TextureGenerator>(ctx, info, pic);
}
#endif
class ImageCacheratorGM : public skiagm::GM {
SkString fName;
- SkImageGenerator* (*fFactory)(GrContext*, SkPicture*);
+ std::unique_ptr<SkImageGenerator> (*fFactory)(GrContext*, sk_sp<SkPicture>);
sk_sp<SkPicture> fPicture;
std::unique_ptr<SkImageCacherator> fCache;
std::unique_ptr<SkImageCacherator> fCacheSubset;
public:
- ImageCacheratorGM(const char suffix[], SkImageGenerator* (*factory)(GrContext*, SkPicture*))
+ ImageCacheratorGM(const char suffix[],
+ std::unique_ptr<SkImageGenerator> (*factory)(GrContext*, sk_sp<SkPicture>))
: fFactory(factory)
{
fName.printf("image-cacherator-from-%s", suffix);
@@ -317,15 +319,15 @@
}
void makeCaches(GrContext* ctx) {
- auto gen = fFactory(ctx, fPicture.get());
+ auto gen = fFactory(ctx, fPicture);
SkDEBUGCODE(const uint32_t genID = gen->uniqueID();)
- fCache.reset(SkImageCacherator::NewFromGenerator(gen));
+ fCache.reset(SkImageCacherator::NewFromGenerator(std::move(gen)));
const SkIRect subset = SkIRect::MakeLTRB(50, 50, 100, 100);
- gen = fFactory(ctx, fPicture.get());
+ gen = fFactory(ctx, fPicture);
SkDEBUGCODE(const uint32_t genSubsetID = gen->uniqueID();)
- fCacheSubset.reset(SkImageCacherator::NewFromGenerator(gen, &subset));
+ fCacheSubset.reset(SkImageCacherator::NewFromGenerator(std::move(gen), &subset));
// whole caches should have the same ID as the generator. Subsets should be diff
SkASSERT(fCache->uniqueID() == genID);
diff --git a/gm/imagemasksubset.cpp b/gm/imagemasksubset.cpp
index 80e63f6..8028278 100644
--- a/gm/imagemasksubset.cpp
+++ b/gm/imagemasksubset.cpp
@@ -9,6 +9,7 @@
#include "SkCanvas.h"
#include "SkImage.h"
#include "SkImageGenerator.h"
+#include "SkMakeUnique.h"
#include "SkSurface.h"
#include "sk_tool_utils.h"
@@ -59,7 +60,7 @@
// SkImage_Generator
[](SkCanvas*, const SkImageInfo& info) -> sk_sp<SkImage> {
- return SkImage::MakeFromGenerator(new MaskGenerator(info));
+ return SkImage::MakeFromGenerator(skstd::make_unique<MaskGenerator>(info));
},
};
diff --git a/gm/pictureimagegenerator.cpp b/gm/pictureimagegenerator.cpp
index 3f8553c..1cf3426 100644
--- a/gm/pictureimagegenerator.cpp
+++ b/gm/pictureimagegenerator.cpp
@@ -153,10 +153,10 @@
if (configs[i].scaleY < 0) {
m.postTranslate(0, SkIntToScalar(configs[i].size.height()));
}
- std::unique_ptr<SkImageGenerator> gen(
- SkImageGenerator::NewFromPicture(configs[i].size, fPicture.get(), &m,
+ std::unique_ptr<SkImageGenerator> gen =
+ SkImageGenerator::MakeFromPicture(configs[i].size, fPicture, &m,
p.getAlpha() != 255 ? &p : nullptr,
- SkImage::BitDepth::kU8, srgbColorSpace));
+ SkImage::BitDepth::kU8, srgbColorSpace);
SkImageInfo bmInfo = gen->getInfo().makeColorSpace(canvas->imageInfo().refColorSpace());
diff --git a/gn/android_framework_defines.gni b/gn/android_framework_defines.gni
index 17a566b..15e167d 100644
--- a/gn/android_framework_defines.gni
+++ b/gn/android_framework_defines.gni
@@ -17,4 +17,5 @@
"SK_SUPPORT_LEGACY_EMBOSSMASKFILTER",
"SK_SUPPORT_EXOTIC_CLIPOPS",
"SK_SUPPORT_LEGACY_SCALARMUL",
+ "SK_SUPPORT_BARE_PTR_IMAGEGENERATOR",
]
diff --git a/include/core/SkGraphics.h b/include/core/SkGraphics.h
index d5a730d..bf8228b 100644
--- a/include/core/SkGraphics.h
+++ b/include/core/SkGraphics.h
@@ -8,7 +8,7 @@
#ifndef SkGraphics_DEFINED
#define SkGraphics_DEFINED
-#include "SkTypes.h"
+#include "SkRefCnt.h"
class SkData;
class SkImageGenerator;
@@ -157,7 +157,8 @@
*/
static void SetTLSFontCacheLimit(size_t bytes);
- typedef SkImageGenerator* (*ImageGeneratorFromEncodedFactory)(SkData*);
+ typedef std::unique_ptr<SkImageGenerator>
+ (*ImageGeneratorFromEncodedDataFactory)(sk_sp<SkData>);
/**
* To instantiate images from encoded data, first looks at this runtime function-ptr. If it
@@ -166,8 +167,15 @@
*
* Returns the previous factory (which could be NULL).
*/
+ static ImageGeneratorFromEncodedDataFactory
+ SetImageGeneratorFromEncodedDataFactory(ImageGeneratorFromEncodedDataFactory);
+
+#ifdef SK_SUPPORT_BARE_PTR_IMAGEGENERATOR
+ typedef SkImageGenerator* (*ImageGeneratorFromEncodedFactory)(SkData*);
static ImageGeneratorFromEncodedFactory
- SetImageGeneratorFromEncodedFactory(ImageGeneratorFromEncodedFactory);
+ SetImageGeneratorFromEncodedFactory(ImageGeneratorFromEncodedFactory);
+#endif
+
};
class SkAutoGraphics {
diff --git a/include/core/SkImage.h b/include/core/SkImage.h
index aaafb44..444ce68 100644
--- a/include/core/SkImage.h
+++ b/include/core/SkImage.h
@@ -73,7 +73,11 @@
*
* If a subset is specified, it must be contained within the generator's bounds.
*/
+ static sk_sp<SkImage> MakeFromGenerator(std::unique_ptr<SkImageGenerator>,
+ const SkIRect* subset = nullptr);
+#ifdef SK_SUPPORT_BARE_PTR_IMAGEGENERATOR
static sk_sp<SkImage> MakeFromGenerator(SkImageGenerator*, const SkIRect* subset = nullptr);
+#endif
/**
* Construct a new SkImage based on the specified encoded data. Returns NULL on failure,
diff --git a/include/core/SkImageGenerator.h b/include/core/SkImageGenerator.h
index a8a858d..44d5943 100644
--- a/include/core/SkImageGenerator.h
+++ b/include/core/SkImageGenerator.h
@@ -146,18 +146,27 @@
* this returns a new ImageGenerator for it. Otherwise this returns NULL. Either way
* the caller is still responsible for managing their ownership of the data.
*/
- static SkImageGenerator* NewFromEncoded(SkData*);
+ static std::unique_ptr<SkImageGenerator> MakeFromEncoded(sk_sp<SkData>);
/** Return a new image generator backed by the specified picture. If the size is empty or
* the picture is NULL, this returns NULL.
* The optional matrix and paint arguments are passed to drawPicture() at rasterization
* time.
*/
- static SkImageGenerator* NewFromPicture(const SkISize&, const SkPicture*, const SkMatrix*,
- const SkPaint*, SkImage::BitDepth, sk_sp<SkColorSpace>);
+ static std::unique_ptr<SkImageGenerator> MakeFromPicture(const SkISize&, sk_sp<SkPicture>,
+ const SkMatrix*, const SkPaint*,
+ SkImage::BitDepth,
+ sk_sp<SkColorSpace>);
bool tryGenerateBitmap(SkBitmap* bm, const SkImageInfo& info, SkBitmap::Allocator* allocator);
+#ifdef SK_SUPPORT_BARE_PTR_IMAGEGENERATOR
+ static SkImageGenerator* NewFromPicture(const SkISize& size, const SkPicture* picture,
+ const SkMatrix* matrix, const SkPaint* paint,
+ SkImage::BitDepth depth, sk_sp<SkColorSpace> cs);
+ static SkImageGenerator* NewFromEncoded(SkData* data);
+#endif
+
protected:
enum {
kNeedNewImageUniqueID = 0
@@ -188,7 +197,7 @@
// This is our default impl, which may be different on different platforms.
// It is called from NewFromEncoded() after it has checked for any runtime factory.
// The SkData will never be NULL, as that will have been checked by NewFromEncoded.
- static SkImageGenerator* NewFromEncodedImpl(SkData*);
+ static std::unique_ptr<SkImageGenerator> MakeFromEncodedImpl(sk_sp<SkData>);
};
#endif // SkImageGenerator_DEFINED
diff --git a/public.bzl b/public.bzl
index 430dbc8..eab1c52 100644
--- a/public.bzl
+++ b/public.bzl
@@ -600,6 +600,7 @@
"SK_SUPPORT_LEGACY_BITMAP_SETPIXELREF",
"SK_SUPPORT_LEGACY_CLIPOP_EXOTIC_NAMES",
"SK_SUPPORT_LEGACY_SCALARMUL",
+ "SK_SUPPORT_BARE_PTR_IMAGEGENERATOR",
]
################################################################################
diff --git a/src/codec/SkCodecImageGenerator.cpp b/src/codec/SkCodecImageGenerator.cpp
index 447332b..56ca21e 100644
--- a/src/codec/SkCodecImageGenerator.cpp
+++ b/src/codec/SkCodecImageGenerator.cpp
@@ -6,14 +6,15 @@
*/
#include "SkCodecImageGenerator.h"
+#include "SkMakeUnique.h"
-SkImageGenerator* SkCodecImageGenerator::NewFromEncodedCodec(sk_sp<SkData> data) {
+std::unique_ptr<SkImageGenerator> SkCodecImageGenerator::MakeFromEncodedCodec(sk_sp<SkData> data) {
SkCodec* codec = SkCodec::NewFromData(data);
if (nullptr == codec) {
return nullptr;
}
- return new SkCodecImageGenerator(codec, data);
+ return std::unique_ptr<SkImageGenerator>(new SkCodecImageGenerator(codec, data));
}
static SkImageInfo make_premul(const SkImageInfo& info) {
diff --git a/src/codec/SkCodecImageGenerator.h b/src/codec/SkCodecImageGenerator.h
index d771f49..727a747 100644
--- a/src/codec/SkCodecImageGenerator.h
+++ b/src/codec/SkCodecImageGenerator.h
@@ -18,10 +18,7 @@
* If this data represents an encoded image that we know how to decode,
* return an SkCodecImageGenerator. Otherwise return nullptr.
*/
- static SkImageGenerator* NewFromEncodedCodec(sk_sp<SkData>);
- static SkImageGenerator* NewFromEncodedCodec(SkData* data) {
- return NewFromEncodedCodec(sk_ref_sp(data));
- }
+ static std::unique_ptr<SkImageGenerator> MakeFromEncodedCodec(sk_sp<SkData>);
protected:
SkData* onRefEncodedData(GrContext* ctx) override;
diff --git a/src/core/SkImageCacherator.cpp b/src/core/SkImageCacherator.cpp
index 4534851..e971883 100644
--- a/src/core/SkImageCacherator.cpp
+++ b/src/core/SkImageCacherator.cpp
@@ -101,9 +101,9 @@
}
}
-SkImageCacherator* SkImageCacherator::NewFromGenerator(SkImageGenerator* gen,
+SkImageCacherator* SkImageCacherator::NewFromGenerator(std::unique_ptr<SkImageGenerator> gen,
const SkIRect* subset) {
- Validator validator(SharedGenerator::Make(gen), subset);
+ Validator validator(SharedGenerator::Make(std::move(gen)), subset);
return validator ? new SkImageCacherator(&validator) : nullptr;
}
diff --git a/src/core/SkImageCacherator.h b/src/core/SkImageCacherator.h
index 528dc0e..9733936 100644
--- a/src/core/SkImageCacherator.h
+++ b/src/core/SkImageCacherator.h
@@ -24,8 +24,8 @@
*/
class SkImageCacherator {
public:
- // Takes ownership of the generator
- static SkImageCacherator* NewFromGenerator(SkImageGenerator*, const SkIRect* subset = nullptr);
+ static SkImageCacherator* NewFromGenerator(std::unique_ptr<SkImageGenerator>,
+ const SkIRect* subset = nullptr);
~SkImageCacherator();
@@ -90,12 +90,16 @@
// among several cacherators.
class SharedGenerator final : public SkNVRefCnt<SharedGenerator> {
public:
- static sk_sp<SharedGenerator> Make(SkImageGenerator* gen) {
- return gen ? sk_sp<SharedGenerator>(new SharedGenerator(gen)) : nullptr;
+ static sk_sp<SharedGenerator> Make(std::unique_ptr<SkImageGenerator> gen) {
+ return gen ? sk_sp<SharedGenerator>(new SharedGenerator(std::move(gen))) : nullptr;
}
private:
- explicit SharedGenerator(SkImageGenerator* gen) : fGenerator(gen) { SkASSERT(gen); }
+ explicit SharedGenerator(std::unique_ptr<SkImageGenerator> gen)
+ : fGenerator(std::move(gen))
+ {
+ SkASSERT(fGenerator);
+ }
friend class ScopedGenerator;
friend class SkImageCacherator;
diff --git a/src/core/SkImageGenerator.cpp b/src/core/SkImageGenerator.cpp
index b815fbf..d4d42ba 100644
--- a/src/core/SkImageGenerator.cpp
+++ b/src/core/SkImageGenerator.cpp
@@ -174,24 +174,57 @@
#include "SkGraphics.h"
-static SkGraphics::ImageGeneratorFromEncodedFactory gFactory;
+static SkGraphics::ImageGeneratorFromEncodedDataFactory gFactory;
-SkGraphics::ImageGeneratorFromEncodedFactory
-SkGraphics::SetImageGeneratorFromEncodedFactory(ImageGeneratorFromEncodedFactory factory)
+SkGraphics::ImageGeneratorFromEncodedDataFactory
+SkGraphics::SetImageGeneratorFromEncodedDataFactory(ImageGeneratorFromEncodedDataFactory factory)
{
- ImageGeneratorFromEncodedFactory prev = gFactory;
+ ImageGeneratorFromEncodedDataFactory prev = gFactory;
gFactory = factory;
return prev;
}
-SkImageGenerator* SkImageGenerator::NewFromEncoded(SkData* data) {
- if (nullptr == data) {
+#ifdef SK_SUPPORT_BARE_PTR_IMAGEGENERATOR
+static SkGraphics::ImageGeneratorFromEncodedFactory gLegacyFactory;
+SkGraphics::ImageGeneratorFromEncodedFactory
+SkGraphics::SetImageGeneratorFromEncodedFactory(ImageGeneratorFromEncodedFactory factory)
+{
+ ImageGeneratorFromEncodedFactory prev = gLegacyFactory;
+ gLegacyFactory = factory;
+ return prev;
+}
+#endif
+
+std::unique_ptr<SkImageGenerator> SkImageGenerator::MakeFromEncoded(sk_sp<SkData> data) {
+ if (!data) {
return nullptr;
}
if (gFactory) {
- if (SkImageGenerator* generator = gFactory(data)) {
+ if (std::unique_ptr<SkImageGenerator> generator = gFactory(data)) {
return generator;
}
}
- return SkImageGenerator::NewFromEncodedImpl(data);
+#ifdef SK_SUPPORT_BARE_PTR_IMAGEGENERATOR
+ if (gLegacyFactory) {
+ if (SkImageGenerator* generator = gLegacyFactory(data.get())) {
+ return std::unique_ptr<SkImageGenerator>(generator);
+ }
+ }
+#endif
+ return SkImageGenerator::MakeFromEncodedImpl(std::move(data));
}
+
+#ifdef SK_SUPPORT_BARE_PTR_IMAGEGENERATOR
+#include "SkPicture.h"
+
+SkImageGenerator* SkImageGenerator::NewFromPicture(const SkISize& size, const SkPicture* picture,
+ const SkMatrix* matrix, const SkPaint* paint,
+ SkImage::BitDepth depth,
+ sk_sp<SkColorSpace> cs) {
+ return MakeFromPicture(size, sk_ref_sp(const_cast<SkPicture*>(picture)), matrix, paint,
+ depth, std::move(cs)).release();
+}
+SkImageGenerator* SkImageGenerator::NewFromEncoded(SkData* data) {
+ return MakeFromEncoded(sk_ref_sp(data)).release();
+}
+#endif
diff --git a/src/core/SkPictureImageGenerator.cpp b/src/core/SkPictureImageGenerator.cpp
index 618312e..44a6b82 100644
--- a/src/core/SkPictureImageGenerator.cpp
+++ b/src/core/SkPictureImageGenerator.cpp
@@ -7,16 +7,17 @@
#include "SkImage_Base.h"
#include "SkCanvas.h"
+#include "SkMakeUnique.h"
#include "SkMatrix.h"
#include "SkPaint.h"
#include "SkPicture.h"
#include "SkPictureImageGenerator.h"
#include "SkSurface.h"
-SkImageGenerator* SkPictureImageGenerator::Create(const SkISize& size, const SkPicture* picture,
- const SkMatrix* matrix, const SkPaint* paint,
- SkImage::BitDepth bitDepth,
- sk_sp<SkColorSpace> colorSpace) {
+std::unique_ptr<SkImageGenerator>
+SkPictureImageGenerator::Make(const SkISize& size, sk_sp<SkPicture> picture, const SkMatrix* matrix,
+ const SkPaint* paint, SkImage::BitDepth bitDepth,
+ sk_sp<SkColorSpace> colorSpace) {
if (!picture || size.isEmpty()) {
return nullptr;
}
@@ -36,13 +37,14 @@
SkImageInfo info = SkImageInfo::Make(size.width(), size.height(), colorType,
kPremul_SkAlphaType, std::move(colorSpace));
- return new SkPictureImageGenerator(info, picture, matrix, paint);
+ return std::unique_ptr<SkImageGenerator>(
+ new SkPictureImageGenerator(info, std::move(picture), matrix, paint));
}
-SkPictureImageGenerator::SkPictureImageGenerator(const SkImageInfo& info, const SkPicture* picture,
+SkPictureImageGenerator::SkPictureImageGenerator(const SkImageInfo& info, sk_sp<SkPicture> picture,
const SkMatrix* matrix, const SkPaint* paint)
: INHERITED(info)
- , fPicture(SkRef(picture)) {
+ , fPicture(std::move(picture)) {
if (matrix) {
fMatrix = *matrix;
@@ -75,18 +77,18 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
-SkImageGenerator* SkImageGenerator::NewFromPicture(const SkISize& size, const SkPicture* picture,
- const SkMatrix* matrix, const SkPaint* paint,
- SkImage::BitDepth bitDepth,
- sk_sp<SkColorSpace> colorSpace) {
+std::unique_ptr<SkImageGenerator>
+SkImageGenerator::MakeFromPicture(const SkISize& size, sk_sp<SkPicture> picture,
+ const SkMatrix* matrix, const SkPaint* paint,
+ SkImage::BitDepth bitDepth, sk_sp<SkColorSpace> colorSpace) {
// Check this here (rather than in SkPictureImageGenerator::Create) so SkPictureShader
// has a private entry point to create legacy picture backed images.
if (!colorSpace) {
return nullptr;
}
- return SkPictureImageGenerator::Create(size, picture, matrix, paint, bitDepth,
- std::move(colorSpace));
+ return SkPictureImageGenerator::Make(size, std::move(picture), matrix, paint, bitDepth,
+ std::move(colorSpace));
}
///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/SkPictureImageGenerator.h b/src/core/SkPictureImageGenerator.h
index 4728d21..ec63e30 100644
--- a/src/core/SkPictureImageGenerator.h
+++ b/src/core/SkPictureImageGenerator.h
@@ -10,10 +10,11 @@
#include "SkImageGenerator.h"
#include "SkTLazy.h"
-class SkPictureImageGenerator : SkImageGenerator {
+class SkPictureImageGenerator : public SkImageGenerator {
public:
- static SkImageGenerator* Create(const SkISize&, const SkPicture*, const SkMatrix*,
- const SkPaint*, SkImage::BitDepth, sk_sp<SkColorSpace>);
+ static std::unique_ptr<SkImageGenerator> Make(const SkISize&, sk_sp<SkPicture>, const SkMatrix*,
+ const SkPaint*, SkImage::BitDepth,
+ sk_sp<SkColorSpace>);
protected:
bool onGetPixels(const SkImageInfo& info, void* pixels, size_t rowBytes, SkPMColor ctable[],
@@ -24,12 +25,12 @@
#endif
private:
- SkPictureImageGenerator(const SkImageInfo& info, const SkPicture*, const SkMatrix*,
+ SkPictureImageGenerator(const SkImageInfo& info, sk_sp<SkPicture>, const SkMatrix*,
const SkPaint*);
- sk_sp<const SkPicture> fPicture;
- SkMatrix fMatrix;
- SkTLazy<SkPaint> fPaint;
+ sk_sp<SkPicture> fPicture;
+ SkMatrix fMatrix;
+ SkTLazy<SkPaint> fPaint;
typedef SkImageGenerator INHERITED;
};
diff --git a/src/core/SkPictureShader.cpp b/src/core/SkPictureShader.cpp
index a957613..69f92ec 100644
--- a/src/core/SkPictureShader.cpp
+++ b/src/core/SkPictureShader.cpp
@@ -228,8 +228,8 @@
SkMatrix::kFill_ScaleToFit);
sk_sp<SkImage> tileImage = SkImage::MakeFromGenerator(
- SkPictureImageGenerator::Create(tileSize, fPicture.get(), &tileMatrix, nullptr,
- SkImage::BitDepth::kU8, sk_ref_sp(dstColorSpace)));
+ SkPictureImageGenerator::Make(tileSize, fPicture, &tileMatrix, nullptr,
+ SkImage::BitDepth::kU8, sk_ref_sp(dstColorSpace)));
if (!tileImage) {
return nullptr;
}
diff --git a/src/core/SkReadBuffer.cpp b/src/core/SkReadBuffer.cpp
index b4fc168..33e1d02 100644
--- a/src/core/SkReadBuffer.cpp
+++ b/src/core/SkReadBuffer.cpp
@@ -10,6 +10,7 @@
#include "SkImage.h"
#include "SkImageDeserializer.h"
#include "SkImageGenerator.h"
+#include "SkMakeUnique.h"
#include "SkReadBuffer.h"
#include "SkStream.h"
#include "SkTypeface.h"
@@ -28,7 +29,7 @@
static sk_sp<SkImage> MakeEmptyImage(int width, int height) {
return SkImage::MakeFromGenerator(
- new EmptyImageGenerator(SkImageInfo::MakeN32Premul(width, height)));
+ skstd::make_unique<EmptyImageGenerator>(SkImageInfo::MakeN32Premul(width, height)));
}
} // anonymous namespace
diff --git a/src/image/SkImage.cpp b/src/image/SkImage.cpp
index 7619acd..2ae01b8 100644
--- a/src/image/SkImage.cpp
+++ b/src/image/SkImage.cpp
@@ -129,8 +129,7 @@
if (nullptr == encoded || 0 == encoded->size()) {
return nullptr;
}
- SkImageGenerator* generator = SkImageGenerator::NewFromEncoded(encoded.get());
- return SkImage::MakeFromGenerator(generator, subset);
+ return SkImage::MakeFromGenerator(SkImageGenerator::MakeFromEncoded(encoded), subset);
}
const char* SkImage::toString(SkString* str) const {
@@ -263,9 +262,9 @@
sk_sp<SkImage> SkImage::MakeFromPicture(sk_sp<SkPicture> picture, const SkISize& dimensions,
const SkMatrix* matrix, const SkPaint* paint,
BitDepth bitDepth, sk_sp<SkColorSpace> colorSpace) {
- return MakeFromGenerator(SkImageGenerator::NewFromPicture(dimensions, picture.get(), matrix,
- paint, bitDepth,
- std::move(colorSpace)));
+ return MakeFromGenerator(SkImageGenerator::MakeFromPicture(dimensions, std::move(picture),
+ matrix, paint, bitDepth,
+ std::move(colorSpace)));
}
sk_sp<SkImage> SkImage::makeWithFilter(const SkImageFilter* filter, const SkIRect& subset,
const SkIRect& clipBounds, SkIRect* outSubset,
diff --git a/src/image/SkImage_Generator.cpp b/src/image/SkImage_Generator.cpp
index da9d61a..7e47523 100644
--- a/src/image/SkImage_Generator.cpp
+++ b/src/image/SkImage_Generator.cpp
@@ -93,9 +93,16 @@
return validator ? sk_sp<SkImage>(new SkImage_Generator(&validator)) : nullptr;
}
-sk_sp<SkImage> SkImage::MakeFromGenerator(SkImageGenerator* generator, const SkIRect* subset) {
- SkImageCacherator::Validator validator(SkImageCacherator::SharedGenerator::Make(generator),
- subset);
+sk_sp<SkImage> SkImage::MakeFromGenerator(std::unique_ptr<SkImageGenerator> generator,
+ const SkIRect* subset) {
+ SkImageCacherator::Validator validator(
+ SkImageCacherator::SharedGenerator::Make(std::move(generator)), subset);
return validator ? sk_make_sp<SkImage_Generator>(&validator) : nullptr;
}
+
+#ifdef SK_SUPPORT_BARE_PTR_IMAGEGENERATOR
+sk_sp<SkImage> SkImage::MakeFromGenerator(SkImageGenerator* gen, const SkIRect* subset) {
+ return MakeFromGenerator(std::unique_ptr<SkImageGenerator>(gen), subset);
+}
+#endif
diff --git a/src/ports/SkImageGenerator_none.cpp b/src/ports/SkImageGenerator_none.cpp
index 2dce1c2..5aeb5cb 100644
--- a/src/ports/SkImageGenerator_none.cpp
+++ b/src/ports/SkImageGenerator_none.cpp
@@ -7,6 +7,6 @@
#include "SkImageGenerator.h"
-SkImageGenerator* SkImageGenerator::NewFromEncodedImpl(SkData*) {
+std::unique_ptr<SkImageGenerator> SkImageGenerator::MakeFromEncodedImpl(sk_sp<SkData>) {
return nullptr;
}
diff --git a/src/ports/SkImageGenerator_skia.cpp b/src/ports/SkImageGenerator_skia.cpp
index b6ddee9..e310b7f 100644
--- a/src/ports/SkImageGenerator_skia.cpp
+++ b/src/ports/SkImageGenerator_skia.cpp
@@ -8,6 +8,6 @@
#include "SkData.h"
#include "SkCodecImageGenerator.h"
-SkImageGenerator* SkImageGenerator::NewFromEncodedImpl(SkData* data) {
- return SkCodecImageGenerator::NewFromEncodedCodec(data);
+std::unique_ptr<SkImageGenerator> SkImageGenerator::MakeFromEncodedImpl(sk_sp<SkData> data) {
+ return SkCodecImageGenerator::MakeFromEncodedCodec(std::move(data));
}
diff --git a/tests/CachedDecodingPixelRefTest.cpp b/tests/CachedDecodingPixelRefTest.cpp
index b65765f..d9a9e9e 100644
--- a/tests/CachedDecodingPixelRefTest.cpp
+++ b/tests/CachedDecodingPixelRefTest.cpp
@@ -12,6 +12,7 @@
#include "SkImage.h"
#include "SkImageEncoder.h"
#include "SkImageGenerator.h"
+#include "SkMakeUnique.h"
#include "SkResourceCache.h"
#include "SkStream.h"
#include "SkUtils.h"
@@ -106,8 +107,8 @@
for (size_t i = 0; i < SK_ARRAY_COUNT(testTypes); ++i) {
TestImageGenerator::TestType test = testTypes[i];
for (const SkColorType testColorType : testColorTypes) {
- SkImageGenerator* gen = new TestImageGenerator(test, r, testColorType);
- sk_sp<SkImage> image(SkImage::MakeFromGenerator(gen));
+ auto gen = skstd::make_unique<TestImageGenerator>(test, r, testColorType);
+ sk_sp<SkImage> image(SkImage::MakeFromGenerator(std::move(gen)));
if (nullptr == image) {
ERRORF(r, "SkImage::NewFromGenerator unexpecedly failed ["
SK_SIZE_T_SPECIFIER "]", i);
diff --git a/tests/CodecTest.cpp b/tests/CodecTest.cpp
index 8a4d6fc..6423271 100644
--- a/tests/CodecTest.cpp
+++ b/tests/CodecTest.cpp
@@ -436,7 +436,7 @@
std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
sk_sp<SkData> fullData(SkData::MakeFromStream(stream.get(), stream->getLength()));
std::unique_ptr<SkImageGenerator> gen(
- SkCodecImageGenerator::NewFromEncodedCodec(fullData.get()));
+ SkCodecImageGenerator::MakeFromEncodedCodec(fullData));
SkBitmap bm;
bm.allocPixels(info);
SkAutoLockPixels autoLockPixels(bm);
diff --git a/tests/ImageGeneratorTest.cpp b/tests/ImageGeneratorTest.cpp
index 63a47e4..b644596 100644
--- a/tests/ImageGeneratorTest.cpp
+++ b/tests/ImageGeneratorTest.cpp
@@ -12,7 +12,7 @@
static bool gMyFactoryWasCalled;
-static SkImageGenerator* my_factory(SkData*) {
+static std::unique_ptr<SkImageGenerator> my_factory(sk_sp<SkData>) {
gMyFactoryWasCalled = true;
return nullptr;
}
@@ -23,20 +23,18 @@
gMyFactoryWasCalled = false;
- SkImageGenerator* gen;
REPORTER_ASSERT(reporter, !gMyFactoryWasCalled);
- gen = SkImageGenerator::NewFromEncoded(data.get());
+ std::unique_ptr<SkImageGenerator> gen = SkImageGenerator::MakeFromEncoded(data);
REPORTER_ASSERT(reporter, nullptr == gen);
REPORTER_ASSERT(reporter, !gMyFactoryWasCalled);
// Test is racy, in that it hopes no other thread is changing this global...
- SkGraphics::ImageGeneratorFromEncodedFactory prev =
- SkGraphics::SetImageGeneratorFromEncodedFactory(my_factory);
- gen = SkImageGenerator::NewFromEncoded(data.get());
+ auto prev = SkGraphics::SetImageGeneratorFromEncodedDataFactory(my_factory);
+ gen = SkImageGenerator::MakeFromEncoded(data);
REPORTER_ASSERT(reporter, nullptr == gen);
REPORTER_ASSERT(reporter, gMyFactoryWasCalled);
- SkGraphics::SetImageGeneratorFromEncodedFactory(prev);
+ SkGraphics::SetImageGeneratorFromEncodedDataFactory(prev);
}
class MyImageGenerator : public SkImageGenerator {
diff --git a/tests/ImageTest.cpp b/tests/ImageTest.cpp
index 4f5f56f..d8a0633 100644
--- a/tests/ImageTest.cpp
+++ b/tests/ImageTest.cpp
@@ -17,6 +17,7 @@
#include "SkImageGenerator.h"
#include "SkImage_Base.h"
#include "SkImagePriv.h"
+#include "SkMakeUnique.h"
#include "SkPicture.h"
#include "SkPictureRecorder.h"
#include "SkPixelSerializer.h"
@@ -595,7 +596,8 @@
REPORTER_ASSERT(reporter, nullptr == SkImage::MakeRasterCopy(pmap));
REPORTER_ASSERT(reporter, nullptr == SkImage::MakeRasterData(info, nullptr, 0));
REPORTER_ASSERT(reporter, nullptr == SkImage::MakeFromRaster(pmap, nullptr, nullptr));
- REPORTER_ASSERT(reporter, nullptr == SkImage::MakeFromGenerator(new EmptyGenerator));
+ REPORTER_ASSERT(reporter, nullptr == SkImage::MakeFromGenerator(
+ skstd::make_unique<EmptyGenerator>()));
}
DEF_TEST(ImageDataRef, reporter) {
diff --git a/tools/Resources.cpp b/tools/Resources.cpp
index aa81d34..239cac6 100644
--- a/tools/Resources.cpp
+++ b/tools/Resources.cpp
@@ -29,7 +29,7 @@
bool GetResourceAsBitmap(const char* resource, SkBitmap* dst) {
SkString resourcePath = GetResourcePath(resource);
sk_sp<SkData> resourceData(SkData::MakeFromFileName(resourcePath.c_str()));
- std::unique_ptr<SkImageGenerator> gen(SkImageGenerator::NewFromEncoded(resourceData.get()));
+ std::unique_ptr<SkImageGenerator> gen(SkImageGenerator::MakeFromEncoded(resourceData));
if (!gen) {
return false;
}