update callsites for Make image factories
not forced yet, as we still have the build-guard. waiting on chrome CL
BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1810813003
TBR=
Review URL: https://codereview.chromium.org/1810813003
diff --git a/tests/CachedDecodingPixelRefTest.cpp b/tests/CachedDecodingPixelRefTest.cpp
index fe6b412..da4a111 100644
--- a/tests/CachedDecodingPixelRefTest.cpp
+++ b/tests/CachedDecodingPixelRefTest.cpp
@@ -320,8 +320,8 @@
TestImageGenerator::TestType test = testTypes[i];
for (const SkColorType testColorType : testColorTypes) {
SkImageGenerator* gen = new TestImageGenerator(test, r, testColorType);
- SkAutoTUnref<SkImage> image(SkImage::NewFromGenerator(gen));
- if (nullptr == image.get()) {
+ sk_sp<SkImage> image(SkImage::MakeFromGenerator(gen));
+ if (nullptr == image) {
ERRORF(r, "SkImage::NewFromGenerator unexpecedly failed ["
SK_SIZE_T_SPECIFIER "]", i);
continue;
diff --git a/tests/FlattenableFactoryToName.cpp b/tests/FlattenableFactoryToName.cpp
index c8f4a62..28d491b 100644
--- a/tests/FlattenableFactoryToName.cpp
+++ b/tests/FlattenableFactoryToName.cpp
@@ -35,7 +35,7 @@
SkBitmap bm;
bm.allocN32Pixels(8, 8);
bm.eraseColor(SK_ColorCYAN);
- SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(bm));
+ sk_sp<SkImage> image(SkImage::MakeFromBitmap(bm));
auto shader = image->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
test_flattenable(r, shader.get(), "SkImage::newShader()");
}
diff --git a/tests/ImageFilterCacheTest.cpp b/tests/ImageFilterCacheTest.cpp
index f355714..c7b2170 100644
--- a/tests/ImageFilterCacheTest.cpp
+++ b/tests/ImageFilterCacheTest.cpp
@@ -169,9 +169,9 @@
DEF_TEST(ImageFilterCache_ImageBackedRaster, reporter) {
SkBitmap srcBM = create_bm();
- SkAutoTUnref<SkImage> srcImage(SkImage::NewFromBitmap(srcBM));
+ sk_sp<SkImage> srcImage(SkImage::MakeFromBitmap(srcBM));
- test_image_backed(reporter, srcImage);
+ test_image_backed(reporter, srcImage.get());
}
#if SK_SUPPORT_GPU
@@ -202,13 +202,12 @@
backendDesc.fHeight = kFullSize;
backendDesc.fSampleCnt = 0;
backendDesc.fTextureHandle = srcTexture->getTextureHandle();
- SkAutoTUnref<SkImage> srcImage(SkImage::NewFromTexture(context, backendDesc,
- kPremul_SkAlphaType));
+ sk_sp<SkImage> srcImage(SkImage::MakeFromTexture(context, backendDesc, kPremul_SkAlphaType));
if (!srcImage) {
return;
}
- test_image_backed(reporter, srcImage);
+ test_image_backed(reporter, srcImage.get());
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_GPUBacked, reporter, context) {
diff --git a/tests/ImageFilterTest.cpp b/tests/ImageFilterTest.cpp
index a0bc5f0..d4e9276 100644
--- a/tests/ImageFilterTest.cpp
+++ b/tests/ImageFilterTest.cpp
@@ -96,7 +96,7 @@
}
#endif
-static SkImage* make_small_image() {
+static sk_sp<SkImage> make_small_image() {
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(kBitmapSize, kBitmapSize));
SkCanvas* canvas = surface->getCanvas();
canvas->clear(0x00000000);
@@ -128,7 +128,7 @@
}
}
- return surface->newImageSnapshot();
+ return surface->makeImageSnapshot();
}
static SkImageFilter* make_scale(float amount, SkImageFilter* input = nullptr) {
@@ -280,7 +280,7 @@
{
// Tests pass by not asserting
- SkAutoTUnref<SkImage> image(make_small_image());
+ sk_sp<SkImage> image(make_small_image());
SkBitmap result;
result.allocN32Pixels(kBitmapSize, kBitmapSize);
@@ -293,7 +293,7 @@
// 3 ) large negative specular exponent value
SkScalar specularExponent = -1000;
- SkAutoTUnref<SkImageFilter> bmSrc(SkImageSource::Create(image));
+ SkAutoTUnref<SkImageFilter> bmSrc(SkImageSource::Create(image.get()));
SkPaint paint;
paint.setImageFilter(SkLightingImageFilter::CreateSpotLitSpecular(
location, target, specularExponent, 180,
@@ -574,8 +574,8 @@
const SkScalar gain = SK_Scalar1, bias = 0;
const SkScalar five = SkIntToScalar(5);
- SkAutoTUnref<SkImage> gradientImage(SkImage::NewFromBitmap(make_gradient_circle(64, 64)));
- SkAutoTUnref<SkImageFilter> gradientSource(SkImageSource::Create(gradientImage));
+ sk_sp<SkImage> gradientImage(SkImage::MakeFromBitmap(make_gradient_circle(64, 64)));
+ SkAutoTUnref<SkImageFilter> gradientSource(SkImageSource::Create(gradientImage.get()));
SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(five, five));
SkMatrix matrix;
@@ -802,7 +802,7 @@
SkBitmap greenBM;
greenBM.allocN32Pixels(20, 20);
greenBM.eraseColor(SK_ColorGREEN);
- SkAutoTUnref<SkImage> greenImage(SkImage::NewFromBitmap(greenBM));
+ sk_sp<SkImage> greenImage(SkImage::MakeFromBitmap(greenBM));
SkAutoTUnref<SkImageFilter> source(SkImageSource::Create(greenImage.get()));
SkAutoTUnref<SkImageFilter> merge(SkMergeImageFilter::Create(source.get(), source.get()));
@@ -1433,8 +1433,8 @@
DEF_TEST(ImageFilterImageSourceSerialization, reporter) {
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(10, 10));
surface->getCanvas()->clear(SK_ColorGREEN);
- SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
- SkAutoTUnref<SkImageFilter> filter(SkImageSource::Create(image));
+ sk_sp<SkImage> image(surface->makeImageSnapshot());
+ SkAutoTUnref<SkImageFilter> filter(SkImageSource::Create(image.get()));
SkAutoTUnref<SkData> data(SkValidatingSerializeFlattenable(filter));
SkAutoTUnref<SkFlattenable> flattenable(SkValidatingDeserializeFlattenable(
@@ -1472,13 +1472,13 @@
return;
}
- SkAutoTUnref<SkImage> largeImage(SkImage::NewFromBitmap(largeBmp));
+ sk_sp<SkImage> largeImage(SkImage::MakeFromBitmap(largeBmp));
if (!largeImage) {
ERRORF(reporter, "Failed to create large image.");
return;
}
- SkAutoTUnref<SkImageFilter> largeSource(SkImageSource::Create(largeImage));
+ SkAutoTUnref<SkImageFilter> largeSource(SkImageSource::Create(largeImage.get()));
if (!largeSource) {
ERRORF(reporter, "Failed to create large SkImageSource.");
return;
diff --git a/tests/ImageFrom565Bitmap.cpp b/tests/ImageFrom565Bitmap.cpp
index d910a47..fada9f0 100644
--- a/tests/ImageFrom565Bitmap.cpp
+++ b/tests/ImageFrom565Bitmap.cpp
@@ -16,6 +16,5 @@
5, 7, kRGB_565_SkColorType, kOpaque_SkAlphaType));
SkAutoLockPixels autoLockPixels(bm);
bm.eraseColor(SK_ColorBLACK);
- SkAutoTUnref<SkImage> img(SkImage::NewFromBitmap(bm));
- REPORTER_ASSERT(r, img.get() != nullptr);
+ REPORTER_ASSERT(r, SkImage::MakeFromBitmap(bm) != nullptr);
}
diff --git a/tests/ImageIsOpaqueTest.cpp b/tests/ImageIsOpaqueTest.cpp
index 739af2b..6f13708 100644
--- a/tests/ImageIsOpaqueTest.cpp
+++ b/tests/ImageIsOpaqueTest.cpp
@@ -49,7 +49,7 @@
}
static void check_isopaque(skiatest::Reporter* reporter, SkSurface* surface, bool expectedOpaque) {
- SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
+ sk_sp<SkImage> image(surface->makeImageSnapshot());
REPORTER_ASSERT(reporter, image->isOpaque() == expectedOpaque);
}
diff --git a/tests/ImageNewShaderTest.cpp b/tests/ImageNewShaderTest.cpp
index 0822dbd..b6266ed 100644
--- a/tests/ImageNewShaderTest.cpp
+++ b/tests/ImageNewShaderTest.cpp
@@ -44,7 +44,7 @@
void runShaderTest(skiatest::Reporter* reporter, SkSurface* sourceSurface, SkSurface* destinationSurface, SkImageInfo& info) {
paintSource(sourceSurface);
- SkAutoTUnref<SkImage> sourceImage(sourceSurface->newImageSnapshot());
+ sk_sp<SkImage> sourceImage(sourceSurface->makeImageSnapshot());
sk_sp<SkShader> sourceShader = sourceImage->makeShader(
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
diff --git a/tests/ImageTest.cpp b/tests/ImageTest.cpp
index da9268d..4781aea 100644
--- a/tests/ImageTest.cpp
+++ b/tests/ImageTest.cpp
@@ -60,19 +60,19 @@
paint.setColor(SK_ColorBLACK);
canvas->drawRect(SkRect::MakeXYWH(5, 5, 10, 10), paint);
}
-static SkImage* create_image() {
+static sk_sp<SkImage> create_image() {
const SkImageInfo info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info));
draw_image_test_pattern(surface->getCanvas());
- return surface->newImageSnapshot();
+ return surface->makeImageSnapshot();
}
-static SkImage* create_image_565() {
+static sk_sp<SkImage> create_image_565() {
const SkImageInfo info = SkImageInfo::Make(20, 20, kRGB_565_SkColorType, kOpaque_SkAlphaType);
SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info));
draw_image_test_pattern(surface->getCanvas());
- return surface->newImageSnapshot();
+ return surface->makeImageSnapshot();
}
-static SkImage* create_image_ct() {
+static sk_sp<SkImage> create_image_ct() {
SkPMColor colors[] = {
SkPreMultiplyARGB(0xFF, 0xFF, 0xFF, 0x00),
SkPreMultiplyARGB(0x80, 0x00, 0xA0, 0xFF),
@@ -87,7 +87,7 @@
0, 0, 0, 0, 0
};
SkImageInfo info = SkImageInfo::Make(5, 5, kIndex_8_SkColorType, kPremul_SkAlphaType);
- return SkImage::NewRasterCopy(info, data, 5, colorTable);
+ return SkImage::MakeRasterCopy(SkPixmap(info, data, 5, colorTable));
}
static SkData* create_image_data(SkImageInfo* info) {
*info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
@@ -101,18 +101,18 @@
}
return data.release();
}
-static SkImage* create_data_image() {
+static sk_sp<SkImage> create_data_image() {
SkImageInfo info;
- SkAutoTUnref<SkData> data(create_image_data(&info));
- return SkImage::NewRasterData(info, data, info.minRowBytes());
+ sk_sp<SkData> data(create_image_data(&info));
+ return SkImage::MakeRasterData(info, data, info.minRowBytes());
}
#if SK_SUPPORT_GPU // not gpu-specific but currently only used in GPU tests
-static SkImage* create_picture_image() {
+static sk_sp<SkImage> create_picture_image() {
SkPictureRecorder recorder;
SkCanvas* canvas = recorder.beginRecording(10, 10);
canvas->clear(SK_ColorCYAN);
- SkAutoTUnref<SkPicture> picture(recorder.endRecording());
- return SkImage::NewFromPicture(picture, SkISize::Make(10, 10), nullptr, nullptr);
+ sk_sp<SkPicture> picture(recorder.endRecording());
+ return SkImage::MakeFromPicture(picture, SkISize::Make(10, 10), nullptr, nullptr);
};
#endif
// Want to ensure that our Release is called when the owning image is destroyed
@@ -126,59 +126,57 @@
self->fData.reset();
}
};
-static SkImage* create_rasterproc_image(RasterDataHolder* dataHolder) {
+static sk_sp<SkImage> create_rasterproc_image(RasterDataHolder* dataHolder) {
SkASSERT(dataHolder);
SkImageInfo info;
SkAutoTUnref<SkData> data(create_image_data(&info));
dataHolder->fData.reset(SkRef(data.get()));
- return SkImage::NewFromRaster(info, data->data(), info.minRowBytes(),
- RasterDataHolder::Release, dataHolder);
+ return SkImage::MakeFromRaster(SkPixmap(info, data->data(), info.minRowBytes()),
+ RasterDataHolder::Release, dataHolder);
}
-static SkImage* create_codec_image() {
+static sk_sp<SkImage> create_codec_image() {
SkImageInfo info;
SkAutoTUnref<SkData> data(create_image_data(&info));
SkBitmap bitmap;
bitmap.installPixels(info, data->writable_data(), info.minRowBytes());
- SkAutoTUnref<SkData> src(
+ sk_sp<SkData> src(
SkImageEncoder::EncodeData(bitmap, SkImageEncoder::kPNG_Type, 100));
- return SkImage::NewFromEncoded(src);
+ return SkImage::MakeFromEncoded(src);
}
#if SK_SUPPORT_GPU
-static SkImage* create_gpu_image(GrContext* context) {
+static sk_sp<SkImage> create_gpu_image(GrContext* context) {
const SkImageInfo info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(context, SkBudgeted::kNo,
info));
draw_image_test_pattern(surface->getCanvas());
- return surface->newImageSnapshot();
+ return surface->makeImageSnapshot();
}
#endif
static void test_encode(skiatest::Reporter* reporter, SkImage* image) {
const SkIRect ir = SkIRect::MakeXYWH(5, 5, 10, 10);
- SkAutoTUnref<SkData> origEncoded(image->encode());
+ sk_sp<SkData> origEncoded(image->encode());
REPORTER_ASSERT(reporter, origEncoded);
REPORTER_ASSERT(reporter, origEncoded->size() > 0);
- SkAutoTUnref<SkImage> decoded(SkImage::NewFromEncoded(origEncoded));
+ sk_sp<SkImage> decoded(SkImage::MakeFromEncoded(origEncoded));
REPORTER_ASSERT(reporter, decoded);
- assert_equal(reporter, image, nullptr, decoded);
+ assert_equal(reporter, image, nullptr, decoded.get());
// Now see if we can instantiate an image from a subset of the surface/origEncoded
- decoded.reset(SkImage::NewFromEncoded(origEncoded, &ir));
+ decoded = SkImage::MakeFromEncoded(origEncoded, &ir);
REPORTER_ASSERT(reporter, decoded);
- assert_equal(reporter, image, &ir, decoded);
+ assert_equal(reporter, image, &ir, decoded.get());
}
DEF_TEST(ImageEncode, reporter) {
- SkAutoTUnref<SkImage> image(create_image());
- test_encode(reporter, image);
+ test_encode(reporter, create_image().get());
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageEncode_Gpu, reporter, context) {
- SkAutoTUnref<SkImage> image(create_gpu_image(context));
- test_encode(reporter, image);
+ test_encode(reporter, create_gpu_image(context).get());
}
#endif
@@ -214,7 +212,7 @@
// Test that SkImage encoding observes custom pixel serializers.
DEF_TEST(Image_Encode_Serializer, reporter) {
MockSerializer serializer([]() -> SkData* { return SkData::NewWithCString(kSerializedData); });
- SkAutoTUnref<SkImage> image(create_image());
+ sk_sp<SkImage> image(create_image());
SkAutoTUnref<SkData> encoded(image->encode(&serializer));
SkAutoTUnref<SkData> reference(SkData::NewWithCString(kSerializedData));
@@ -228,7 +226,7 @@
DEF_TEST(Image_Serialize_Encoding_Failure, reporter) {
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
surface->getCanvas()->clear(SK_ColorGREEN);
- SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
+ sk_sp<SkImage> image(surface->makeImageSnapshot());
REPORTER_ASSERT(reporter, image);
SkPictureRecorder recorder;
@@ -267,7 +265,7 @@
const SkImageInfo srcInfo = SkImageInfo::Make(2, 2, kIndex_8_SkColorType, kPremul_SkAlphaType);
const size_t srcRowBytes = 2 * sizeof(uint8_t);
uint8_t indices[] = { 0, 1, 2, 3 };
- SkAutoTUnref<SkImage> image(SkImage::NewRasterCopy(srcInfo, indices, srcRowBytes, ctable));
+ sk_sp<SkImage> image(SkImage::MakeRasterCopy(SkPixmap(srcInfo, indices, srcRowBytes, ctable)));
// The image made a copy, so we can trash the original indices
memset(indices, 0xFF, sizeof(indices));
@@ -297,7 +295,7 @@
const SkImageInfo dstInfo = SkImageInfo::MakeN32Premul(2, 2);
const size_t dstRowBytes = 2 * sizeof(SkPMColor);
- SkAutoTUnref<SkImage> image1(surface->newImageSnapshot());
+ sk_sp<SkImage> image1(surface->makeImageSnapshot());
REPORTER_ASSERT(reporter, image1->readPixels(dstInfo, pixels, dstRowBytes, 0, 0));
for (size_t i = 0; i < SK_ARRAY_COUNT(pixels); ++i) {
REPORTER_ASSERT(reporter, pixels[i] == green);
@@ -309,7 +307,7 @@
surface->getCanvas()->drawRect(SkRect::MakeXYWH(1, 1, 1, 1), paint);
- SkAutoTUnref<SkImage> image2(surface->newImageSnapshot());
+ sk_sp<SkImage> image2(surface->makeImageSnapshot());
REPORTER_ASSERT(reporter, image2->readPixels(dstInfo, pixels, dstRowBytes, 0, 0));
REPORTER_ASSERT(reporter, pixels[0] == green);
REPORTER_ASSERT(reporter, pixels[1] == green);
@@ -343,7 +341,7 @@
SkBitmap bm;
rec[i].fMakeProc(&bm);
- SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(bm));
+ sk_sp<SkImage> image(SkImage::MakeFromBitmap(bm));
SkPixmap pmap;
const bool sharedID = (image->uniqueID() == bm.getGenerationID());
@@ -372,7 +370,7 @@
*/
DEF_GPUTEST_FOR_NATIVE_CONTEXT(SkImage_Gpu2Cpu, reporter, context) {
SkImageInfo info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
- SkAutoTUnref<SkImage> image(create_gpu_image(context));
+ sk_sp<SkImage> image(create_gpu_image(context));
const uint32_t uniqueID = image->uniqueID();
SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info));
@@ -411,7 +409,7 @@
otherFactory.getContextInfo(GrContextFactory::kNative_GLContextType);
glContext->makeCurrent();
- std::function<SkImage*()> imageFactories[] = {
+ std::function<sk_sp<SkImage>()> imageFactories[] = {
create_image,
create_codec_image,
create_data_image,
@@ -422,21 +420,21 @@
// Create a texture image in a another GrContext.
[glContext, otherContextInfo] {
otherContextInfo.fGLContext->makeCurrent();
- SkImage* otherContextImage = create_gpu_image(otherContextInfo.fGrContext);
+ sk_sp<SkImage> otherContextImage = create_gpu_image(otherContextInfo.fGrContext);
glContext->makeCurrent();
return otherContextImage;
}
};
for (auto factory : imageFactories) {
- SkAutoTUnref<SkImage> image(factory());
+ sk_sp<SkImage> image(factory());
if (!image) {
ERRORF(reporter, "Error creating image.");
continue;
}
GrTexture* origTexture = as_IB(image)->peekTexture();
- SkAutoTUnref<SkImage> texImage(image->newTextureImage(context));
+ sk_sp<SkImage> texImage(image->makeTextureImage(context));
if (!texImage) {
// We execpt to fail if image comes from a different GrContext.
if (!origTexture || origTexture->getContext() == context) {
@@ -475,8 +473,8 @@
bm.allocPixels(info, nullptr, ctable);
SkAutoLockPixels autoLockPixels(bm);
*bm.getAddr8(0, 0) = 0;
- SkAutoTUnref<SkImage> img(SkImage::NewFromBitmap(bm));
- REPORTER_ASSERT(r, img.get() != nullptr);
+ sk_sp<SkImage> img(SkImage::MakeFromBitmap(bm));
+ REPORTER_ASSERT(r, img != nullptr);
}
class EmptyGenerator : public SkImageGenerator {
@@ -486,23 +484,23 @@
DEF_TEST(ImageEmpty, reporter) {
const SkImageInfo info = SkImageInfo::Make(0, 0, kN32_SkColorType, kPremul_SkAlphaType);
- REPORTER_ASSERT(reporter, nullptr == SkImage::NewRasterCopy(info, nullptr, 0));
- REPORTER_ASSERT(reporter, nullptr == SkImage::NewRasterData(info, nullptr, 0));
- REPORTER_ASSERT(reporter, nullptr == SkImage::NewFromRaster(info, nullptr, 0, nullptr, nullptr));
- REPORTER_ASSERT(reporter, nullptr == SkImage::NewFromGenerator(new EmptyGenerator));
+ SkPixmap pmap(info, nullptr, 0);
+ 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));
}
DEF_TEST(ImageDataRef, reporter) {
SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
size_t rowBytes = info.minRowBytes();
size_t size = info.getSafeSize(rowBytes);
- SkData* data = SkData::NewUninitialized(size);
+ sk_sp<SkData> data = SkData::MakeUninitialized(size);
REPORTER_ASSERT(reporter, data->unique());
- SkImage* image = SkImage::NewRasterData(info, data, rowBytes);
+ sk_sp<SkImage> image = SkImage::MakeRasterData(info, data, rowBytes);
REPORTER_ASSERT(reporter, !data->unique());
- image->unref();
+ image.reset();
REPORTER_ASSERT(reporter, data->unique());
- data->unref();
}
static bool has_pixels(const SkPMColor pixels[], int count, SkPMColor expected) {
@@ -559,25 +557,24 @@
REPORTER_ASSERT(reporter, has_pixels(&pixels[1], w*h - 1, notExpected));
}
DEF_TEST(ImageReadPixels, reporter) {
- SkAutoTUnref<SkImage> image(create_image());
- test_read_pixels(reporter, image);
+ sk_sp<SkImage> image(create_image());
+ test_read_pixels(reporter, image.get());
- image.reset(create_data_image());
- test_read_pixels(reporter, image);
+ image = create_data_image();
+ test_read_pixels(reporter, image.get());
RasterDataHolder dataHolder;
- image.reset(create_rasterproc_image(&dataHolder));
- test_read_pixels(reporter, image);
+ image = create_rasterproc_image(&dataHolder);
+ test_read_pixels(reporter, image.get());
image.reset();
REPORTER_ASSERT(reporter, 1 == dataHolder.fReleaseCount);
- image.reset(create_codec_image());
- test_read_pixels(reporter, image);
+ image = create_codec_image();
+ test_read_pixels(reporter, image.get());
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageReadPixels_Gpu, reporter, context) {
- SkAutoTUnref<SkImage> image(create_gpu_image(context));
- test_read_pixels(reporter, image);
+ test_read_pixels(reporter, create_gpu_image(context).get());
}
#endif
@@ -609,12 +606,12 @@
SkBitmap tmp;
REPORTER_ASSERT(reporter, bitmap.extractSubset(&tmp, SkIRect::MakeWH(image->width() / 2,
image->height() / 2)));
- SkAutoTUnref<SkImage> subsetImage(SkImage::NewFromBitmap(tmp));
- REPORTER_ASSERT(reporter, subsetImage);
+ sk_sp<SkImage> subsetImage(SkImage::MakeFromBitmap(tmp));
+ REPORTER_ASSERT(reporter, subsetImage.get());
SkBitmap subsetBitmap;
REPORTER_ASSERT(reporter, subsetImage->asLegacyBitmap(&subsetBitmap, mode));
- check_legacy_bitmap(reporter, subsetImage, subsetBitmap, mode);
+ check_legacy_bitmap(reporter, subsetImage.get(), subsetBitmap, mode);
}
DEF_TEST(ImageLegacyBitmap, reporter) {
const SkImage::LegacyBitmapMode modes[] = {
@@ -622,20 +619,20 @@
SkImage::kRW_LegacyBitmapMode,
};
for (auto& mode : modes) {
- SkAutoTUnref<SkImage> image(create_image());
- test_legacy_bitmap(reporter, image, mode);
+ sk_sp<SkImage> image(create_image());
+ test_legacy_bitmap(reporter, image.get(), mode);
- image.reset(create_data_image());
- test_legacy_bitmap(reporter, image, mode);
+ image = create_data_image();
+ test_legacy_bitmap(reporter, image.get(), mode);
RasterDataHolder dataHolder;
- image.reset(create_rasterproc_image(&dataHolder));
- test_legacy_bitmap(reporter, image, mode);
+ image = create_rasterproc_image(&dataHolder);
+ test_legacy_bitmap(reporter, image.get(), mode);
image.reset();
REPORTER_ASSERT(reporter, 1 == dataHolder.fReleaseCount);
- image.reset(create_codec_image());
- test_legacy_bitmap(reporter, image, mode);
+ image = create_codec_image();
+ test_legacy_bitmap(reporter, image.get(), mode);
}
}
#if SK_SUPPORT_GPU
@@ -645,8 +642,8 @@
SkImage::kRW_LegacyBitmapMode,
};
for (auto& mode : modes) {
- SkAutoTUnref<SkImage> image(create_gpu_image(context));
- test_legacy_bitmap(reporter, image, mode);
+ sk_sp<SkImage> image(create_gpu_image(context));
+ test_legacy_bitmap(reporter, image.get(), mode);
}
}
#endif
@@ -667,25 +664,25 @@
}
}
DEF_TEST(ImagePeek, reporter) {
- SkAutoTUnref<SkImage> image(create_image());
- test_peek(reporter, image, true);
+ sk_sp<SkImage> image(create_image());
+ test_peek(reporter, image.get(), true);
- image.reset(create_data_image());
- test_peek(reporter, image, true);
+ image = create_data_image();
+ test_peek(reporter, image.get(), true);
RasterDataHolder dataHolder;
- image.reset(create_rasterproc_image(&dataHolder));
- test_peek(reporter, image, true);
+ image = create_rasterproc_image(&dataHolder);
+ test_peek(reporter, image.get(), true);
image.reset();
REPORTER_ASSERT(reporter, 1 == dataHolder.fReleaseCount);
- image.reset(create_codec_image());
- test_peek(reporter, image, false);
+ image = create_codec_image();
+ test_peek(reporter, image.get(), false);
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImagePeek_Gpu, reporter, context) {
- SkAutoTUnref<SkImage> image(create_gpu_image(context));
- test_peek(reporter, image, false);
+ sk_sp<SkImage> image(create_gpu_image(context));
+ test_peek(reporter, image.get(), false);
}
#endif
@@ -731,14 +728,13 @@
backendDesc.fSampleCnt = 0;
backendDesc.fTextureHandle = tex->getTextureHandle();
TextureReleaseChecker releaseChecker;
- SkAutoTUnref<SkImage> refImg(
- SkImage::NewFromTexture(context, backendDesc, kPremul_SkAlphaType,
- TextureReleaseChecker::Release, &releaseChecker));
- SkAutoTUnref<SkImage> cpyImg(SkImage::NewFromTextureCopy(context, backendDesc,
- kPremul_SkAlphaType));
+ sk_sp<SkImage> refImg(
+ SkImage::MakeFromTexture(context, backendDesc, kPremul_SkAlphaType,
+ TextureReleaseChecker::Release, &releaseChecker));
+ sk_sp<SkImage> cpyImg(SkImage::MakeFromTextureCopy(context, backendDesc, kPremul_SkAlphaType));
- check_image_color(reporter, refImg, expected0);
- check_image_color(reporter, cpyImg, expected0);
+ check_image_color(reporter, refImg.get(), expected0);
+ check_image_color(reporter, cpyImg.get(), expected0);
// Now lets jam new colors into our "external" texture, and see if the images notice
const SkPMColor expected1 = SkPreMultiplyColor(SK_ColorBLUE);
@@ -751,7 +747,7 @@
// write pixels call violated the contract with refImg and refImg is now undefined.
check_image_color(reporter, refImg, expected1);
#endif
- check_image_color(reporter, cpyImg, expected0);
+ check_image_color(reporter, cpyImg.get(), expected0);
// Now exercise the release proc
REPORTER_ASSERT(reporter, 0 == releaseChecker.fReleaseCount);
@@ -802,7 +798,7 @@
for (auto create : {&create_image,
&create_image_565,
&create_image_ct}) {
- SkAutoTUnref<SkImage> image((*create)());
+ sk_sp<SkImage> image((*create)());
if (!image) {
ERRORF(reporter, "Could not create image");
return;
@@ -812,12 +808,12 @@
if (!image->peekPixels(&pixmap)) {
ERRORF(reporter, "peek failed");
} else {
- SkAutoTUnref<SkImage> texImage(SkImage::NewTextureFromPixmap(context, pixmap,
- SkBudgeted::kNo));
+ sk_sp<SkImage> texImage(SkImage::MakeTextureFromPixmap(context, pixmap,
+ SkBudgeted::kNo));
if (!texImage) {
ERRORF(reporter, "NewTextureFromPixmap failed.");
} else {
- check_images_same(reporter, image, texImage);
+ check_images_same(reporter, image.get(), texImage.get());
}
}
}
@@ -833,7 +829,7 @@
glContext->makeCurrent();
REPORTER_ASSERT(reporter, proxy);
struct {
- std::function<SkImage *()> fImageFactory;
+ std::function<sk_sp<SkImage> ()> fImageFactory;
bool fExpectation;
} testCases[] = {
{ create_image, true },
@@ -844,7 +840,7 @@
// Create a texture image in a another GrContext.
{ [glContext, otherContextInfo] {
otherContextInfo.fGLContext->makeCurrent();
- SkImage *otherContextImage = create_gpu_image(otherContextInfo.fGrContext);
+ sk_sp<SkImage> otherContextImage = create_gpu_image(otherContextInfo.fGrContext);
glContext->makeCurrent();
return otherContextImage;
}, false },
@@ -852,7 +848,7 @@
for (auto testCase : testCases) {
- SkAutoTUnref<SkImage> image(testCase.fImageFactory());
+ sk_sp<SkImage> image(testCase.fImageFactory());
// This isn't currently used in the implementation, just set any old values.
SkImage::DeferredTextureImageUsageParams params;
@@ -876,15 +872,15 @@
ERRORF(reporter, "deferred image size succeeded but creation failed.");
} else {
for (auto budgeted : { SkBudgeted::kNo, SkBudgeted::kYes }) {
- SkAutoTUnref<SkImage> newImage(
- SkImage::NewFromDeferredTextureImageData(context, buffer, budgeted));
+ sk_sp<SkImage> newImage(
+ SkImage::MakeFromDeferredTextureImageData(context, buffer, budgeted));
REPORTER_ASSERT(reporter, newImage != nullptr);
if (newImage) {
- check_images_same(reporter, image, newImage);
+ check_images_same(reporter, image.get(), newImage.get());
}
// The other context should not be able to create images from texture data
// created by the original context.
- SkAutoTUnref<SkImage> newImage2(SkImage::NewFromDeferredTextureImageData(
+ sk_sp<SkImage> newImage2(SkImage::MakeFromDeferredTextureImageData(
otherContextInfo.fGrContext, buffer, budgeted));
REPORTER_ASSERT(reporter, !newImage2);
glContext->makeCurrent();
diff --git a/tests/PDFJpegEmbedTest.cpp b/tests/PDFJpegEmbedTest.cpp
index 9d83fe6..2dcbdd0 100644
--- a/tests/PDFJpegEmbedTest.cpp
+++ b/tests/PDFJpegEmbedTest.cpp
@@ -56,9 +56,8 @@
*/
DEF_TEST(PDFJpegEmbedTest, r) {
const char test[] = "PDFJpegEmbedTest";
- SkAutoTUnref<SkData> mandrillData(
- load_resource(r, test, "mandrill_512_q075.jpg"));
- SkAutoTUnref<SkData> cmykData(load_resource(r, test, "CMYK.jpg"));
+ sk_sp<SkData> mandrillData(load_resource(r, test, "mandrill_512_q075.jpg"));
+ sk_sp<SkData> cmykData(load_resource(r, test, "CMYK.jpg"));
if (!mandrillData || !cmykData) {
return;
}
@@ -69,9 +68,9 @@
canvas->clear(SK_ColorLTGRAY);
- SkBitmap bm1(bitmap_from_data(mandrillData));
+ SkBitmap bm1(bitmap_from_data(mandrillData.get()));
canvas->drawBitmap(bm1, 65.0, 0.0, nullptr);
- SkBitmap bm2(bitmap_from_data(cmykData));
+ SkBitmap bm2(bitmap_from_data(cmykData.get()));
canvas->drawBitmap(bm2, 0.0, 512.0, nullptr);
canvas->flush();
@@ -81,11 +80,11 @@
SkASSERT(pdfData);
pdf.reset();
- REPORTER_ASSERT(r, is_subset_of(mandrillData, pdfData));
+ REPORTER_ASSERT(r, is_subset_of(mandrillData.get(), pdfData.get()));
// This JPEG uses a nonstandard colorspace - it can not be
// embedded into the PDF directly.
- REPORTER_ASSERT(r, !is_subset_of(cmykData, pdfData));
+ REPORTER_ASSERT(r, !is_subset_of(cmykData.get(), pdfData.get()));
////////////////////////////////////////////////////////////////////////////
pdf.reset();
document.reset(SkDocument::CreatePDF(&pdf));
@@ -93,10 +92,10 @@
canvas->clear(SK_ColorLTGRAY);
- SkAutoTUnref<SkImage> im1(SkImage::NewFromEncoded(mandrillData));
- canvas->drawImage(im1, 65.0, 0.0, nullptr);
- SkAutoTUnref<SkImage> im2(SkImage::NewFromEncoded(cmykData));
- canvas->drawImage(im2, 0.0, 512.0, nullptr);
+ sk_sp<SkImage> im1(SkImage::MakeFromEncoded(mandrillData));
+ canvas->drawImage(im1.get(), 65.0, 0.0, nullptr);
+ sk_sp<SkImage> im2(SkImage::MakeFromEncoded(cmykData));
+ canvas->drawImage(im2.get(), 0.0, 512.0, nullptr);
canvas->flush();
document->endPage();
@@ -105,11 +104,11 @@
SkASSERT(pdfData);
pdf.reset();
- REPORTER_ASSERT(r, is_subset_of(mandrillData, pdfData));
+ REPORTER_ASSERT(r, is_subset_of(mandrillData.get(), pdfData.get()));
// This JPEG uses a nonstandard colorspace - it can not be
// embedded into the PDF directly.
- REPORTER_ASSERT(r, !is_subset_of(cmykData, pdfData));
+ REPORTER_ASSERT(r, !is_subset_of(cmykData.get(), pdfData.get()));
}
#include "SkJpegInfo.h"
diff --git a/tests/PictureTest.cpp b/tests/PictureTest.cpp
index 3d2f19d..ba787a0 100644
--- a/tests/PictureTest.cpp
+++ b/tests/PictureTest.cpp
@@ -50,7 +50,7 @@
// We just need _some_ SkImage
const SkPMColor pixel = 0;
const SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
- SkAutoTUnref<SkImage> image(SkImage::NewRasterCopy(info, &pixel, sizeof(pixel)));
+ sk_sp<SkImage> image(SkImage::MakeRasterCopy(SkPixmap(info, &pixel, sizeof(pixel))));
SkPictureRecorder recorder;
recorder.beginRecording(100,100)->drawImage(image, 0,0);
diff --git a/tests/ReadPixelsTest.cpp b/tests/ReadPixelsTest.cpp
index b87d2b8..77a11e5 100644
--- a/tests/ReadPixelsTest.cpp
+++ b/tests/ReadPixelsTest.cpp
@@ -556,8 +556,7 @@
canvas->translate(-SkScalarHalf(bm.width()), -SkScalarHalf(bm.height()));
canvas->drawBitmap(bm, 0, 0, &paint);
- SkAutoTUnref<SkImage> image(surf->newImageSnapshot());
- return image->encode();
+ return surf->makeImageSnapshot()->encode();
}
#include "SkStream.h"
diff --git a/tests/RecordDrawTest.cpp b/tests/RecordDrawTest.cpp
index 8dfdc97..8d91fbc 100644
--- a/tests/RecordDrawTest.cpp
+++ b/tests/RecordDrawTest.cpp
@@ -281,7 +281,7 @@
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(10, 10));
surface->getCanvas()->clear(SK_ColorGREEN);
- SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
+ sk_sp<SkImage> image(surface->makeImageSnapshot());
SkCanvasMock canvas(10, 10);
diff --git a/tests/RecorderTest.cpp b/tests/RecorderTest.cpp
index 9d7fda5..b1af138 100644
--- a/tests/RecorderTest.cpp
+++ b/tests/RecorderTest.cpp
@@ -72,18 +72,18 @@
DEF_TEST(Recorder_drawImage_takeReference, reporter) {
- SkAutoTUnref<SkImage> image;
+ sk_sp<SkImage> image;
{
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
surface->getCanvas()->clear(SK_ColorGREEN);
- image.reset(surface->newImageSnapshot());
+ image = surface->makeImageSnapshot();
}
{
SkRecord record;
SkRecorder recorder(&record, 100, 100);
// DrawImage is supposed to take a reference
- recorder.drawImage(image.get(), 0, 0);
+ recorder.drawImage(image, 0, 0);
REPORTER_ASSERT(reporter, !image->unique());
Tally tally;
@@ -98,7 +98,7 @@
SkRecorder recorder(&record, 100, 100);
// DrawImageRect is supposed to take a reference
- recorder.drawImageRect(image.get(), SkRect::MakeWH(100, 100), nullptr);
+ recorder.drawImageRect(image, SkRect::MakeWH(100, 100), nullptr);
REPORTER_ASSERT(reporter, !image->unique());
Tally tally;
diff --git a/tests/SerializationTest.cpp b/tests/SerializationTest.cpp
index d6a88cf..eca9e64 100644
--- a/tests/SerializationTest.cpp
+++ b/tests/SerializationTest.cpp
@@ -242,10 +242,10 @@
const SkBitmap& invalidBitmap,
bool shouldSucceed,
skiatest::Reporter* reporter) {
- SkAutoTUnref<SkImage> validImage(SkImage::NewFromBitmap(validBitmap));
- SkAutoTUnref<SkImageFilter> validBitmapSource(SkImageSource::Create(validImage));
- SkAutoTUnref<SkImage> invalidImage(SkImage::NewFromBitmap(invalidBitmap));
- SkAutoTUnref<SkImageFilter> invalidBitmapSource(SkImageSource::Create(invalidImage));
+ sk_sp<SkImage> validImage(SkImage::MakeFromBitmap(validBitmap));
+ SkAutoTUnref<SkImageFilter> validBitmapSource(SkImageSource::Create(validImage.get()));
+ sk_sp<SkImage> invalidImage(SkImage::MakeFromBitmap(invalidBitmap));
+ SkAutoTUnref<SkImageFilter> invalidBitmapSource(SkImageSource::Create(invalidImage.get()));
SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kSrcOver_Mode));
SkAutoTUnref<SkImageFilter> xfermodeImageFilter(
SkXfermodeImageFilter::Create(mode, invalidBitmapSource, validBitmapSource));
diff --git a/tests/SkColor4fTest.cpp b/tests/SkColor4fTest.cpp
index 0b5a4e0..94e1b68 100644
--- a/tests/SkColor4fTest.cpp
+++ b/tests/SkColor4fTest.cpp
@@ -108,7 +108,7 @@
SkPackARGB32(0xFF, 0xBB, 0x88, 0x55),
SkPackARGB32(0xFF, 0xBB, 0x88, 0x55),
};
- SkAutoTUnref<SkImage> image(SkImage::NewRasterCopy(info, pixels, sizeof(SkPMColor) * 2));
+ sk_sp<SkImage> image(SkImage::MakeRasterCopy(SkPixmap(info, pixels, sizeof(SkPMColor) * 2)));
return image->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
}
diff --git a/tests/SkImageTest.cpp b/tests/SkImageTest.cpp
index 8817f0b..4a05b44 100644
--- a/tests/SkImageTest.cpp
+++ b/tests/SkImageTest.cpp
@@ -14,7 +14,7 @@
// Tests that SkNewImageFromBitmap obeys pixelref origin.
DEF_TEST(SkImageFromBitmap_extractSubset, reporter) {
- SkAutoTUnref<SkImage> image;
+ sk_sp<SkImage> image;
{
SkBitmap srcBitmap;
srcBitmap.allocN32Pixels(gWidth, gHeight);
@@ -26,7 +26,7 @@
canvas.drawIRect(r, p);
SkBitmap dstBitmap;
srcBitmap.extractSubset(&dstBitmap, r);
- image.reset(SkImage::NewFromBitmap(dstBitmap));
+ image = SkImage::MakeFromBitmap(dstBitmap);
}
SkBitmap tgt;
diff --git a/tests/SkResourceCacheTest.cpp b/tests/SkResourceCacheTest.cpp
index f9a0e6d..625b98a 100644
--- a/tests/SkResourceCacheTest.cpp
+++ b/tests/SkResourceCacheTest.cpp
@@ -263,7 +263,7 @@
}
static void test_discarded_image(skiatest::Reporter* reporter, const SkMatrix& transform,
- SkImage* (*buildImage)()) {
+ sk_sp<SkImage> (*buildImage)()) {
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(10, 10));
SkCanvas* canvas = surface->getCanvas();
@@ -273,7 +273,7 @@
for (unsigned i = 0; i < kRepeatCount; ++i) {
SkAutoCanvasRestore acr(canvas, true);
- SkAutoTUnref<SkImage> image(buildImage());
+ sk_sp<SkImage> image(buildImage());
// always use high quality to ensure caching when scaled
SkPaint paint;
@@ -315,15 +315,15 @@
test_discarded_image(reporter, xforms[i], []() {
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(10, 10));
surface->getCanvas()->clear(SK_ColorCYAN);
- return surface->newImageSnapshot();
+ return surface->makeImageSnapshot();
});
test_discarded_image(reporter, xforms[i], []() {
SkPictureRecorder recorder;
SkCanvas* canvas = recorder.beginRecording(10, 10);
canvas->clear(SK_ColorCYAN);
- SkAutoTUnref<SkPicture> picture(recorder.endRecording());
- return SkImage::NewFromPicture(picture, SkISize::Make(10, 10), nullptr, nullptr);
+ sk_sp<SkPicture> picture(recorder.endRecording());
+ return SkImage::MakeFromPicture(picture, SkISize::Make(10, 10), nullptr, nullptr);
});
}
}
diff --git a/tests/SpecialImageTest.cpp b/tests/SpecialImageTest.cpp
index 7511e62..03a496d 100644
--- a/tests/SpecialImageTest.cpp
+++ b/tests/SpecialImageTest.cpp
@@ -119,19 +119,19 @@
DEF_TEST(SpecialImage_Image, reporter) {
SkBitmap bm = create_bm();
- SkAutoTUnref<SkImage> fullImage(SkImage::NewFromBitmap(bm));
+ sk_sp<SkImage> fullImage(SkImage::MakeFromBitmap(bm));
SkAutoTUnref<SkSpecialImage> fullSImage(SkSpecialImage::NewFromImage(
nullptr,
SkIRect::MakeWH(kFullSize, kFullSize),
- fullImage));
+ fullImage.get()));
const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
{
SkAutoTUnref<SkSpecialImage> subSImg1(SkSpecialImage::NewFromImage(nullptr,
subset,
- fullImage));
+ fullImage.get()));
test_image(subSImg1, reporter, true, false, kPad, kFullSize);
}
diff --git a/tests/SurfaceTest.cpp b/tests/SurfaceTest.cpp
index d6c7acd..89c7765 100644
--- a/tests/SurfaceTest.cpp
+++ b/tests/SurfaceTest.cpp
@@ -231,7 +231,7 @@
bool expectOpaque) {
REPORTER_ASSERT(reporter, surface);
if (surface) {
- SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
+ sk_sp<SkImage> image(surface->makeImageSnapshot());
REPORTER_ASSERT(reporter, image);
if (image) {
REPORTER_ASSERT(reporter, image->isOpaque() == SkToBool(expectOpaque));
@@ -276,10 +276,10 @@
skiatest::Reporter* reporter, SkSurface* surface, SkSurface::BackendHandleAccess mode,
GrBackendObject (*func)(SkSurface*, SkSurface::BackendHandleAccess)) {
GrBackendObject obj1 = func(surface, mode);
- SkAutoTUnref<SkImage> snap1(surface->newImageSnapshot());
+ sk_sp<SkImage> snap1(surface->makeImageSnapshot());
GrBackendObject obj2 = func(surface, mode);
- SkAutoTUnref<SkImage> snap2(surface->newImageSnapshot());
+ sk_sp<SkImage> snap2(surface->makeImageSnapshot());
// If the access mode triggers CoW, then the backend objects should reflect it.
REPORTER_ASSERT(reporter, (obj1 == obj2) == (snap1 == snap2));
@@ -339,39 +339,39 @@
std::function<intptr_t(SkSurface*)> sbs = surfaceBackingStore;
static const SkBudgeted kB = SkBudgeted::kNo;
{
- SkAutoTUnref<SkImage> image(surface->newImageSnapshot(kB, SkSurface::kYes_ForceUnique));
- REPORTER_ASSERT(reporter, !same_image_surf(image, surface, ibs, sbs));
+ sk_sp<SkImage> image(surface->makeImageSnapshot(kB, SkSurface::kYes_ForceUnique));
+ REPORTER_ASSERT(reporter, !same_image_surf(image.get(), surface, ibs, sbs));
REPORTER_ASSERT(reporter, image->unique());
}
{
- SkAutoTUnref<SkImage> image1(surface->newImageSnapshot(kB, SkSurface::kYes_ForceUnique));
- REPORTER_ASSERT(reporter, !same_image_surf(image1, surface, ibs, sbs));
+ sk_sp<SkImage> image1(surface->makeImageSnapshot(kB, SkSurface::kYes_ForceUnique));
+ REPORTER_ASSERT(reporter, !same_image_surf(image1.get(), surface, ibs, sbs));
REPORTER_ASSERT(reporter, image1->unique());
- SkAutoTUnref<SkImage> image2(surface->newImageSnapshot(kB, SkSurface::kYes_ForceUnique));
- REPORTER_ASSERT(reporter, !same_image_surf(image2, surface, ibs, sbs));
- REPORTER_ASSERT(reporter, !same_image(image1, image2, ibs));
+ sk_sp<SkImage> image2(surface->makeImageSnapshot(kB, SkSurface::kYes_ForceUnique));
+ REPORTER_ASSERT(reporter, !same_image_surf(image2.get(), surface, ibs, sbs));
+ REPORTER_ASSERT(reporter, !same_image(image1.get(), image2.get(), ibs));
REPORTER_ASSERT(reporter, image2->unique());
}
{
- SkAutoTUnref<SkImage> image1(surface->newImageSnapshot(kB, SkSurface::kNo_ForceUnique));
- SkAutoTUnref<SkImage> image2(surface->newImageSnapshot(kB, SkSurface::kYes_ForceUnique));
- SkAutoTUnref<SkImage> image3(surface->newImageSnapshot(kB, SkSurface::kNo_ForceUnique));
- SkAutoTUnref<SkImage> image4(surface->newImageSnapshot(kB, SkSurface::kYes_ForceUnique));
+ sk_sp<SkImage> image1(surface->makeImageSnapshot(kB, SkSurface::kNo_ForceUnique));
+ sk_sp<SkImage> image2(surface->makeImageSnapshot(kB, SkSurface::kYes_ForceUnique));
+ sk_sp<SkImage> image3(surface->makeImageSnapshot(kB, SkSurface::kNo_ForceUnique));
+ sk_sp<SkImage> image4(surface->makeImageSnapshot(kB, SkSurface::kYes_ForceUnique));
// Image 1 and 3 ought to be the same (or we're missing an optimization).
- REPORTER_ASSERT(reporter, same_image(image1, image3, ibs));
+ REPORTER_ASSERT(reporter, same_image(image1.get(), image3.get(), ibs));
// If the surface is not direct then images 1 and 3 should alias the surface's
// store.
- REPORTER_ASSERT(reporter, !surfaceIsDirect == same_image_surf(image1, surface, ibs, sbs));
+ REPORTER_ASSERT(reporter, !surfaceIsDirect == same_image_surf(image1.get(), surface, ibs, sbs));
// Image 2 should not be shared with any other image.
- REPORTER_ASSERT(reporter, !same_image(image1, image2, ibs) &&
- !same_image(image3, image2, ibs) &&
- !same_image(image4, image2, ibs));
+ REPORTER_ASSERT(reporter, !same_image(image1.get(), image2.get(), ibs) &&
+ !same_image(image3.get(), image2.get(), ibs) &&
+ !same_image(image4.get(), image2.get(), ibs));
REPORTER_ASSERT(reporter, image2->unique());
- REPORTER_ASSERT(reporter, !same_image_surf(image2, surface, ibs, sbs));
+ REPORTER_ASSERT(reporter, !same_image_surf(image2.get(), surface, ibs, sbs));
// Image 4 should not be shared with any other image.
- REPORTER_ASSERT(reporter, !same_image(image1, image4, ibs) &&
- !same_image(image3, image4, ibs));
- REPORTER_ASSERT(reporter, !same_image_surf(image4, surface, ibs, sbs));
+ REPORTER_ASSERT(reporter, !same_image(image1.get(), image4.get(), ibs) &&
+ !same_image(image3.get(), image4.get(), ibs));
+ REPORTER_ASSERT(reporter, !same_image_surf(image4.get(), surface, ibs, sbs));
REPORTER_ASSERT(reporter, image4->unique());
}
}
@@ -455,7 +455,7 @@
* Test legacy behavor of bumping the surface's device's bitmap's genID when we access its
* texture handle for writing.
*
- * Note: this needs to be tested separately from checking newImageSnapshot, as calling that
+ * Note: this needs to be tested separately from checking makeImageSnapshot, as calling that
* can also incidentally bump the genID (when a new backing surface is created).
*/
static void test_backend_handle_gen_id(
@@ -478,22 +478,22 @@
static void test_backend_handle_unique_id(
skiatest::Reporter* reporter, SkSurface* surface,
GrBackendObject (*func)(SkSurface*, SkSurface::BackendHandleAccess)) {
- SkAutoTUnref<SkImage> image0(surface->newImageSnapshot());
+ sk_sp<SkImage> image0(surface->makeImageSnapshot());
GrBackendObject obj = func(surface, SkSurface::kFlushRead_BackendHandleAccess);
REPORTER_ASSERT(reporter, obj != 0);
- SkAutoTUnref<SkImage> image1(surface->newImageSnapshot());
+ sk_sp<SkImage> image1(surface->makeImageSnapshot());
// just read access should not affect the snapshot
REPORTER_ASSERT(reporter, image0->uniqueID() == image1->uniqueID());
obj = func(surface, SkSurface::kFlushWrite_BackendHandleAccess);
REPORTER_ASSERT(reporter, obj != 0);
- SkAutoTUnref<SkImage> image2(surface->newImageSnapshot());
+ sk_sp<SkImage> image2(surface->makeImageSnapshot());
// expect a new image, since we claimed we would write
REPORTER_ASSERT(reporter, image0->uniqueID() != image2->uniqueID());
obj = func(surface, SkSurface::kDiscardWrite_BackendHandleAccess);
REPORTER_ASSERT(reporter, obj != 0);
- SkAutoTUnref<SkImage> image3(surface->newImageSnapshot());
+ sk_sp<SkImage> image3(surface->makeImageSnapshot());
// expect a new(er) image, since we claimed we would write
REPORTER_ASSERT(reporter, image0->uniqueID() != image3->uniqueID());
REPORTER_ASSERT(reporter, image2->uniqueID() != image3->uniqueID());
@@ -563,11 +563,11 @@
#define EXPECT_COPY_ON_WRITE(command) \
{ \
- SkImage* imageBefore = surface->newImageSnapshot(); \
- SkAutoTUnref<SkImage> aur_before(imageBefore); \
+ sk_sp<SkImage> imageBefore = surface->makeImageSnapshot(); \
+ sk_sp<SkImage> aur_before(imageBefore); \
canvas-> command ; \
- SkImage* imageAfter = surface->newImageSnapshot(); \
- SkAutoTUnref<SkImage> aur_after(imageAfter); \
+ sk_sp<SkImage> imageAfter = surface->makeImageSnapshot(); \
+ sk_sp<SkImage> aur_after(imageAfter); \
REPORTER_ASSERT(reporter, imageBefore != imageAfter); \
}
@@ -608,7 +608,7 @@
// acquiring and releasing a snapshot without triggering a copy on write.
SkCanvas* canvas = surface->getCanvas();
canvas->clear(1);
- surface->newImageSnapshot()->unref(); // Create and destroy SkImage
+ surface->makeImageSnapshot(); // Create and destroy SkImage
canvas->clear(2); // Must not assert internally
}
DEF_TEST(SurfaceWriteableAfterSnapshotRelease, reporter) {
@@ -635,20 +635,20 @@
SkCanvas* canvas1 = surface1->getCanvas();
SkCanvas* canvas2 = surface2->getCanvas();
canvas1->clear(1);
- SkAutoTUnref<SkImage> image1(surface1->newImageSnapshot());
+ sk_sp<SkImage> image1(surface1->makeImageSnapshot());
// Trigger copy on write, new backing is a scratch texture
canvas1->clear(2);
- SkAutoTUnref<SkImage> image2(surface1->newImageSnapshot());
+ sk_sp<SkImage> image2(surface1->makeImageSnapshot());
// Trigger copy on write, old backing should not be returned to scratch
// pool because it is held by image2
canvas1->clear(3);
canvas2->clear(4);
- SkAutoTUnref<SkImage> image3(surface2->newImageSnapshot());
+ sk_sp<SkImage> image3(surface2->makeImageSnapshot());
// Trigger copy on write on surface2. The new backing store should not
// be recycling a texture that is held by an existing image.
canvas2->clear(5);
- SkAutoTUnref<SkImage> image4(surface2->newImageSnapshot());
+ sk_sp<SkImage> image4(surface2->makeImageSnapshot());
REPORTER_ASSERT(reporter, as_IB(image4)->peekTexture() != as_IB(image3)->peekTexture());
// The following assertion checks crbug.com/263329
REPORTER_ASSERT(reporter, as_IB(image4)->peekTexture() != as_IB(image2)->peekTexture());
@@ -668,7 +668,7 @@
DEF_TEST(SurfaceGetTexture, reporter) {
SkAutoTUnref<SkSurface> surface(create_surface());
- SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
+ sk_sp<SkImage> image(surface->makeImageSnapshot());
REPORTER_ASSERT(reporter, as_IB(image)->peekTexture() == nullptr);
surface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode);
REPORTER_ASSERT(reporter, as_IB(image)->peekTexture() == nullptr);
@@ -677,7 +677,7 @@
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfacepeekTexture_Gpu, reporter, context) {
for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
SkAutoTUnref<SkSurface> surface(surface_func(context, kPremul_SkAlphaType, nullptr));
- SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
+ sk_sp<SkImage> image(surface->makeImageSnapshot());
GrTexture* texture = as_IB(image)->peekTexture();
REPORTER_ASSERT(reporter, texture);
REPORTER_ASSERT(reporter, 0 != texture->getTextureHandle());
@@ -701,6 +701,10 @@
return ((SkImage_Gpu*)image)->peekTexture()->resourcePriv().isBudgeted();
}
+static SkBudgeted is_budgeted(const sk_sp<SkImage> image) {
+ return is_budgeted(image.get());
+}
+
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceBudget, reporter, context) {
SkImageInfo info = SkImageInfo::MakeN32Premul(8,8);
for (auto sbudgeted : { SkBudgeted::kNo, SkBudgeted::kYes }) {
@@ -710,7 +714,7 @@
SkASSERT(surface);
REPORTER_ASSERT(reporter, sbudgeted == is_budgeted(surface));
- SkAutoTUnref<SkImage> image(surface->newImageSnapshot(ibudgeted));
+ sk_sp<SkImage> image(surface->makeImageSnapshot(ibudgeted));
// Initially the image shares a texture with the surface, and the surface decides
// whether it is budgeted or not.
@@ -741,15 +745,15 @@
SkSurface::ContentChangeMode mode) {
// Verifies the robustness of SkSurface for handling use cases where calls
// are made before a canvas is created.
- SkImage* image1 = surface->newImageSnapshot();
- SkAutoTUnref<SkImage> aur_image1(image1);
+ sk_sp<SkImage> image1 = surface->makeImageSnapshot();
+ sk_sp<SkImage> aur_image1(image1);
SkDEBUGCODE(image1->validate();)
SkDEBUGCODE(surface->validate();)
surface->notifyContentWillChange(mode);
SkDEBUGCODE(image1->validate();)
SkDEBUGCODE(surface->validate();)
- SkImage* image2 = surface->newImageSnapshot();
- SkAutoTUnref<SkImage> aur_image2(image2);
+ sk_sp<SkImage> image2 = surface->makeImageSnapshot();
+ sk_sp<SkImage> aur_image2(image2);
SkDEBUGCODE(image2->validate();)
SkDEBUGCODE(surface->validate();)
REPORTER_ASSERT(reporter, image1 != image2);
@@ -784,7 +788,7 @@
SkPixmap surfacePM;
REPORTER_ASSERT(reporter, surface->peekPixels(&surfacePM));
- SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
+ sk_sp<SkImage> image(surface->makeImageSnapshot());
SkPixmap pm;
REPORTER_ASSERT(reporter, image->peekPixels(&pm));
@@ -792,7 +796,7 @@
// trigger a copy-on-write
surface->getCanvas()->drawPaint(SkPaint());
- SkAutoTUnref<SkImage> image2(surface->newImageSnapshot());
+ sk_sp<SkImage> image2(surface->makeImageSnapshot());
REPORTER_ASSERT(reporter, image->uniqueID() != image2->uniqueID());
SkPixmap pm2;
@@ -866,7 +870,7 @@
SkBaseDevice* d =
s->getCanvas()->getDevice_just_for_deprecated_compatibility_testing();
return d->accessRenderTarget(); },
- [] (SkSurface* s){ SkAutoTUnref<SkImage> i(s->newImageSnapshot());
+ [] (SkSurface* s){ sk_sp<SkImage> i(s->makeImageSnapshot());
return as_IB(i)->peekTexture(); },
};
for (auto grSurfaceGetter : grSurfaceGetters) {
diff --git a/tests/TextureStorageAllocator.cpp b/tests/TextureStorageAllocator.cpp
index 73d9dc0..5c9962e 100644
--- a/tests/TextureStorageAllocator.cpp
+++ b/tests/TextureStorageAllocator.cpp
@@ -72,7 +72,7 @@
REPORTER_ASSERT(reporter, surface);
GrGLuint id = allocator.m_mostRecentlyAllocatedStorage;
- SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
+ sk_sp<SkImage> image(surface->makeImageSnapshot());
REPORTER_ASSERT(reporter, image->isTextureBacked());
SkImageInfo imageInfo = SkImageInfo::MakeN32Premul(1,1);
GrColor dest = 0x11223344;
@@ -80,7 +80,7 @@
REPORTER_ASSERT(reporter, GrColorUnpackG(dest) == 0);
surface->getCanvas()->clear(SK_ColorGREEN);
- SkAutoTUnref<SkImage> image2(surface->newImageSnapshot());
+ sk_sp<SkImage> image2(surface->makeImageSnapshot());
REPORTER_ASSERT(reporter, image2->isTextureBacked());
REPORTER_ASSERT(reporter, allocator.m_mostRecentlyAllocatedStorage != id);