diff options
101 files changed, 637 insertions, 668 deletions
diff --git a/bench/DisplacementBench.cpp b/bench/DisplacementBench.cpp index f3f9472061..c22b8fd2d1 100644 --- a/bench/DisplacementBench.cpp +++ b/bench/DisplacementBench.cpp @@ -67,7 +67,7 @@ protected: } } - fCheckerboard.reset(surface->newImageSnapshot()); + fCheckerboard = surface->makeImageSnapshot(); } void drawClippedBitmap(SkCanvas* canvas, int x, int y, const SkPaint& paint) { @@ -82,7 +82,7 @@ protected: inline bool isSmall() const { return fIsSmall; } SkBitmap fBitmap; - SkAutoTUnref<SkImage> fCheckerboard; + sk_sp<SkImage> fCheckerboard; private: bool fInitialized; @@ -102,7 +102,7 @@ protected: void onDraw(int loops, SkCanvas* canvas) override { SkPaint paint; - SkAutoTUnref<SkImageFilter> displ(SkImageSource::Create(fCheckerboard)); + SkAutoTUnref<SkImageFilter> displ(SkImageSource::Create(fCheckerboard.get())); // No displacement effect paint.setImageFilter(SkDisplacementMapEffect::Create( SkDisplacementMapEffect::kR_ChannelSelectorType, @@ -129,7 +129,7 @@ protected: void onDraw(int loops, SkCanvas* canvas) override { SkPaint paint; - SkAutoTUnref<SkImageFilter> displ(SkImageSource::Create(fCheckerboard)); + SkAutoTUnref<SkImageFilter> displ(SkImageSource::Create(fCheckerboard.get())); // Displacement, with 1 alpha component (which isn't pre-multiplied) paint.setImageFilter(SkDisplacementMapEffect::Create( SkDisplacementMapEffect::kB_ChannelSelectorType, @@ -155,7 +155,7 @@ protected: void onDraw(int loops, SkCanvas* canvas) override { SkPaint paint; - SkAutoTUnref<SkImageFilter> displ(SkImageSource::Create(fCheckerboard)); + SkAutoTUnref<SkImageFilter> displ(SkImageSource::Create(fCheckerboard.get())); // Displacement, with 2 non-alpha components paint.setImageFilter(SkDisplacementMapEffect::Create( SkDisplacementMapEffect::kR_ChannelSelectorType, diff --git a/bench/ImageBench.cpp b/bench/ImageBench.cpp index 097ed91d5d..b07d267b60 100644 --- a/bench/ImageBench.cpp +++ b/bench/ImageBench.cpp @@ -33,7 +33,7 @@ protected: SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100); SkAutoTUnref<SkSurface> surface(canvas->newSurface(info)); canvas->drawColor(SK_ColorRED); - fImage.reset(surface->newImageSnapshot()); + fImage = surface->makeImageSnapshot(); // create a cpu-backed Surface fRasterSurface.reset(SkSurface::NewRaster(info)); @@ -49,14 +49,14 @@ protected: void onDraw(int loops, SkCanvas*) override { for (int i = 0; i < loops; i++) { for (int inner = 0; inner < 10; ++inner) { - fRasterSurface->getCanvas()->drawImage(fImage, 0, 0); + fRasterSurface->getCanvas()->drawImage(fImage.get(), 0, 0); } } } private: SkString fName; - SkAutoTUnref<SkImage> fImage; + sk_sp<SkImage> fImage; SkAutoTUnref<SkSurface> fRasterSurface; typedef Benchmark INHERITED; diff --git a/bench/MergeBench.cpp b/bench/MergeBench.cpp index 925b6b2bfe..b24f988ded 100644 --- a/bench/MergeBench.cpp +++ b/bench/MergeBench.cpp @@ -45,8 +45,8 @@ protected: private: SkImageFilter* mergeBitmaps() { - SkAutoTUnref<SkImageFilter> first(SkImageSource::Create(fCheckerboard)); - SkAutoTUnref<SkImageFilter> second(SkImageSource::Create(fImage)); + SkAutoTUnref<SkImageFilter> first(SkImageSource::Create(fCheckerboard.get())); + SkAutoTUnref<SkImageFilter> second(SkImageSource::Create(fImage.get())); return SkMergeImageFilter::Create(first, second); } @@ -59,7 +59,7 @@ private: paint.setTextSize(SkIntToScalar(96)); const char* str = "g"; surface->getCanvas()->drawText(str, strlen(str), 15, 55, paint); - fImage.reset(surface->newImageSnapshot()); + fImage = surface->makeImageSnapshot(); } void make_checkerboard() { @@ -82,12 +82,12 @@ private: } } - fCheckerboard.reset(surface->newImageSnapshot()); + fCheckerboard = surface->makeImageSnapshot(); } bool fIsSmall; bool fInitialized; - SkAutoTUnref<SkImage> fImage, fCheckerboard; + sk_sp<SkImage> fImage, fCheckerboard; typedef Benchmark INHERITED; }; diff --git a/bench/PDFBench.cpp b/bench/PDFBench.cpp index ba25e44f37..920a02da4a 100644 --- a/bench/PDFBench.cpp +++ b/bench/PDFBench.cpp @@ -49,15 +49,13 @@ protected: return backend == kNonRendering_Backend; } void onDelayedSetup() override { - SkAutoTUnref<SkImage> img(GetResourceAsImage("color_wheel.png")); + sk_sp<SkImage> img(GetResourceAsImage("color_wheel.png")); if (img) { // force decoding, throw away reference to encoded data. SkAutoPixmapStorage pixmap; pixmap.alloc(SkImageInfo::MakeN32Premul(img->dimensions())); if (img->readPixels(pixmap, 0, 0)) { - fImage.reset(SkImage::NewRasterCopy( - pixmap.info(), pixmap.addr(), - pixmap.rowBytes(), pixmap.ctable())); + fImage = SkImage::MakeRasterCopy(pixmap); } } } @@ -67,7 +65,7 @@ protected: } while (loops-- > 0) { SkAutoTUnref<SkPDFObject> object( - SkPDFCreateBitmapObject(fImage, nullptr)); + SkPDFCreateBitmapObject(fImage.get(), nullptr)); SkASSERT(object); if (!object) { return; @@ -77,7 +75,7 @@ protected: } private: - SkAutoTUnref<SkImage> fImage; + sk_sp<SkImage> fImage; }; class PDFJpegImageBench : public Benchmark { @@ -91,13 +89,12 @@ protected: return backend == kNonRendering_Backend; } void onDelayedSetup() override { - SkAutoTUnref<SkImage> img( - GetResourceAsImage("mandrill_512_q075.jpg")); + sk_sp<SkImage> img(GetResourceAsImage("mandrill_512_q075.jpg")); if (!img) { return; } SkAutoTUnref<SkData> encoded(img->refEncoded()); SkASSERT(encoded); if (!encoded) { return; } - fImage.reset(img.release()); + fImage = img; } void onDraw(int loops, SkCanvas*) override { if (!fImage) { @@ -106,7 +103,7 @@ protected: } while (loops-- > 0) { SkAutoTUnref<SkPDFObject> object( - SkPDFCreateBitmapObject(fImage, nullptr)); + SkPDFCreateBitmapObject(fImage.get(), nullptr)); SkASSERT(object); if (!object) { return; @@ -116,7 +113,7 @@ protected: } private: - SkAutoTUnref<SkImage> fImage; + sk_sp<SkImage> fImage; }; /** Test calling DEFLATE on a 78k PDF command stream. Used for measuring diff --git a/bench/SKPBench.cpp b/bench/SKPBench.cpp index b4724195df..1d378b5046 100644 --- a/bench/SKPBench.cpp +++ b/bench/SKPBench.cpp @@ -90,7 +90,7 @@ void SKPBench::onPerCanvasPostDraw(SkCanvas* canvas) { // Draw the last set of tiles into the master canvas in case we're // saving the images for (int i = 0; i < fTileRects.count(); ++i) { - SkAutoTUnref<SkImage> image(fSurfaces[i]->newImageSnapshot()); + sk_sp<SkImage> image(fSurfaces[i]->makeImageSnapshot()); canvas->drawImage(image, SkIntToScalar(fTileRects[i].fLeft), SkIntToScalar(fTileRects[i].fTop)); SkSafeSetNull(fSurfaces[i]); diff --git a/bench/SkLinearBitmapPipelineBench.cpp b/bench/SkLinearBitmapPipelineBench.cpp index 0c60eed302..7d2d4a54dd 100644 --- a/bench/SkLinearBitmapPipelineBench.cpp +++ b/bench/SkLinearBitmapPipelineBench.cpp @@ -173,9 +173,8 @@ struct SkBitmapFPOrigShader : public CommonBitmapFPBenchmark { void onPreDraw(SkCanvas* c) override { CommonBitmapFPBenchmark::onPreDraw(c); - SkImage* image = SkImage::NewRasterCopy( - fInfo, fBitmap.get(), sizeof(SkPMColor) * fSrcSize.fWidth); - fImage.reset(image); + fImage = SkImage::MakeRasterCopy( + SkPixmap(fInfo, fBitmap.get(), sizeof(SkPMColor) * fSrcSize.fWidth)); fPaint.setShader(fImage->makeShader(fXTile, fYTile)); if (fUseBilerp) { fPaint.setFilterQuality(SkFilterQuality::kLow_SkFilterQuality); @@ -209,7 +208,7 @@ struct SkBitmapFPOrigShader : public CommonBitmapFPBenchmark { ctx->~Context(); } SkPaint fPaint; - SkAutoTUnref<SkImage> fImage; + sk_sp<SkImage> fImage; }; static SkISize srcSize = SkISize::Make(120, 100); diff --git a/dm/DMSrcSink.cpp b/dm/DMSrcSink.cpp index 27cb6aa54e..f571b5d6d7 100644 --- a/dm/DMSrcSink.cpp +++ b/dm/DMSrcSink.cpp @@ -818,7 +818,7 @@ Error ImageGenSrc::draw(SkCanvas* canvas) const { // We have disabled these tests in DM.cpp. SkASSERT(kGray_8_SkColorType != gen->getInfo().colorType()); - SkAutoTDelete<SkImage> image(SkImage::NewFromGenerator(gen.release(), nullptr)); + sk_sp<SkImage> image(SkImage::MakeFromGenerator(gen.release(), nullptr)); if (!image) { return "Could not create image from codec image generator."; } @@ -1315,7 +1315,7 @@ Error ViaTiles::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkStri mpd.draw(); for (int j = 0; j < yTiles; j++) { for (int i = 0; i < xTiles; i++) { - SkAutoTUnref<SkImage> image(surfaces[i+xTiles*j]->newImageSnapshot()); + sk_sp<SkImage> image(surfaces[i+xTiles*j]->makeImageSnapshot()); canvas->drawImage(image, SkIntToScalar(i*fW), SkIntToScalar(j*fH)); } } diff --git a/example/HelloWorld.cpp b/example/HelloWorld.cpp index 817bbaa463..bb29a0c3f5 100644 --- a/example/HelloWorld.cpp +++ b/example/HelloWorld.cpp @@ -150,7 +150,7 @@ void HelloWorldWindow::draw(SkCanvas* canvas) { if (kRaster_DeviceType == fType) { // need to send the raster bits to the (gpu) window - sk_sp<SkImage> snap = sk_sp<SkImage>(fSurface->newImageSnapshot()); + sk_sp<SkImage> snap = fSurface->makeImageSnapshot(); SkPixmap pmap; if (snap->peekPixels(&pmap)) { const SkImageInfo& info = pmap.info(); diff --git a/gm/SkLinearBitmapPipelineGM.cpp b/gm/SkLinearBitmapPipelineGM.cpp index e93d2ac4c3..51fd2cfd46 100644 --- a/gm/SkLinearBitmapPipelineGM.cpp +++ b/gm/SkLinearBitmapPipelineGM.cpp @@ -57,8 +57,7 @@ static void draw_rect_orig(SkCanvas* canvas, const SkRect& r, SkColor c, const S SkImageInfo info = SkImageInfo::MakeN32Premul(ir.width(), ir.height(), kLinear_SkColorProfileType); - SkAutoTUnref<SkImage> image{SkImage::NewRasterCopy( - info, pmsrc.addr32(), pmsrc.rowBytes())}; + sk_sp<SkImage> image(SkImage::MakeRasterCopy(SkPixmap(info, pmsrc.addr32(), pmsrc.rowBytes()))); SkPaint paint; int32_t storage[300]; paint.setShader(image->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode)); diff --git a/gm/all_bitmap_configs.cpp b/gm/all_bitmap_configs.cpp index 46c5d5eed5..c533b6fcae 100644 --- a/gm/all_bitmap_configs.cpp +++ b/gm/all_bitmap_configs.cpp @@ -192,7 +192,7 @@ DEF_SIMPLE_GM(all_bitmap_configs, canvas, SCALE, 6 * SCALE) { } // Works on Ganesh, fails on Raster. -SkImage* make_not_native32_color_wheel() { +sk_sp<SkImage> make_not_native32_color_wheel() { SkBitmap n32bitmap, notN32bitmap; n32bitmap.allocN32Pixels(SCALE, SCALE); n32bitmap.eraseColor(SK_ColorTRANSPARENT); @@ -207,12 +207,12 @@ SkImage* make_not_native32_color_wheel() { static_assert(ct != kN32_SkColorType, "BRGA!=RGBA"); SkAssertResult(n32bitmap.copyTo(¬N32bitmap, ct)); SkASSERT(notN32bitmap.colorType() == ct); - return SkImage::NewFromBitmap(notN32bitmap); + return SkImage::MakeFromBitmap(notN32bitmap); } DEF_SIMPLE_GM(not_native32_bitmap_config, canvas, SCALE, SCALE) { - SkAutoTUnref<SkImage> notN32image(make_not_native32_color_wheel()); + sk_sp<SkImage> notN32image(make_not_native32_color_wheel()); SkASSERT(notN32image); sk_tool_utils::draw_checkerboard(canvas, SK_ColorLTGRAY, SK_ColorWHITE, 8); - canvas->drawImage(notN32image, 0.0f, 0.0f); + canvas->drawImage(notN32image.get(), 0.0f, 0.0f); } diff --git a/gm/astcbitmap.cpp b/gm/astcbitmap.cpp index 211e8daff0..181cfa4019 100644 --- a/gm/astcbitmap.cpp +++ b/gm/astcbitmap.cpp @@ -62,7 +62,7 @@ DEF_SIMPLE_GM(astcbitmap, canvas, kGMDimension, kGMDimension) { DEF_SIMPLE_GM(astc_image, canvas, kGMDimension, kGMDimension) { for (int j = 0; j < 4; ++j) { for (int i = 0; i < 4; ++i) { - SkAutoTUnref<SkImage> image(GetResourceAsImage(get_astc_filename(j*4+i))); + sk_sp<SkImage> image(GetResourceAsImage(get_astc_filename(j*4+i))); if (image) { const SkScalar bmX = static_cast<SkScalar>(i*kBitmapDimension); const SkScalar bmY = static_cast<SkScalar>(j*kBitmapDimension); diff --git a/gm/bigtileimagefilter.cpp b/gm/bigtileimagefilter.cpp index f2164e8e2f..84b9816a83 100644 --- a/gm/bigtileimagefilter.cpp +++ b/gm/bigtileimagefilter.cpp @@ -10,7 +10,7 @@ #include "SkTileImageFilter.h" #include "gm.h" -static SkImage* create_circle_texture(int size, SkColor color) { +static sk_sp<SkImage> create_circle_texture(int size, SkColor color) { SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(size, size)); SkCanvas* canvas = surface->getCanvas(); canvas->clear(0xFF000000); @@ -22,7 +22,7 @@ static SkImage* create_circle_texture(int size, SkColor color) { canvas->drawCircle(SkScalarHalf(size), SkScalarHalf(size), SkScalarHalf(size), paint); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } namespace skiagm { @@ -44,8 +44,8 @@ protected: } void onOnceBeforeDraw() override { - fRedImage.reset(create_circle_texture(kBitmapSize, SK_ColorRED)); - fGreenImage.reset(create_circle_texture(kBitmapSize, SK_ColorGREEN)); + fRedImage = create_circle_texture(kBitmapSize, SK_ColorRED); + fGreenImage = create_circle_texture(kBitmapSize, SK_ColorGREEN); } void onDraw(SkCanvas* canvas) override { @@ -55,11 +55,11 @@ protected: SkPaint p; SkRect bound = SkRect::MakeWH(SkIntToScalar(kWidth), SkIntToScalar(kHeight)); - SkAutoTUnref<SkImageFilter> imageSource(SkImageSource::Create(fRedImage)); + sk_sp<SkImageFilter> imageSource(SkImageSource::Create(fRedImage.get())); SkAutoTUnref<SkImageFilter> tif(SkTileImageFilter::Create( SkRect::MakeWH(SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize)), SkRect::MakeWH(SkIntToScalar(kWidth), SkIntToScalar(kHeight)), - imageSource)); + imageSource.get())); p.setImageFilter(tif); canvas->saveLayer(&bound, &p); @@ -84,7 +84,7 @@ protected: SkRect bound3 = SkRect::MakeXYWH(320, 320, SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize)); - canvas->drawImageRect(fGreenImage, bound2, bound3, nullptr, + canvas->drawImageRect(fGreenImage.get(), bound2, bound3, nullptr, SkCanvas::kStrict_SrcRectConstraint); canvas->restore(); } @@ -95,8 +95,8 @@ private: static const int kHeight = 512; static const int kBitmapSize = 64; - SkAutoTUnref<SkImage> fRedImage; - SkAutoTUnref<SkImage> fGreenImage; + sk_sp<SkImage> fRedImage; + sk_sp<SkImage> fGreenImage; typedef GM INHERITED; }; diff --git a/gm/bleed.cpp b/gm/bleed.cpp index 5a04162938..c3d026a6e8 100644 --- a/gm/bleed.cpp +++ b/gm/bleed.cpp @@ -27,10 +27,10 @@ struct TestPixels { kBitmap, kImage }; - Type fType; - SkBitmap fBitmap; - SkAutoTUnref<SkImage> fImage; - SkIRect fRect; // The region of the bitmap/image that should be rendered. + Type fType; + SkBitmap fBitmap; + sk_sp<SkImage> fImage; + SkIRect fRect; // The region of the bitmap/image that should be rendered. }; /** Creates a bitmap with two one-pixel rings around a checkerboard. The checkerboard is 2x2 @@ -130,7 +130,7 @@ static bool make_ringed_alpha_bitmap(GrContext* ctx, TestPixels* result, int wid /** Helper to reuse above functions to produce images rather than bmps */ static void bmp_to_image(TestPixels* result) { SkASSERT(TestPixels::kBitmap == result->fType); - result->fImage.reset(SkImage::NewFromBitmap(result->fBitmap)); + result->fImage = SkImage::MakeFromBitmap(result->fBitmap); SkASSERT(result->fImage); result->fType = TestPixels::kImage; result->fBitmap.reset(); @@ -345,7 +345,7 @@ protected: if (TestPixels::kBitmap == pixels.fType) { canvas->drawBitmapRect(pixels.fBitmap, src, dst, paint, constraint); } else { - canvas->drawImageRect(pixels.fImage, src, dst, paint, constraint); + canvas->drawImageRect(pixels.fImage.get(), src, dst, paint, constraint); } } diff --git a/gm/colorfilterimagefilter.cpp b/gm/colorfilterimagefilter.cpp index fa33a9c5cb..f72108f433 100644 --- a/gm/colorfilterimagefilter.cpp +++ b/gm/colorfilterimagefilter.cpp @@ -66,7 +66,7 @@ static sk_sp<SkShader> sh_make_lineargradient1() { } static sk_sp<SkShader> sh_make_image() { - SkAutoTUnref<SkImage> image(GetResourceAsImage("mandrill_128.png")); + sk_sp<SkImage> image(GetResourceAsImage("mandrill_128.png")); if (!image) { return nullptr; } diff --git a/gm/colormatrix.cpp b/gm/colormatrix.cpp index b6e83d3ceb..de80ebb64b 100644 --- a/gm/colormatrix.cpp +++ b/gm/colormatrix.cpp @@ -37,11 +37,11 @@ protected: } void onOnceBeforeDraw() override { - fSolidImg.reset(CreateSolidBitmap(64, 64)); - fTransparentImg.reset(CreateTransparentBitmap(64, 64)); + fSolidImg = CreateSolidBitmap(64, 64); + fTransparentImg = CreateTransparentBitmap(64, 64); } - static SkImage* CreateSolidBitmap(int width, int height) { + static sk_sp<SkImage> CreateSolidBitmap(int width, int height) { SkBitmap bm; bm.allocN32Pixels(width, height); SkCanvas canvas(bm); @@ -54,11 +54,11 @@ protected: SkIntToScalar(y), SK_Scalar1, SK_Scalar1), paint); } } - return SkImage::NewFromBitmap(bm); + return SkImage::MakeFromBitmap(bm); } // creates a bitmap with shades of transparent gray. - static SkImage* CreateTransparentBitmap(int width, int height) { + static sk_sp<SkImage> CreateTransparentBitmap(int width, int height) { SkBitmap bm; bm.allocN32Pixels(width, height); SkCanvas canvas(bm); @@ -70,7 +70,7 @@ protected: paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode)); canvas.drawRect(SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height)), paint); - return SkImage::NewFromBitmap(bm); + return SkImage::MakeFromBitmap(bm); } void onDraw(SkCanvas* canvas) override { @@ -78,7 +78,7 @@ protected: SkColorMatrix matrix; paint.setXfermodeMode(SkXfermode::kSrc_Mode); - const SkImage* bmps[] = { fSolidImg, fTransparentImg }; + const SkImage* bmps[] = { fSolidImg.get(), fTransparentImg.get() }; for (size_t i = 0; i < SK_ARRAY_COUNT(bmps); ++i) { matrix.setIdentity(); @@ -139,8 +139,8 @@ protected: } private: - SkAutoTUnref<SkImage> fSolidImg; - SkAutoTUnref<SkImage> fTransparentImg; + sk_sp<SkImage> fSolidImg; + sk_sp<SkImage> fTransparentImg; typedef skiagm::GM INHERITED; }; diff --git a/gm/colorwheel.cpp b/gm/colorwheel.cpp index efa3a6b0b4..530e0c2eed 100644 --- a/gm/colorwheel.cpp +++ b/gm/colorwheel.cpp @@ -12,7 +12,7 @@ #include "sk_tool_utils.h" static void draw_image(SkCanvas* canvas, const char* resource, int x, int y) { - SkAutoTUnref<SkImage> image(GetResourceAsImage(resource)); + sk_sp<SkImage> image(GetResourceAsImage(resource)); if (image) { canvas->drawImage(image, SkIntToScalar(x), SkIntToScalar(y)); } else { diff --git a/gm/complexclip_blur_tiled.cpp b/gm/complexclip_blur_tiled.cpp index aac04167b7..b619e67e14 100644 --- a/gm/complexclip_blur_tiled.cpp +++ b/gm/complexclip_blur_tiled.cpp @@ -58,8 +58,7 @@ protected: tileCanvas->drawRect(rect, paint); tileCanvas->restore(); tileCanvas->restore(); - SkAutoTUnref<SkImage> tileImage(tileSurface->newImageSnapshot()); - canvas->drawImage(tileImage, x, y); + canvas->drawImage(tileSurface->makeImageSnapshot().get(), x, y); } } } diff --git a/gm/dftext.cpp b/gm/dftext.cpp index cccca3863d..545911c26c 100644 --- a/gm/dftext.cpp +++ b/gm/dftext.cpp @@ -201,9 +201,7 @@ protected: SkAutoCanvasRestore acr(inputCanvas, true); // since we prepended this matrix already, we blit using identity inputCanvas->resetMatrix(); - SkImage* image = surface->newImageSnapshot(); - inputCanvas->drawImage(image, 0, 0, nullptr); - image->unref(); + inputCanvas->drawImage(surface->makeImageSnapshot().get(), 0, 0, nullptr); } #endif } diff --git a/gm/displacement.cpp b/gm/displacement.cpp index c5f1837c91..a3fb9e5e5b 100644 --- a/gm/displacement.cpp +++ b/gm/displacement.cpp @@ -30,16 +30,16 @@ protected: SkColor c1 = sk_tool_utils::color_to_565(0xFF244484); SkColor c2 = sk_tool_utils::color_to_565(0xFF804020); - fCheckerboard.reset(SkImage::NewFromBitmap( - sk_tool_utils::create_checkerboard_bitmap(80, 80, c1, c2, 8))); - fSmall.reset(SkImage::NewFromBitmap( - sk_tool_utils::create_checkerboard_bitmap(64, 64, c1, c2, 8))); - fLarge.reset(SkImage::NewFromBitmap( - sk_tool_utils::create_checkerboard_bitmap(96, 96, c1, c2, 8))); - fLargeW.reset( - SkImage::NewFromBitmap(sk_tool_utils::create_checkerboard_bitmap(96, 64, c1, c2, 8))); - fLargeH.reset(SkImage::NewFromBitmap( - sk_tool_utils::create_checkerboard_bitmap(64, 96, c1, c2, 8))); + fCheckerboard = SkImage::MakeFromBitmap( + sk_tool_utils::create_checkerboard_bitmap(80, 80, c1, c2, 8)); + fSmall = SkImage::MakeFromBitmap( + sk_tool_utils::create_checkerboard_bitmap(64, 64, c1, c2, 8)); + fLarge = SkImage::MakeFromBitmap( + sk_tool_utils::create_checkerboard_bitmap(96, 96, c1, c2, 8)); + fLargeW = + SkImage::MakeFromBitmap(sk_tool_utils::create_checkerboard_bitmap(96, 64, c1, c2, 8)); + fLargeH = SkImage::MakeFromBitmap( + sk_tool_utils::create_checkerboard_bitmap(64, 96, c1, c2, 8)); } SkISize onISize() override { @@ -57,7 +57,7 @@ protected: void onDraw(SkCanvas* canvas) override { canvas->clear(SK_ColorBLACK); SkPaint paint; - SkAutoTUnref<SkImageFilter> displ(SkImageSource::Create(fCheckerboard)); + SkAutoTUnref<SkImageFilter> displ(SkImageSource::Create(fCheckerboard.get())); paint.setImageFilter(SkDisplacementMapEffect::Create( SkDisplacementMapEffect::kR_ChannelSelectorType, SkDisplacementMapEffect::kG_ChannelSelectorType, 0.0f, displ))->unref(); @@ -161,25 +161,25 @@ protected: this->drawClippedBitmap(canvas, 500, 0, paint); // Tests for images of different sizes - displ.reset(SkImageSource::Create(fSmall)); + displ.reset(SkImageSource::Create(fSmall.get())); paint.setImageFilter(SkDisplacementMapEffect::Create( SkDisplacementMapEffect::kR_ChannelSelectorType, SkDisplacementMapEffect::kG_ChannelSelectorType, 40.0f, displ))->unref(); drawClippedBitmap(canvas, 0, 400, paint); - displ.reset(SkImageSource::Create(fLarge)); + displ.reset(SkImageSource::Create(fLarge.get())); paint.setImageFilter(SkDisplacementMapEffect::Create( SkDisplacementMapEffect::kB_ChannelSelectorType, SkDisplacementMapEffect::kA_ChannelSelectorType, 40.0f, displ))->unref(); drawClippedBitmap(canvas, 100, 400, paint); - displ.reset(SkImageSource::Create(fLargeW)); + displ.reset(SkImageSource::Create(fLargeW.get())); paint.setImageFilter(SkDisplacementMapEffect::Create( SkDisplacementMapEffect::kR_ChannelSelectorType, SkDisplacementMapEffect::kB_ChannelSelectorType, 40.0f, displ))->unref(); drawClippedBitmap(canvas, 200, 400, paint); - displ.reset(SkImageSource::Create(fLargeH)); + displ.reset(SkImageSource::Create(fLargeH.get())); paint.setImageFilter(SkDisplacementMapEffect::Create( SkDisplacementMapEffect::kG_ChannelSelectorType, SkDisplacementMapEffect::kA_ChannelSelectorType, @@ -198,7 +198,7 @@ protected: private: SkBitmap fBitmap; - SkAutoTUnref<SkImage> fCheckerboard, fSmall, fLarge, fLargeW, fLargeH; + sk_sp<SkImage> fCheckerboard, fSmall, fLarge, fLargeW, fLargeH; typedef GM INHERITED; }; diff --git a/gm/drawatlas.cpp b/gm/drawatlas.cpp index 858e4bf056..4d2f6d46f3 100644 --- a/gm/drawatlas.cpp +++ b/gm/drawatlas.cpp @@ -11,7 +11,7 @@ #include "SkSurface.h" class DrawAtlasGM : public skiagm::GM { - static SkImage* MakeAtlas(SkCanvas* caller, const SkRect& target) { + static sk_sp<SkImage> MakeAtlas(SkCanvas* caller, const SkRect& target) { SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100); SkAutoTUnref<SkSurface> surface(caller->newSurface(info)); if (nullptr == surface) { @@ -32,10 +32,10 @@ class DrawAtlasGM : public skiagm::GM { paint.setColor(SK_ColorBLUE); paint.setAntiAlias(true); canvas->drawOval(target, paint); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } - SkAutoTUnref<SkImage> fAtlas; + sk_sp<SkImage> fAtlas; public: DrawAtlasGM() {} @@ -53,7 +53,7 @@ protected: void onDraw(SkCanvas* canvas) override { const SkRect target = { 50, 50, 80, 90 }; if (nullptr == fAtlas) { - fAtlas.reset(MakeAtlas(canvas, target)); + fAtlas = MakeAtlas(canvas, target); } const struct { @@ -91,9 +91,9 @@ protected: paint.setFilterQuality(kLow_SkFilterQuality); paint.setAntiAlias(true); - canvas->drawAtlas(fAtlas, xform, tex, N, nullptr, &paint); + canvas->drawAtlas(fAtlas.get(), xform, tex, N, nullptr, &paint); canvas->translate(0, 100); - canvas->drawAtlas(fAtlas, xform, tex, colors, N, SkXfermode::kSrcIn_Mode, nullptr, &paint); + canvas->drawAtlas(fAtlas.get(), xform, tex, colors, N, SkXfermode::kSrcIn_Mode, nullptr, &paint); } private: diff --git a/gm/drawatlascolor.cpp b/gm/drawatlascolor.cpp index b5f9d7a285..85a7a9473a 100644 --- a/gm/drawatlascolor.cpp +++ b/gm/drawatlascolor.cpp @@ -15,7 +15,7 @@ // ------------------------------------ // opaque green | transparent black // -static SkImage* make_atlas(SkCanvas* caller, int atlasSize) { +static sk_sp<SkImage> make_atlas(SkCanvas* caller, int atlasSize) { const int kBlockSize = atlasSize/2; SkImageInfo info = SkImageInfo::MakeN32Premul(atlasSize, atlasSize); @@ -48,7 +48,7 @@ static SkImage* make_atlas(SkCanvas* caller, int atlasSize) { SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize)); canvas->drawRect(r, paint); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } // This GM tests the drawAtlas API with colors, different xfer modes @@ -73,7 +73,7 @@ protected: const SkRect target = SkRect::MakeWH(SkIntToScalar(kAtlasSize), SkIntToScalar(kAtlasSize)); if (nullptr == fAtlas) { - fAtlas.reset(make_atlas(canvas, kAtlasSize)); + fAtlas = make_atlas(canvas, kAtlasSize); } const struct { @@ -151,11 +151,11 @@ protected: canvas->translate(SkIntToScalar(i*(target.height()+kPad)), SkIntToScalar(kTextPad+kPad)); // w/o a paint - canvas->drawAtlas(fAtlas, xforms, rects, quadColors, numColors, + canvas->drawAtlas(fAtlas.get(), xforms, rects, quadColors, numColors, gModes[i].fMode, nullptr, nullptr); canvas->translate(0.0f, numColors*(target.height()+kPad)); // w a paint - canvas->drawAtlas(fAtlas, xforms, rects, quadColors, numColors, + canvas->drawAtlas(fAtlas.get(), xforms, rects, quadColors, numColors, gModes[i].fMode, nullptr, &paint); canvas->restore(); } @@ -169,7 +169,7 @@ private: static const int kTextPad = 8; - SkAutoTUnref<SkImage> fAtlas; + sk_sp<SkImage> fAtlas; typedef GM INHERITED; }; diff --git a/gm/drawbitmaprect.cpp b/gm/drawbitmaprect.cpp index 7ee2271c5c..8ec7cee28e 100644 --- a/gm/drawbitmaprect.cpp +++ b/gm/drawbitmaprect.cpp @@ -33,7 +33,7 @@ static SkBitmap make_chessbm(int w, int h) { return bm; } -static SkImage* makebm(SkCanvas* origCanvas, SkBitmap* resultBM, int w, int h) { +static sk_sp<SkImage> makebm(SkCanvas* origCanvas, SkBitmap* resultBM, int w, int h) { SkImageInfo info = SkImageInfo::MakeN32Premul(w, h); SkAutoTUnref<SkSurface> surface(origCanvas->newSurface(info)); @@ -81,7 +81,7 @@ static SkImage* makebm(SkCanvas* origCanvas, SkBitmap* resultBM, int w, int h) { mat.postScale(SK_Scalar1 / 4, SK_Scalar1 / 4); } - SkImage* image = surface->newImageSnapshot(); + auto image = surface->makeImageSnapshot(); SkBitmap tempBM; @@ -125,10 +125,10 @@ public: } } - DrawRectRectProc* fProc; - SkBitmap fLargeBitmap; - SkAutoTUnref<SkImage> fImage; - SkString fName; + DrawRectRectProc* fProc; + SkBitmap fLargeBitmap; + sk_sp<SkImage> fImage; + SkString fName; protected: SkString onShortName() override { return fName; } @@ -136,7 +136,7 @@ protected: SkISize onISize() override { return SkISize::Make(gSize, gSize); } void setupImage(SkCanvas* canvas) { - fImage.reset(makebm(canvas, &fLargeBitmap, gBmpSize, gBmpSize)); + fImage = makebm(canvas, &fLargeBitmap, gBmpSize, gBmpSize); } void onDraw(SkCanvas* canvas) override { @@ -172,7 +172,7 @@ protected: for (int h = 1; h <= kMaxSrcRectSize; h *= 4) { SkIRect srcRect = SkIRect::MakeXYWH((gBmpSize - w) / 2, (gBmpSize - h) / 2, w, h); - fProc(canvas, fImage, fLargeBitmap, srcRect, dstRect); + fProc(canvas, fImage.get(), fLargeBitmap, srcRect, dstRect); SkString label; label.appendf("%d x %d", w, h); diff --git a/gm/drawminibitmaprect.cpp b/gm/drawminibitmaprect.cpp index f0ce1a2db6..c494605daf 100644 --- a/gm/drawminibitmaprect.cpp +++ b/gm/drawminibitmaprect.cpp @@ -13,7 +13,7 @@ #include "SkShader.h" #include "SkSurface.h" -static SkImage* makebm(SkCanvas* caller, int w, int h) { +static sk_sp<SkImage> makebm(SkCanvas* caller, int w, int h) { SkImageInfo info = SkImageInfo::MakeN32Premul(w, h); SkAutoTUnref<SkSurface> surface(caller->newSurface(info)); if (nullptr == surface) { @@ -56,7 +56,7 @@ static SkImage* makebm(SkCanvas* caller, int w, int h) { rect.inset(wScalar / 8, hScalar / 8); mat.postScale(SK_Scalar1 / 4, SK_Scalar1 / 4); } - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } static const int gSize = 1024; @@ -80,7 +80,7 @@ protected: void onDraw(SkCanvas* canvas) override { if (nullptr == fImage) { - fImage.reset(makebm(canvas, gSurfaceSize, gSurfaceSize)); + fImage = makebm(canvas, gSurfaceSize, gSurfaceSize); } const SkRect dstRect = { 0, 0, SkIntToScalar(64), SkIntToScalar(64)}; @@ -113,7 +113,7 @@ protected: // rect stays rect break; } - canvas->drawImageRect(fImage, srcRect, dstRect, &paint, + canvas->drawImageRect(fImage.get(), srcRect, dstRect, &paint, SkCanvas::kFast_SrcRectConstraint); canvas->restore(); @@ -131,9 +131,9 @@ protected: } private: - bool fAA; - SkAutoTUnref<SkImage> fImage; - SkString fName; + bool fAA; + sk_sp<SkImage> fImage; + SkString fName; typedef skiagm::GM INHERITED; }; diff --git a/gm/etc1bitmap.cpp b/gm/etc1bitmap.cpp index e2f6c2dc41..51c1f3948c 100644 --- a/gm/etc1bitmap.cpp +++ b/gm/etc1bitmap.cpp @@ -98,13 +98,13 @@ protected: SkBitmap bm; SkString filename = GetResourcePath("mandrill_128."); filename.append(this->fileExtension()); - SkAutoTUnref<SkData> fileData(SkData::NewFromFileName(filename.c_str())); + sk_sp<SkData> fileData(SkData::MakeFromFileName(filename.c_str())); if (nullptr == fileData) { SkDebugf("Could not open the file. Did you forget to set the resourcePath?\n"); return; } - SkAutoTUnref<SkImage> image(SkImage::NewFromEncoded(fileData)); + sk_sp<SkImage> image(SkImage::MakeFromEncoded(std::move(fileData))); if (nullptr == image) { SkDebugf("Could not decode the ETC file. ETC may not be included in this platform.\n"); return; @@ -201,10 +201,8 @@ protected: SkASSERT(124 == height); size_t dataSz = etc1_get_encoded_data_size(width, height) + ETC_PKM_HEADER_SIZE; - SkAutoDataUnref nonPOTData(SkData::NewWithCopy(am.get(), dataSz)); - - SkAutoTUnref<SkImage> image(SkImage::NewFromEncoded(nonPOTData)); - canvas->drawImage(image, 0, 0); + sk_sp<SkData> nonPOTData(SkData::MakeWithCopy(am.get(), dataSz)); + canvas->drawImage(SkImage::MakeFromEncoded(std::move(nonPOTData)).get(), 0, 0); } private: diff --git a/gm/filterfastbounds.cpp b/gm/filterfastbounds.cpp index 453dded8cc..9623e4265b 100644 --- a/gm/filterfastbounds.cpp +++ b/gm/filterfastbounds.cpp @@ -275,8 +275,8 @@ protected: temp->drawRect(SkRect::MakeLTRB(5, 0, 10, 5), p); } - SkAutoTUnref<SkImage> image(surface->newImageSnapshot()); - SkAutoTUnref<SkImageFilter> imageSource(SkImageSource::Create(image)); + sk_sp<SkImage> image(surface->makeImageSnapshot()); + SkAutoTUnref<SkImageFilter> imageSource(SkImageSource::Create(image.get())); SkTArray<SkPaint> bmsPaints; create_paints(imageSource, &bmsPaints); diff --git a/gm/grayscalejpg.cpp b/gm/grayscalejpg.cpp index 70ea72e9bd..bc88ee13a6 100644 --- a/gm/grayscalejpg.cpp +++ b/gm/grayscalejpg.cpp @@ -15,7 +15,7 @@ */ DEF_SIMPLE_GM(grayscalejpg, canvas, 128, 128) { const char kResource[] = "grayscale.jpg"; - SkAutoTUnref<SkImage> image(GetResourceAsImage(kResource)); + sk_sp<SkImage> image(GetResourceAsImage(kResource)); if (image) { canvas->drawImage(image, 0.0f, 0.0f); } else { diff --git a/gm/image.cpp b/gm/image.cpp index 4e22dd0ff5..d54f1cf203 100644 --- a/gm/image.cpp +++ b/gm/image.cpp @@ -22,17 +22,16 @@ static void drawJpeg(SkCanvas* canvas, const SkISize& size) { // TODO: Make this draw a file that is checked in, so it can // be exercised on machines other than mike's. Will require a // rebaseline. - SkAutoDataUnref data(SkData::NewFromFileName("/Users/mike/Downloads/skia.google.jpeg")); - if (nullptr == data.get()) { + sk_sp<SkData> data(SkData::MakeFromFileName("/Users/mike/Downloads/skia.google.jpeg")); + if (nullptr == data) { return; } - SkImage* image = SkImage::NewFromEncoded(data); + sk_sp<SkImage> image = SkImage::MakeFromEncoded(std::move(data)); if (image) { SkAutoCanvasRestore acr(canvas, true); canvas->scale(size.width() * 1.0f / image->width(), size.height() * 1.0f / image->height()); canvas->drawImage(image, 0, 0, nullptr); - image->unref(); } } @@ -58,16 +57,15 @@ static void drawContents(SkSurface* surface, SkColor fillC) { static void test_surface(SkCanvas* canvas, SkSurface* surf, bool usePaint) { drawContents(surf, SK_ColorRED); - SkImage* imgR = surf->newImageSnapshot(); + sk_sp<SkImage> imgR = surf->makeImageSnapshot(); if (true) { - SkImage* imgR2 = surf->newImageSnapshot(); + sk_sp<SkImage> imgR2 = surf->makeImageSnapshot(); SkASSERT(imgR == imgR2); - imgR2->unref(); } drawContents(surf, SK_ColorGREEN); - SkImage* imgG = surf->newImageSnapshot(); + sk_sp<SkImage> imgG = surf->makeImageSnapshot(); // since we've drawn after we snapped imgR, imgG will be a different obj SkASSERT(imgR != imgG); @@ -78,8 +76,8 @@ static void test_surface(SkCanvas* canvas, SkSurface* surf, bool usePaint) { // paint.setFilterBitmap(true); // paint.setAlpha(0x80); - canvas->drawImage(imgR, 0, 0, usePaint ? &paint : nullptr); - canvas->drawImage(imgG, 0, 80, usePaint ? &paint : nullptr); + canvas->drawImage(imgR.get(), 0, 0, usePaint ? &paint : nullptr); + canvas->drawImage(imgG.get(), 0, 80, usePaint ? &paint : nullptr); surf->draw(canvas, 0, 160, usePaint ? &paint : nullptr); SkRect src1, src2, src3; @@ -94,13 +92,10 @@ static void test_surface(SkCanvas* canvas, SkSurface* surf, bool usePaint) { dst3.set(0, 400, 65, 465); dst4.set(0, 480, 65, 545); - canvas->drawImageRect(imgR, src1, dst1, usePaint ? &paint : nullptr); - canvas->drawImageRect(imgG, src2, dst2, usePaint ? &paint : nullptr); - canvas->drawImageRect(imgR, src3, dst3, usePaint ? &paint : nullptr); - canvas->drawImageRect(imgG, dst4, usePaint ? &paint : nullptr); - - imgG->unref(); - imgR->unref(); + canvas->drawImageRect(imgR.get(), src1, dst1, usePaint ? &paint : nullptr); + canvas->drawImageRect(imgG.get(), src2, dst2, usePaint ? &paint : nullptr); + canvas->drawImageRect(imgR.get(), src3, dst3, usePaint ? &paint : nullptr); + canvas->drawImageRect(imgG.get(), dst4, usePaint ? &paint : nullptr); } class ImageGM : public skiagm::GM { @@ -242,33 +237,33 @@ static void draw_contents(SkCanvas* canvas) { canvas->drawCircle(50, 50, 35, paint); } -static SkImage* make_raster(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) { +static sk_sp<SkImage> make_raster(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) { SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info)); draw(surface->getCanvas()); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } -static SkImage* make_picture(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) { +static sk_sp<SkImage> make_picture(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) { SkPictureRecorder recorder; draw(recorder.beginRecording(SkRect::MakeIWH(info.width(), info.height()))); SkAutoTUnref<SkPicture> pict(recorder.endRecording()); - return SkImage::NewFromPicture(pict, info.dimensions(), nullptr, nullptr); + return SkImage::MakeFromPicture(sk_ref_sp(pict.get()), info.dimensions(), nullptr, nullptr); } -static SkImage* make_codec(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) { - SkAutoTUnref<SkImage> image(make_raster(info, nullptr, draw)); - SkAutoTUnref<SkData> data(image->encode()); - return SkImage::NewFromEncoded(data); +static sk_sp<SkImage> make_codec(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) { + sk_sp<SkImage> image(make_raster(info, nullptr, draw)); + sk_sp<SkData> data(image->encode()); + return SkImage::MakeFromEncoded(data); } -static SkImage* make_gpu(const SkImageInfo& info, GrContext* ctx, void (*draw)(SkCanvas*)) { +static sk_sp<SkImage> make_gpu(const SkImageInfo& info, GrContext* ctx, void (*draw)(SkCanvas*)) { if (!ctx) { return nullptr; } SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkBudgeted::kNo, info)); draw(surface->getCanvas()); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } -typedef SkImage* (*ImageMakerProc)(const SkImageInfo&, GrContext*, void (*)(SkCanvas*)); +typedef sk_sp<SkImage> (*ImageMakerProc)(const SkImageInfo&, GrContext*, void (*)(SkCanvas*)); class ScalePixelsGM : public skiagm::GM { public: @@ -290,9 +285,9 @@ protected: make_codec, make_raster, make_picture, make_codec, make_gpu, }; for (auto& proc : procs) { - SkAutoTUnref<SkImage> image(proc(info, canvas->getGrContext(), draw_contents)); + sk_sp<SkImage> image(proc(info, canvas->getGrContext(), draw_contents)); if (image) { - show_scaled_pixels(canvas, image); + show_scaled_pixels(canvas, image.get()); } canvas->translate(0, 120); } @@ -342,8 +337,7 @@ static void draw_opaque_contents(SkCanvas* canvas) { static SkImageGenerator* gen_raster(const SkImageInfo& info) { SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info)); draw_opaque_contents(surface->getCanvas()); - SkAutoTUnref<SkImage> img(surface->newImageSnapshot()); - return new ImageGeneratorFromImage(img); + return new ImageGeneratorFromImage(surface->makeImageSnapshot().get()); } static SkImageGenerator* gen_picture(const SkImageInfo& info) { @@ -354,13 +348,13 @@ static SkImageGenerator* gen_picture(const SkImageInfo& info) { } static SkImageGenerator* gen_png(const SkImageInfo& info) { - SkAutoTUnref<SkImage> image(make_raster(info, nullptr, draw_opaque_contents)); + sk_sp<SkImage> image(make_raster(info, nullptr, draw_opaque_contents)); SkAutoTUnref<SkData> data(image->encode(SkImageEncoder::kPNG_Type, 100)); return SkImageGenerator::NewFromEncoded(data); } static SkImageGenerator* gen_jpg(const SkImageInfo& info) { - SkAutoTUnref<SkImage> image(make_raster(info, nullptr, draw_opaque_contents)); + sk_sp<SkImage> image(make_raster(info, nullptr, draw_opaque_contents)); SkAutoTUnref<SkData> data(image->encode(SkImageEncoder::kJPEG_Type, 100)); return SkImageGenerator::NewFromEncoded(data); } @@ -466,16 +460,16 @@ DEF_SIMPLE_GM(new_texture_image, canvas, 225, 60) { SkCanvas bmpCanvas(bmp); render_image(&bmpCanvas); - std::function<SkImage*()> imageFactories[] = { + std::function<sk_sp<SkImage>()> imageFactories[] = { // Create sw raster image. [bmp] { - return SkImage::NewFromBitmap(bmp); + return SkImage::MakeFromBitmap(bmp); }, // Create encoded image. [bmp] { - SkAutoTUnref<SkData> src( + sk_sp<SkData> src( SkImageEncoder::EncodeData(bmp, SkImageEncoder::kPNG_Type, 100)); - return SkImage::NewFromEncoded(src); + return SkImage::MakeFromEncoded(std::move(src)); }, // Create a picture image. [render_image] { @@ -483,10 +477,11 @@ DEF_SIMPLE_GM(new_texture_image, canvas, 225, 60) { SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kSize), SkIntToScalar(kSize)); render_image(canvas); SkAutoTUnref<SkPicture> picture(recorder.endRecording()); - return SkImage::NewFromPicture(picture, SkISize::Make(kSize, kSize), nullptr, nullptr); + return SkImage::MakeFromPicture(sk_ref_sp(picture.get()), SkISize::Make(kSize, kSize), + nullptr, nullptr); }, // Create a texture image - [context, render_image]() -> SkImage* { + [context, render_image]() -> sk_sp<SkImage> { SkAutoTUnref<SkSurface> surface( SkSurface::NewRenderTarget(context, SkBudgeted::kYes, SkImageInfo::MakeN32Premul(kSize, kSize))); @@ -494,19 +489,19 @@ DEF_SIMPLE_GM(new_texture_image, canvas, 225, 60) { return nullptr; } render_image(surface->getCanvas()); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } }; static const SkScalar kPad = 5.f; canvas->translate(kPad, kPad); for (auto factory : imageFactories) { - SkAutoTUnref<SkImage> image(factory()); + auto image(factory()); if (!image) { continue; } if (context) { - SkAutoTUnref<SkImage> texImage(image->newTextureImage(context)); + sk_sp<SkImage> texImage(image->makeTextureImage(context)); if (texImage) { canvas->drawImage(texImage, 0, 0); } diff --git a/gm/image_pict.cpp b/gm/image_pict.cpp index 52c9309bc8..fd21d717c0 100644 --- a/gm/image_pict.cpp +++ b/gm/image_pict.cpp @@ -36,8 +36,8 @@ static void draw_something(SkCanvas* canvas, const SkRect& bounds) { */ class ImagePictGM : public skiagm::GM { SkAutoTUnref<SkPicture> fPicture; - SkAutoTUnref<SkImage> fImage0; - SkAutoTUnref<SkImage> fImage1; + sk_sp<SkImage> fImage0; + sk_sp<SkImage> fImage1; public: ImagePictGM() {} @@ -61,18 +61,18 @@ protected: SkMatrix matrix; matrix.setTranslate(-100, -100); - fImage0.reset(SkImage::NewFromPicture(fPicture, size, &matrix, nullptr)); + fImage0 = SkImage::MakeFromPicture(sk_ref_sp(fPicture.get()), size, &matrix, nullptr); matrix.postTranslate(-50, -50); matrix.postRotate(45); matrix.postTranslate(50, 50); - fImage1.reset(SkImage::NewFromPicture(fPicture, size, &matrix, nullptr)); + fImage1 = SkImage::MakeFromPicture(sk_ref_sp(fPicture.get()), size, &matrix, nullptr); } void drawSet(SkCanvas* canvas) const { SkMatrix matrix = SkMatrix::MakeTrans(-100, -100); canvas->drawPicture(fPicture, &matrix, nullptr); - canvas->drawImage(fImage0, 150, 0); - canvas->drawImage(fImage1, 300, 0); + canvas->drawImage(fImage0.get(), 150, 0); + canvas->drawImage(fImage1.get(), 300, 0); } void onDraw(SkCanvas* canvas) override { @@ -216,7 +216,7 @@ public: surface->getCanvas()->clear(0); surface->getCanvas()->translate(-100, -100); surface->getCanvas()->drawPicture(pic); - SkAutoTUnref<SkImage> image(surface->newImageSnapshot()); + sk_sp<SkImage> image(surface->makeImageSnapshot()); fTexture.reset(SkRef(as_IB(image)->peekTexture())); } protected: diff --git a/gm/image_shader.cpp b/gm/image_shader.cpp index 7ea0202296..e7378c4470 100644 --- a/gm/image_shader.cpp +++ b/gm/image_shader.cpp @@ -24,16 +24,16 @@ static void draw_something(SkCanvas* canvas, const SkRect& bounds) { canvas->drawOval(bounds, paint); } -typedef SkImage* (*ImageMakerProc)(GrContext*, const SkPicture*, const SkImageInfo&); +typedef sk_sp<SkImage> (*ImageMakerProc)(GrContext*, SkPicture*, const SkImageInfo&); -static SkImage* make_raster(GrContext*, const SkPicture* pic, const SkImageInfo& info) { +static sk_sp<SkImage> make_raster(GrContext*, SkPicture* pic, const SkImageInfo& info) { SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info)); surface->getCanvas()->clear(0); surface->getCanvas()->drawPicture(pic); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } -static SkImage* make_texture(GrContext* ctx, const SkPicture* pic, const SkImageInfo& info) { +static sk_sp<SkImage> make_texture(GrContext* ctx, SkPicture* pic, const SkImageInfo& info) { if (!ctx) { return nullptr; } @@ -41,23 +41,23 @@ static SkImage* make_texture(GrContext* ctx, const SkPicture* pic, const SkImage info, 0)); surface->getCanvas()->clear(0); surface->getCanvas()->drawPicture(pic); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } -static SkImage* make_pict_gen(GrContext*, const SkPicture* pic, const SkImageInfo& info) { - return SkImage::NewFromPicture(pic, info.dimensions(), nullptr, nullptr); +static sk_sp<SkImage> make_pict_gen(GrContext*, SkPicture* pic, const SkImageInfo& info) { + return SkImage::MakeFromPicture(sk_ref_sp(pic), info.dimensions(), nullptr, nullptr); } -static SkImage* make_encode_gen(GrContext* ctx, const SkPicture* pic, const SkImageInfo& info) { - SkAutoTUnref<SkImage> src(make_raster(ctx, pic, info)); +static sk_sp<SkImage> make_encode_gen(GrContext* ctx, SkPicture* pic, const SkImageInfo& info) { + sk_sp<SkImage> src(make_raster(ctx, pic, info)); if (!src) { return nullptr; } - SkAutoTUnref<SkData> encoded(src->encode(SkImageEncoder::kPNG_Type, 100)); + sk_sp<SkData> encoded(src->encode(SkImageEncoder::kPNG_Type, 100)); if (!encoded) { return nullptr; } - return SkImage::NewFromEncoded(encoded); + return SkImage::MakeFromEncoded(std::move(encoded)); } const ImageMakerProc gProcs[] = { @@ -113,9 +113,9 @@ protected: const SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100); for (size_t i = 0; i < SK_ARRAY_COUNT(gProcs); ++i) { - SkAutoTUnref<SkImage> image(gProcs[i](canvas->getGrContext(), fPicture, info)); + sk_sp<SkImage> image(gProcs[i](canvas->getGrContext(), fPicture, info)); if (image) { - this->testImage(canvas, image); + this->testImage(canvas, image.get()); } canvas->translate(120, 0); } diff --git a/gm/imagealphathreshold.cpp b/gm/imagealphathreshold.cpp index ea7185be1d..eafc32f8d6 100644 --- a/gm/imagealphathreshold.cpp +++ b/gm/imagealphathreshold.cpp @@ -102,10 +102,9 @@ protected: surface->getCanvas()->clear(SK_ColorWHITE); draw_rects(surface->getCanvas()); - SkAutoTUnref<SkImage> image(surface->newImageSnapshot()); SkPaint paint = create_filter_paint(); canvas->clipRect(SkRect::MakeLTRB(100, 100, WIDTH - 100, HEIGHT - 100)); - canvas->drawImage(image, 0, 0, &paint); + canvas->drawImage(surface->makeImageSnapshot().get(), 0, 0, &paint); } private: diff --git a/gm/imagefilters.cpp b/gm/imagefilters.cpp index 951a934d82..24a08ff865 100644 --- a/gm/imagefilters.cpp +++ b/gm/imagefilters.cpp @@ -66,14 +66,14 @@ DEF_SIMPLE_GM(imagefilters_xfermodes, canvas, 480, 480) { } } -static SkImage* make_image(SkCanvas* canvas) { +static sk_sp<SkImage> make_image(SkCanvas* canvas) { const SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100); SkAutoTUnref<SkSurface> surface(canvas->newSurface(info)); if (!surface) { surface.reset(SkSurface::NewRaster(info)); } surface->getCanvas()->drawRect(SkRect::MakeXYWH(25, 25, 50, 50), SkPaint()); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } // Compare blurs when we're tightly clipped (fast) and not as tightly (slower) @@ -81,7 +81,7 @@ static SkImage* make_image(SkCanvas* canvas) { // Expect the two to draw the same (modulo the extra border of pixels when the clip is larger) // DEF_SIMPLE_GM(fast_slow_blurimagefilter, canvas, 620, 260) { - SkAutoTUnref<SkImage> image(make_image(canvas)); + sk_sp<SkImage> image(make_image(canvas)); const SkRect r = SkRect::MakeIWH(image->width(), image->height()); canvas->translate(10, 10); @@ -162,7 +162,7 @@ DEF_SIMPLE_GM(savelayer_with_backdrop, canvas, 830, 550) { SkPaint paint; paint.setFilterQuality(kMedium_SkFilterQuality); - SkAutoTUnref<SkImage> image(GetResourceAsImage("mandrill_512.png")); + sk_sp<SkImage> image(GetResourceAsImage("mandrill_512.png")); canvas->translate(20, 20); for (const auto& xform : xforms) { diff --git a/gm/imagefiltersclipped.cpp b/gm/imagefiltersclipped.cpp index 033b80638f..26ee24b1d4 100644 --- a/gm/imagefiltersclipped.cpp +++ b/gm/imagefiltersclipped.cpp @@ -57,7 +57,7 @@ protected: paint.setShader(SkGradientShader::MakeRadial(SkPoint::Make(x, y), radius, colors, nullptr, 2, SkShader::kClamp_TileMode)); canvas->drawCircle(x, y, radius, paint); - fGradientCircle.reset(surface->newImageSnapshot()); + fGradientCircle = surface->makeImageSnapshot(); } static void draw_clipped_filter(SkCanvas* canvas, SkImageFilter* filter, size_t i, @@ -80,16 +80,16 @@ protected: } void onOnceBeforeDraw() override { - fCheckerboard.reset(SkImage::NewFromBitmap - (sk_tool_utils::create_checkerboard_bitmap(64, 64, 0xFFA0A0A0, 0xFF404040, 8))); + fCheckerboard = SkImage::MakeFromBitmap + (sk_tool_utils::create_checkerboard_bitmap(64, 64, 0xFFA0A0A0, 0xFF404040, 8)); this->makeGradientCircle(64, 64); } void onDraw(SkCanvas* canvas) override { canvas->clear(SK_ColorBLACK); - SkAutoTUnref<SkImageFilter> gradient(SkImageSource::Create(fGradientCircle)); - SkAutoTUnref<SkImageFilter> checkerboard(SkImageSource::Create(fCheckerboard)); + SkAutoTUnref<SkImageFilter> gradient(SkImageSource::Create(fGradientCircle.get())); + SkAutoTUnref<SkImageFilter> checkerboard(SkImageSource::Create(fCheckerboard.get())); SkAutoTUnref<SkShader> noise(SkPerlinNoiseShader::CreateFractalNoise( SkDoubleToScalar(0.1), SkDoubleToScalar(0.05), 1, 0)); SkMatrix resizeMatrix; @@ -148,7 +148,7 @@ protected: } private: - SkAutoTUnref<SkImage> fCheckerboard, fGradientCircle; + sk_sp<SkImage> fCheckerboard, fGradientCircle; typedef GM INHERITED; }; diff --git a/gm/imagefilterscropexpand.cpp b/gm/imagefilterscropexpand.cpp index 185bbde0a6..f3ca4d32a6 100644 --- a/gm/imagefilterscropexpand.cpp +++ b/gm/imagefilterscropexpand.cpp @@ -46,12 +46,12 @@ protected: SkRect::Make(SkIRect::MakeXYWH(10, 10, 44, 44)), SkImageFilter::CropRect::kHasAll_CropEdge); - SkAutoTUnref<SkImage> gradientCircle(MakeGradientCircle(64, 64)); + sk_sp<SkImage> gradientCircle(MakeGradientCircle(64, 64)); SkBitmap checkerboard; MakeCheckerboard(&checkerboard); SkAutoTUnref<SkImageFilter> gradientCircleSource( - SkImageSource::Create(gradientCircle)); + SkImageSource::Create(gradientCircle.get())); SkAutoTUnref<SkImageFilter> noopCropped( SkOffsetImageFilter::Create(0, 0, nullptr, &cropRect)); SkScalar sk255 = SkIntToScalar(255); @@ -141,7 +141,7 @@ private: } } - static SkImage* MakeGradientCircle(int width, int height) { + static sk_sp<SkImage> MakeGradientCircle(int width, int height) { SkScalar x = SkIntToScalar(width / 2); SkScalar y = SkIntToScalar(height / 2); SkScalar radius = SkMinScalar(x, y) * 0.8f; @@ -156,7 +156,7 @@ private: 2, SkShader::kClamp_TileMode)); canvas->drawCircle(x, y, radius, paint); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } static void Draw(SkCanvas* canvas, const SkBitmap& bitmap, const SkRect& rect, SkImageFilter* filter) { diff --git a/gm/imagefiltersgraph.cpp b/gm/imagefiltersgraph.cpp index 26ebc4df7d..fa9c512591 100644 --- a/gm/imagefiltersgraph.cpp +++ b/gm/imagefiltersgraph.cpp @@ -111,14 +111,14 @@ protected: SkISize onISize() override { return SkISize::Make(600, 150); } void onOnceBeforeDraw() override { - fImage.reset(SkImage::NewFromBitmap( - sk_tool_utils::create_string_bitmap(100, 100, SK_ColorWHITE, 20, 70, 96, "e"))); + fImage = SkImage::MakeFromBitmap( + sk_tool_utils::create_string_bitmap(100, 100, SK_ColorWHITE, 20, 70, 96, "e")); } void onDraw(SkCanvas* canvas) override { canvas->clear(SK_ColorBLACK); { - SkAutoTUnref<SkImageFilter> bitmapSource(SkImageSource::Create(fImage)); + SkAutoTUnref<SkImageFilter> bitmapSource(SkImageSource::Create(fImage.get())); SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode)); SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(4.0f, 4.0f, bitmapSource)); @@ -146,7 +146,7 @@ protected: SkPaint paint; paint.setImageFilter(blendColor); - DrawClippedImage(canvas, fImage, paint); + DrawClippedImage(canvas, fImage.get(), paint); canvas->translate(SkIntToScalar(100), 0); } { @@ -165,7 +165,7 @@ protected: SkPaint paint; paint.setImageFilter(arithFilter); - DrawClippedImage(canvas, fImage, paint); + DrawClippedImage(canvas, fImage.get(), paint); canvas->translate(SkIntToScalar(100), 0); } { @@ -179,7 +179,7 @@ protected: SkPaint paint; paint.setImageFilter(blend); - DrawClippedImage(canvas, fImage, paint); + DrawClippedImage(canvas, fImage.get(), paint); canvas->translate(SkIntToScalar(100), 0); } { @@ -213,7 +213,7 @@ protected: SkPaint paint; paint.setImageFilter(convolve); - DrawClippedImage(canvas, fImage, paint); + DrawClippedImage(canvas, fImage.get(), paint); canvas->translate(SkIntToScalar(100), 0); } { @@ -245,7 +245,7 @@ private: canvas->restore(); } - SkAutoTUnref<SkImage> fImage; + sk_sp<SkImage> fImage; typedef GM INHERITED; }; diff --git a/gm/imagefiltersscaled.cpp b/gm/imagefiltersscaled.cpp index da4467882b..391f4e5c1c 100644 --- a/gm/imagefiltersscaled.cpp +++ b/gm/imagefiltersscaled.cpp @@ -44,16 +44,16 @@ protected: } void onOnceBeforeDraw() override { - fCheckerboard.reset(SkImage::NewFromBitmap( - sk_tool_utils::create_checkerboard_bitmap(64, 64, 0xFFA0A0A0, 0xFF404040, 8))); - fGradientCircle.reset(MakeGradientCircle(64, 64)); + fCheckerboard = SkImage::MakeFromBitmap( + sk_tool_utils::create_checkerboard_bitmap(64, 64, 0xFFA0A0A0, 0xFF404040, 8)); + fGradientCircle = MakeGradientCircle(64, 64); } void onDraw(SkCanvas* canvas) override { canvas->clear(SK_ColorBLACK); - SkAutoTUnref<SkImageFilter> gradient(SkImageSource::Create(fGradientCircle)); - SkAutoTUnref<SkImageFilter> checkerboard(SkImageSource::Create(fCheckerboard)); + SkAutoTUnref<SkImageFilter> gradient(SkImageSource::Create(fGradientCircle.get())); + SkAutoTUnref<SkImageFilter> checkerboard(SkImageSource::Create(fCheckerboard.get())); SkAutoTUnref<SkShader> noise(SkPerlinNoiseShader::CreateFractalNoise( SkDoubleToScalar(0.1), SkDoubleToScalar(0.05), 1, 0)); SkPaint noisePaint; @@ -135,7 +135,7 @@ protected: } private: - static SkImage* MakeGradientCircle(int width, int height) { + static sk_sp<SkImage> MakeGradientCircle(int width, int height) { SkScalar x = SkIntToScalar(width / 2); SkScalar y = SkIntToScalar(height / 2); SkScalar radius = SkScalarMul(SkMinScalar(x, y), SkIntToScalar(4) / SkIntToScalar(5)); @@ -150,10 +150,10 @@ private: 2, SkShader::kClamp_TileMode)); canvas->drawCircle(x, y, radius, paint); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } - SkAutoTUnref<SkImage> fCheckerboard, fGradientCircle; + sk_sp<SkImage> fCheckerboard, fGradientCircle; typedef GM INHERITED; }; diff --git a/gm/imagefilterstransformed.cpp b/gm/imagefilterstransformed.cpp index 5b9d702efb..4243902efe 100644 --- a/gm/imagefilterstransformed.cpp +++ b/gm/imagefilterstransformed.cpp @@ -24,7 +24,7 @@ namespace skiagm { // It checks that the scale portion of the CTM is correctly extracted // and applied to the image inputs separately from the non-scale portion. -static SkImage* make_gradient_circle(int width, int height) { +static sk_sp<SkImage> make_gradient_circle(int width, int height) { SkScalar x = SkIntToScalar(width / 2); SkScalar y = SkIntToScalar(height / 2); SkScalar radius = SkMinScalar(x, y) * 0.8f; @@ -41,7 +41,7 @@ static SkImage* make_gradient_circle(int width, int height) { SkShader::kClamp_TileMode)); canvas->drawCircle(x, y, radius, paint); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } class ImageFiltersTransformedGM : public GM { @@ -57,14 +57,14 @@ protected: SkISize onISize() override { return SkISize::Make(420, 240); } void onOnceBeforeDraw() override { - fCheckerboard.reset(SkImage::NewFromBitmap( - sk_tool_utils::create_checkerboard_bitmap(64, 64, 0xFFA0A0A0, 0xFF404040, 8))); - fGradientCircle.reset(make_gradient_circle(64, 64)); + fCheckerboard = SkImage::MakeFromBitmap( + sk_tool_utils::create_checkerboard_bitmap(64, 64, 0xFFA0A0A0, 0xFF404040, 8)); + fGradientCircle = make_gradient_circle(64, 64); } void onDraw(SkCanvas* canvas) override { - SkAutoTUnref<SkImageFilter> gradient(SkImageSource::Create(fGradientCircle)); - SkAutoTUnref<SkImageFilter> checkerboard(SkImageSource::Create(fCheckerboard)); + SkAutoTUnref<SkImageFilter> gradient(SkImageSource::Create(fGradientCircle.get())); + SkAutoTUnref<SkImageFilter> checkerboard(SkImageSource::Create(fCheckerboard.get())); SkImageFilter* filters[] = { SkBlurImageFilter::Create(12, 0), SkDropShadowImageFilter::Create(0, 15, 8, 0, SK_ColorGREEN, @@ -113,8 +113,8 @@ protected: } private: - SkAutoTUnref<SkImage> fCheckerboard; - SkAutoTUnref<SkImage> fGradientCircle; + sk_sp<SkImage> fCheckerboard; + sk_sp<SkImage> fGradientCircle; typedef GM INHERITED; }; diff --git a/gm/imagefromyuvtextures.cpp b/gm/imagefromyuvtextures.cpp index 6280ae740b..0d2637cabe 100644 --- a/gm/imagefromyuvtextures.cpp +++ b/gm/imagefromyuvtextures.cpp @@ -90,7 +90,7 @@ protected: ((112 * rgb[0] - 94 * rgb[1] - 18 * rgb[2] + 128) >> 8) + 128); } } - fRGBImage.reset(SkImage::NewRasterCopy(rgbBmp.info(), rgbColors, rgbBmp.rowBytes())); + fRGBImage = SkImage::MakeRasterCopy(SkPixmap(rgbBmp.info(), rgbColors, rgbBmp.rowBytes())); } void createYUVTextures(GrContext* context, GrBackendObject yuvHandles[3]) { @@ -141,28 +141,26 @@ protected: { fYUVBmps[1].width(), fYUVBmps[1].height()}, { fYUVBmps[2].width(), fYUVBmps[2].height()}, }; - SkTArray<SkImage*> images; - images.push_back(SkRef(fRGBImage.get())); + SkTArray<sk_sp<SkImage>> images; + images.push_back(fRGBImage); for (int space = kJPEG_SkYUVColorSpace; space <= kLastEnum_SkYUVColorSpace; ++space) { - images.push_back(SkImage::NewFromYUVTexturesCopy(context, - static_cast<SkYUVColorSpace>(space), - yuvHandles, sizes, - kTopLeft_GrSurfaceOrigin)); + images.push_back(SkImage::MakeFromYUVTexturesCopy(context, + static_cast<SkYUVColorSpace>(space), + yuvHandles, sizes, + kTopLeft_GrSurfaceOrigin)); } this->deleteYUVTextures(context, yuvHandles); for (int i = 0; i < images.count(); ++ i) { SkScalar y = (i + 1) * kPad + i * fYUVBmps[0].height(); SkScalar x = kPad; - canvas->drawImage(images[i], x, y); - images[i]->unref(); - images[i] = nullptr; + canvas->drawImage(images[i].get(), x, y); } } private: - SkAutoTUnref<SkImage> fRGBImage; - SkBitmap fYUVBmps[3]; + sk_sp<SkImage> fRGBImage; + SkBitmap fYUVBmps[3]; static const int kBmpSize = 32; diff --git a/gm/imagescalealigned.cpp b/gm/imagescalealigned.cpp index c9e697cbad..66ad8b62f4 100644 --- a/gm/imagescalealigned.cpp +++ b/gm/imagescalealigned.cpp @@ -20,11 +20,11 @@ protected: auto& set = fSets.push_back(); set.fVector = vectors[i]; - set.fImages.push_back().reset(MakeImage(vectors[i], SK_ColorGREEN)); + set.fImages.push_back() = MakeImage(vectors[i], SK_ColorGREEN); set.fScales.push_back() = 1; - set.fImages.push_back().reset(MakeImage(vectors[i], SK_ColorRED)); + set.fImages.push_back() = MakeImage(vectors[i], SK_ColorRED); set.fScales.push_back() = kStretchFactor; - set.fImages.push_back().reset(MakeImage(vectors[i], SK_ColorGREEN)); + set.fImages.push_back() = MakeImage(vectors[i], SK_ColorGREEN); set.fScales.push_back() = 1; } } @@ -63,12 +63,12 @@ protected: private: struct ImageSet { - SkSTArray<3, SkAutoTUnref<SkImage>, true> fImages; - SkSTArray<3, SkScalar> fScales; - SkVector fVector; + SkSTArray<3, sk_sp<SkImage>, true> fImages; + SkSTArray<3, SkScalar> fScales; + SkVector fVector; }; - static SkImage* MakeImage(const SkVector& vec, SkColor color) { + static sk_sp<SkImage> MakeImage(const SkVector& vec, SkColor color) { const SkPoint start = SkPoint::Make(vec.y() * kSegLen / 2, vec.x() * kSegLen / 2); const SkPoint end = SkPoint::Make(start.x() + vec.x() * (kSegLen - 1), start.y() + vec.y() * (kSegLen - 1)); @@ -88,7 +88,7 @@ private: surface->getCanvas()->drawPoint(start.x(), start.y(), color); surface->getCanvas()->drawPoint(end.x(), end.y(), color); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } void drawSets(SkCanvas* canvas) const { @@ -131,7 +131,7 @@ private: img->width() * (1 + (set.fScales[i] - 1) * set.fVector.x()), img->height() * (1 + (set.fScales[i] - 1) * set.fVector.y())); - canvas->drawImageRect(img, dst, &paint); + canvas->drawImageRect(img.get(), dst, &paint); pt.offset(dst.width() * set.fVector.x(), dst.height() * set.fVector.y()); } diff --git a/gm/imagesource.cpp b/gm/imagesource.cpp index f4574d267c..973dc0c6ea 100644 --- a/gm/imagesource.cpp +++ b/gm/imagesource.cpp @@ -25,7 +25,7 @@ protected: void onOnceBeforeDraw() override { SkBitmap bm = sk_tool_utils::create_string_bitmap(100, 100, 0xFFFFFFFF, 20, 70, 96, "e"); - fImage.reset(SkImage::NewFromBitmap(bm)); + fImage = SkImage::MakeFromBitmap(bm); } static void FillRectFiltered(SkCanvas* canvas, const SkRect& clipRect, SkImageFilter* filter) { @@ -44,13 +44,13 @@ protected: SkRect dstRect = SkRect::MakeXYWH(0, 10, 60, 60); SkRect clipRect = SkRect::MakeXYWH(0, 0, 100, 100); SkRect bounds = SkRect::MakeIWH(fImage->width(), fImage->height()); - SkAutoTUnref<SkImageFilter> imageSource(SkImageSource::Create(fImage)); + SkAutoTUnref<SkImageFilter> imageSource(SkImageSource::Create(fImage.get())); SkAutoTUnref<SkImageFilter> imageSourceSrcRect( - SkImageSource::Create(fImage, srcRect, srcRect, kHigh_SkFilterQuality)); + SkImageSource::Create(fImage.get(), srcRect, srcRect, kHigh_SkFilterQuality)); SkAutoTUnref<SkImageFilter> imageSourceSrcRectDstRect( - SkImageSource::Create(fImage, srcRect, dstRect, kHigh_SkFilterQuality)); + SkImageSource::Create(fImage.get(), srcRect, dstRect, kHigh_SkFilterQuality)); SkAutoTUnref<SkImageFilter> imageSourceDstRectOnly( - SkImageSource::Create(fImage, bounds, dstRect, kHigh_SkFilterQuality)); + SkImageSource::Create(fImage.get(), bounds, dstRect, kHigh_SkFilterQuality)); // Draw an unscaled bitmap. FillRectFiltered(canvas, clipRect, imageSource); @@ -71,7 +71,7 @@ protected: } private: - SkAutoTUnref<SkImage> fImage; + sk_sp<SkImage> fImage; typedef GM INHERITED; }; diff --git a/gm/imagesource2.cpp b/gm/imagesource2.cpp index 7f9c2b5d43..46c42f1d18 100644 --- a/gm/imagesource2.cpp +++ b/gm/imagesource2.cpp @@ -56,7 +56,7 @@ protected: curColor = (curColor+1) % SK_ARRAY_COUNT(gColors); } - fImage.reset(surface->newImageSnapshot()); + fImage = surface->makeImageSnapshot(); } void onDraw(SkCanvas* canvas) override { @@ -65,7 +65,7 @@ protected: SkRect dstRect = SkRect::MakeLTRB(0.75f, 0.75f, 225.75f, 225.75f); SkAutoTUnref<SkImageFilter> filter( - SkImageSource::Create(fImage, srcRect, dstRect, fFilter)); + SkImageSource::Create(fImage.get(), srcRect, dstRect, fFilter)); SkPaint p; p.setImageFilter(filter); @@ -79,7 +79,7 @@ private: SkString fSuffix; SkFilterQuality fFilter; - SkAutoTUnref<SkImage> fImage; + sk_sp<SkImage> fImage; typedef GM INHERITED; }; diff --git a/gm/imagetoyuvplanes.cpp b/gm/imagetoyuvplanes.cpp index 87bff8ee64..ddead1be42 100644 --- a/gm/imagetoyuvplanes.cpp +++ b/gm/imagetoyuvplanes.cpp @@ -12,7 +12,7 @@ #include "SkGradientShader.h" #include "SkImage.h" -static SkImage* create_image(GrContext* context, int width, int height) { +static sk_sp<SkImage> create_image(GrContext* context, int width, int height) { SkAutoTUnref<SkSurface> surface; SkImageInfo info = SkImageInfo::MakeN32Premul(width, height); if (context) { @@ -33,7 +33,7 @@ static SkImage* create_image(GrContext* context, int width, int height) { SkShader::kMirror_TileMode)); surface->getCanvas()->drawPaint(paint); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } DEF_SIMPLE_GM(image_to_yuv_planes, canvas, 120, 525) { @@ -41,12 +41,12 @@ DEF_SIMPLE_GM(image_to_yuv_planes, canvas, 120, 525) { static const int kImageSize = 32; GrContext *context = canvas->getGrContext(); - SkAutoTUnref<SkImage> rgbImage(create_image(context, kImageSize, kImageSize)); + sk_sp<SkImage> rgbImage(create_image(context, kImageSize, kImageSize)); if (!rgbImage) { return; } - canvas->drawImage(rgbImage, kPad, kPad); + canvas->drawImage(rgbImage.get(), kPad, kPad); // Test cases where all three planes are the same size, where just u and v are the same size, // and where all differ. static const SkISize kSizes[][3] = { diff --git a/gm/localmatriximagefilter.cpp b/gm/localmatriximagefilter.cpp index 64ed6d7b8c..f99655863e 100644 --- a/gm/localmatriximagefilter.cpp +++ b/gm/localmatriximagefilter.cpp @@ -14,7 +14,7 @@ #include "SkOffsetImageFilter.h" #include "SkSurface.h" -static SkImage* make_image(SkCanvas* rootCanvas) { +static sk_sp<SkImage> make_image(SkCanvas* rootCanvas) { SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100); SkAutoTUnref<SkSurface> surface(rootCanvas->newSurface(info)); if (!surface) { @@ -25,7 +25,7 @@ static SkImage* make_image(SkCanvas* rootCanvas) { paint.setAntiAlias(true); paint.setColor(SK_ColorRED); surface->getCanvas()->drawCircle(50, 50, 50, paint); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } typedef SkImageFilter* (*ImageFilterFactory)(); @@ -62,7 +62,7 @@ protected: } void onDraw(SkCanvas* canvas) override { - SkAutoTUnref<SkImage> image0(make_image(canvas)); + sk_sp<SkImage> image0(make_image(canvas)); const ImageFilterFactory factories[] = { IFCCast([]{ return SkBlurImageFilter::Create(8, 8); }), @@ -84,11 +84,11 @@ protected: SkAutoTUnref<SkImageFilter> filter(factory()); canvas->save(); - show_image(canvas, image0, filter); + show_image(canvas, image0.get(), filter); for (const auto& matrix : matrices) { SkAutoTUnref<SkImageFilter> localFilter(filter->newWithLocalMatrix(matrix)); canvas->translate(spacer, 0); - show_image(canvas, image0, localFilter); + show_image(canvas, image0.get(), localFilter); } canvas->restore(); canvas->translate(0, spacer); diff --git a/gm/mipmap.cpp b/gm/mipmap.cpp index b0b0cc487c..4b1912a99c 100644 --- a/gm/mipmap.cpp +++ b/gm/mipmap.cpp @@ -11,7 +11,7 @@ #include "SkRandom.h" #include "SkSurface.h" -static SkImage* make_image() { +static sk_sp<SkImage> make_image() { const SkImageInfo info = SkImageInfo::MakeN32Premul(319, 52); SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info)); SkCanvas* canvas = surface->getCanvas(); @@ -25,11 +25,11 @@ static SkImage* make_image() { canvas->drawCircle(-4, 25, 20, paint); canvas->translate(25, 0); } - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } DEF_SIMPLE_GM(mipmap, canvas, 400, 200) { - SkAutoTUnref<SkImage> img(make_image());//SkImage::NewFromEncoded(data)); + sk_sp<SkImage> img(make_image());//SkImage::NewFromEncoded(data)); SkPaint paint; const SkRect dst = SkRect::MakeWH(177, 15); @@ -42,9 +42,9 @@ DEF_SIMPLE_GM(mipmap, canvas, 400, 200) { canvas->translate(20, 20); for (int i = 0; i < 4; ++i) { paint.setFilterQuality(SkFilterQuality(i)); - canvas->drawImageRect(img, dst, &paint); + canvas->drawImageRect(img.get(), dst, &paint); canvas->translate(0, 20); } - canvas->drawImage(img, 20, 20, nullptr); + canvas->drawImage(img.get(), 20, 20, nullptr); } diff --git a/gm/multipicturedraw.cpp b/gm/multipicturedraw.cpp index 88d6cd798f..c3f6b892bf 100644 --- a/gm/multipicturedraw.cpp +++ b/gm/multipicturedraw.cpp @@ -511,9 +511,8 @@ namespace skiagm { for (int i = 0; i < composeSteps.count(); ++i) { const ComposeStep& step = composeSteps[i]; - SkAutoTUnref<SkImage> image(step.fSurf->newImageSnapshot()); - - canvas->drawImage(image, step.fX, step.fY, step.fPaint); + canvas->drawImage(step.fSurf->makeImageSnapshot().get(), + step.fX, step.fY, step.fPaint); } } diff --git a/gm/ninepatchstretch.cpp b/gm/ninepatchstretch.cpp index 218b452862..f269376bb0 100644 --- a/gm/ninepatchstretch.cpp +++ b/gm/ninepatchstretch.cpp @@ -17,7 +17,7 @@ static SkSurface* make_surface(SkCanvas* root, int N) { return surface; } -static SkImage* make_image(SkCanvas* root, SkIRect* center) { +static sk_sp<SkImage> make_image(SkCanvas* root, SkIRect* center) { const int kFixed = 28; const int kStretchy = 8; const int kSize = 2*kFixed + kStretchy; @@ -43,7 +43,7 @@ static SkImage* make_image(SkCanvas* root, SkIRect* center) { paint.setColor(0x880000FF); canvas->drawRect(r, paint); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } static void image_to_bitmap(const SkImage* image, SkBitmap* bm) { @@ -54,9 +54,9 @@ static void image_to_bitmap(const SkImage* image, SkBitmap* bm) { class NinePatchStretchGM : public skiagm::GM { public: - SkAutoTUnref<SkImage> fImage; - SkBitmap fBitmap; - SkIRect fCenter; + sk_sp<SkImage> fImage; + SkBitmap fBitmap; + SkIRect fCenter; NinePatchStretchGM() {} @@ -71,8 +71,8 @@ protected: void onDraw(SkCanvas* canvas) override { if (nullptr == fBitmap.pixelRef()) { - fImage.reset(make_image(canvas, &fCenter)); - image_to_bitmap(fImage, &fBitmap); + fImage = make_image(canvas, &fCenter); + image_to_bitmap(fImage.get(), &fBitmap); } // amount of bm that should not be stretched (unless we have to) @@ -100,7 +100,7 @@ protected: SkRect r = SkRect::MakeXYWH(x + ix * fixed, y + iy * fixed, size[i].width(), size[i].height()); canvas->drawBitmapNine(fBitmap, fCenter, r, &paint); - canvas->drawImageNine(fImage, fCenter, r.makeOffset(360, 0), &paint); + canvas->drawImageNine(fImage.get(), fCenter, r.makeOffset(360, 0), &paint); } } } diff --git a/gm/offsetimagefilter.cpp b/gm/offsetimagefilter.cpp index eec18cffb9..15cf0450d8 100644 --- a/gm/offsetimagefilter.cpp +++ b/gm/offsetimagefilter.cpp @@ -32,14 +32,14 @@ protected: } void onOnceBeforeDraw() override { - fBitmap.reset(SkImage::NewFromBitmap( - sk_tool_utils::create_string_bitmap(80, 80, 0xD000D000, 15, 65, 96, "e"))); + fBitmap = SkImage::MakeFromBitmap( + sk_tool_utils::create_string_bitmap(80, 80, 0xD000D000, 15, 65, 96, "e")); - fCheckerboard.reset(SkImage::NewFromBitmap( + fCheckerboard = SkImage::MakeFromBitmap( sk_tool_utils::create_checkerboard_bitmap(80, 80, sk_tool_utils::color_to_565(0xFFA0A0A0), sk_tool_utils::color_to_565(0xFF404040), - 8))); + 8)); } void onDraw(SkCanvas* canvas) override { @@ -47,7 +47,7 @@ protected: SkPaint paint; for (int i = 0; i < 4; i++) { - const SkImage* image = (i & 0x01) ? fCheckerboard : fBitmap; + const SkImage* image = (i & 0x01) ? fCheckerboard.get() : fBitmap.get(); SkIRect cropRect = SkIRect::MakeXYWH(i * 12, i * 8, image->width() - i * 8, @@ -67,7 +67,7 @@ protected: SkImageFilter::CropRect rect(SkRect::Make(cropRect)); SkAutoTUnref<SkImageFilter> filter(SkOffsetImageFilter::Create(-5, -10, nullptr, &rect)); paint.setImageFilter(filter); - DrawClippedImage(canvas, fBitmap, paint, 2, cropRect); + DrawClippedImage(canvas, fBitmap.get(), paint, 2, cropRect); } private: static void DrawClippedImage(SkCanvas* canvas, const SkImage* image, const SkPaint& paint, @@ -92,7 +92,7 @@ private: } } - SkAutoTUnref<SkImage> fBitmap, fCheckerboard; + sk_sp<SkImage> fBitmap, fCheckerboard; typedef skiagm::GM INHERITED; }; diff --git a/gm/perspshaders.cpp b/gm/perspshaders.cpp index a29ef52f46..b2ac3287f2 100644 --- a/gm/perspshaders.cpp +++ b/gm/perspshaders.cpp @@ -11,7 +11,7 @@ #include "SkPath.h" #include "SkSurface.h" -static SkImage* make_image(SkCanvas* origCanvas, int w, int h) { +static sk_sp<SkImage> make_image(SkCanvas* origCanvas, int w, int h) { SkImageInfo info = SkImageInfo::MakeN32Premul(w, h); SkAutoTUnref<SkSurface> surface(origCanvas->newSurface(info)); if (nullptr == surface) { @@ -20,7 +20,7 @@ static SkImage* make_image(SkCanvas* origCanvas, int w, int h) { SkCanvas* canvas = surface->getCanvas(); sk_tool_utils::draw_checkerboard(canvas, SK_ColorRED, SK_ColorGREEN, w/10); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } namespace skiagm { @@ -106,7 +106,7 @@ protected: canvas->translate(SkIntToScalar(kCellSize), 0); canvas->save(); canvas->concat(fPerspMatrix); - canvas->drawImage(fImage, 0, 0, &filterPaint); + canvas->drawImage(fImage.get(), 0, 0, &filterPaint); canvas->restore(); canvas->translate(SkIntToScalar(kCellSize), 0); @@ -138,7 +138,7 @@ protected: void onDraw(SkCanvas* canvas) override { if (!fImage) { - fImage.reset(make_image(canvas, kCellSize, kCellSize)); + fImage = make_image(canvas, kCellSize, kCellSize); } this->drawRow(canvas, kNone_SkFilterQuality); @@ -155,14 +155,14 @@ private: static const int kNumRows = 4; static const int kNumCols = 6; - bool fDoAA; - SkPath fPath; - sk_sp<SkShader> fBitmapShader; - sk_sp<SkShader> fLinearGrad1; - sk_sp<SkShader> fLinearGrad2; - SkMatrix fPerspMatrix; - SkAutoTUnref<SkImage> fImage; - SkBitmap fBitmap; + bool fDoAA; + SkPath fPath; + sk_sp<SkShader> fBitmapShader; + sk_sp<SkShader> fLinearGrad1; + sk_sp<SkShader> fLinearGrad2; + SkMatrix fPerspMatrix; + sk_sp<SkImage> fImage; + SkBitmap fBitmap; typedef GM INHERITED; }; diff --git a/gm/rectangletexture.cpp b/gm/rectangletexture.cpp index 4bdb4c9f11..e00afe97d1 100644 --- a/gm/rectangletexture.cpp +++ b/gm/rectangletexture.cpp @@ -54,7 +54,8 @@ protected: SkIntToScalar(width + height) / 5, paint); } - SkImage* createRectangleTextureImg(GrContext* context, int width, int height, void* pixels) { + sk_sp<SkImage> createRectangleTextureImg(GrContext* context, int width, int height, + void* pixels) { if (!context) { return nullptr; } @@ -111,7 +112,7 @@ protected: desc.fHeight = height; desc.fOrigin = kTopLeft_GrSurfaceOrigin; desc.fTextureHandle = reinterpret_cast<GrBackendObject>(&info); - if (SkImage* image = SkImage::NewFromAdoptedTexture(context, desc)) { + if (sk_sp<SkImage> image = SkImage::MakeFromAdoptedTexture(context, desc)) { return image; } GR_GL_CALL(gl, DeleteTextures(1, &id)); @@ -132,8 +133,7 @@ protected: SkPMColor pixels[kWidth * kHeight]; this->fillPixels(kWidth, kHeight, pixels); - SkAutoTUnref<SkImage> rectImg(this->createRectangleTextureImg(context, kWidth, kHeight, - pixels)); + sk_sp<SkImage> rectImg(this->createRectangleTextureImg(context, kWidth, kHeight, pixels)); if (!rectImg) { SkPaint paint; @@ -157,24 +157,24 @@ protected: canvas->save(); canvas->scale(s, s); for (auto q : kQualities) { - SkPaint plainPaint; - plainPaint.setFilterQuality(q); - canvas->drawImage(rectImg, 0, 0, &plainPaint); - canvas->translate(kWidth + kPad, 0); - - SkPaint clampPaint; - clampPaint.setFilterQuality(q); - clampPaint.setShader(rectImg->makeShader(SkShader::kClamp_TileMode, - SkShader::kClamp_TileMode)); - canvas->drawRect(SkRect::MakeWH(1.5f * kWidth, 1.5f * kHeight), clampPaint); - canvas->translate(kWidth * 1.5f + kPad, 0); - - SkPaint repeatPaint; - repeatPaint.setFilterQuality(q); - repeatPaint.setShader(rectImg->makeShader(SkShader::kRepeat_TileMode, - SkShader::kMirror_TileMode)); - canvas->drawRect(SkRect::MakeWH(1.5f * kWidth, 1.5f * kHeight), repeatPaint); - canvas->translate(1.5f * kWidth + kPad, 0); + SkPaint plainPaint; + plainPaint.setFilterQuality(q); + canvas->drawImage(rectImg.get(), 0, 0, &plainPaint); + canvas->translate(kWidth + kPad, 0); + + SkPaint clampPaint; + clampPaint.setFilterQuality(q); + clampPaint.setShader(rectImg->makeShader(SkShader::kClamp_TileMode, + SkShader::kClamp_TileMode)); + canvas->drawRect(SkRect::MakeWH(1.5f * kWidth, 1.5f * kHeight), clampPaint); + canvas->translate(kWidth * 1.5f + kPad, 0); + + SkPaint repeatPaint; + repeatPaint.setFilterQuality(q); + repeatPaint.setShader(rectImg->makeShader(SkShader::kRepeat_TileMode, + SkShader::kMirror_TileMode)); + canvas->drawRect(SkRect::MakeWH(1.5f * kWidth, 1.5f * kHeight), repeatPaint); + canvas->translate(1.5f * kWidth + kPad, 0); } canvas->restore(); canvas->translate(0, kPad + 1.5f * kHeight * s); diff --git a/gm/repeated_bitmap.cpp b/gm/repeated_bitmap.cpp index 39eeb4e6e9..a659e784f7 100644 --- a/gm/repeated_bitmap.cpp +++ b/gm/repeated_bitmap.cpp @@ -35,11 +35,9 @@ static void draw_rotated_image(SkCanvas* canvas, const SkImage* image) { } DEF_SIMPLE_GM(repeated_bitmap, canvas, 576, 576) { - SkAutoTUnref<SkImage> image(GetResourceAsImage("randPixels.png")); - draw_rotated_image(canvas, image); + draw_rotated_image(canvas, GetResourceAsImage("randPixels.png").get()); } DEF_SIMPLE_GM(repeated_bitmap_jpg, canvas, 576, 576) { - SkAutoTUnref<SkImage> image(GetResourceAsImage("color_wheel.jpg")); - draw_rotated_image(canvas, image); + draw_rotated_image(canvas, GetResourceAsImage("color_wheel.jpg").get()); } diff --git a/gm/resizeimagefilter.cpp b/gm/resizeimagefilter.cpp index 9a684a2859..2236b76b3e 100644 --- a/gm/resizeimagefilter.cpp +++ b/gm/resizeimagefilter.cpp @@ -97,11 +97,11 @@ protected: ovalRect.inset(SkIntToScalar(2)/3, SkIntToScalar(2)/3); surfaceCanvas->drawOval(ovalRect, paint); } - SkAutoTUnref<SkImage> image(surface->newImageSnapshot()); + sk_sp<SkImage> image(surface->makeImageSnapshot()); SkRect inRect = SkRect::MakeXYWH(-4, -4, 20, 20); SkRect outRect = SkRect::MakeXYWH(-24, -24, 120, 120); SkAutoTUnref<SkImageFilter> source( - SkImageSource::Create(image, inRect, outRect, kHigh_SkFilterQuality)); + SkImageSource::Create(image.get(), inRect, outRect, kHigh_SkFilterQuality)); canvas->translate(srcRect.width() + SkIntToScalar(10), 0); draw(canvas, srcRect, diff --git a/gm/surface.cpp b/gm/surface.cpp index 6874b5bea3..c817f8d63a 100644 --- a/gm/surface.cpp +++ b/gm/surface.cpp @@ -140,7 +140,7 @@ protected: } drawInto(surf->getCanvas()); - SkAutoTUnref<SkImage> image(surf->newImageSnapshot()); + sk_sp<SkImage> image(surf->makeImageSnapshot()); canvas->drawImage(image, 10, 10, nullptr); SkAutoTUnref<SkSurface> surf2(surf->newSurface(info)); @@ -149,8 +149,8 @@ protected: // Assert that the props were communicated transitively through the first image SkASSERT(equal(surf->props(), surf2->props())); - SkAutoTUnref<SkImage> image2(surf2->newImageSnapshot()); - canvas->drawImage(image2, 10 + SkIntToScalar(image->width()) + 10, 10, nullptr); + sk_sp<SkImage> image2(surf2->makeImageSnapshot()); + canvas->drawImage(image2.get(), 10 + SkIntToScalar(image->width()) + 10, 10, nullptr); } private: diff --git a/gm/textblobmixedsizes.cpp b/gm/textblobmixedsizes.cpp index 86ab0ac8fb..7923489370 100644 --- a/gm/textblobmixedsizes.cpp +++ b/gm/textblobmixedsizes.cpp @@ -171,9 +171,7 @@ protected: SkAutoCanvasRestore acr(inputCanvas, true); // since we prepended this matrix already, we blit using identity inputCanvas->resetMatrix(); - SkImage* image = surface->newImageSnapshot(); - inputCanvas->drawImage(image, 0, 0, nullptr); - image->unref(); + inputCanvas->drawImage(surface->makeImageSnapshot().get(), 0, 0, nullptr); } #endif } diff --git a/gm/tileimagefilter.cpp b/gm/tileimagefilter.cpp index eb0ad09f4b..b03af44207 100644 --- a/gm/tileimagefilter.cpp +++ b/gm/tileimagefilter.cpp @@ -35,14 +35,14 @@ protected: } void onOnceBeforeDraw() override { - fBitmap.reset(SkImage::NewFromBitmap( - sk_tool_utils::create_string_bitmap(50, 50, 0xD000D000, 10, 45, 50, "e"))); + fBitmap = SkImage::MakeFromBitmap( + sk_tool_utils::create_string_bitmap(50, 50, 0xD000D000, 10, 45, 50, "e")); - fCheckerboard.reset(SkImage::NewFromBitmap( + fCheckerboard = SkImage::MakeFromBitmap( sk_tool_utils::create_checkerboard_bitmap(80, 80, sk_tool_utils::color_to_565(0xFFA0A0A0), sk_tool_utils::color_to_565(0xFF404040), - 8))); + 8)); } void onDraw(SkCanvas* canvas) override { @@ -56,7 +56,7 @@ protected: int x = 0, y = 0; for (size_t i = 0; i < 4; i++) { - const SkImage* image = (i & 0x01) ? fCheckerboard : fBitmap; + const SkImage* image = (i & 0x01) ? fCheckerboard.get() : fBitmap.get(); SkRect srcRect = SkRect::MakeXYWH(SkIntToScalar(image->width()/4), SkIntToScalar(image->height()/4), SkIntToScalar(image->width()/(i+1)), @@ -72,7 +72,7 @@ protected: canvas->translate(SkIntToScalar(x), SkIntToScalar(y)); SkPaint paint; paint.setImageFilter(filter); - canvas->drawImage(fBitmap, 0, 0, &paint); + canvas->drawImage(fBitmap.get(), 0, 0, &paint); canvas->drawRect(srcRect, red); canvas->drawRect(dstRect, blue); canvas->restore(); @@ -102,14 +102,14 @@ protected: canvas->translate(SkIntToScalar(x), SkIntToScalar(y)); canvas->clipRect(dstRect); canvas->saveLayer(&dstRect, &paint); - canvas->drawImage(fBitmap, 0, 0); + canvas->drawImage(fBitmap.get(), 0, 0); canvas->restore(); canvas->drawRect(srcRect, red); canvas->drawRect(dstRect, blue); canvas->restore(); } private: - SkAutoTUnref<SkImage> fBitmap, fCheckerboard; + sk_sp<SkImage> fBitmap, fCheckerboard; typedef GM INHERITED; }; diff --git a/gm/verylargebitmap.cpp b/gm/verylargebitmap.cpp index ab6821dc1a..4ce5b7b379 100644 --- a/gm/verylargebitmap.cpp +++ b/gm/verylargebitmap.cpp @@ -22,25 +22,25 @@ static void draw(SkCanvas* canvas, int width, int height, SkColor colors[2]) { canvas->drawPaint(paint); } -static SkImage* make_raster_image(int width, int height, SkColor colors[2]) { +static sk_sp<SkImage> make_raster_image(int width, int height, SkColor colors[2]) { SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(width, height)); draw(surface->getCanvas(), width, height, colors); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } -static SkImage* make_picture_image(int width, int height, SkColor colors[2]) { +static sk_sp<SkImage> make_picture_image(int width, int height, SkColor colors[2]) { SkPictureRecorder recorder; draw(recorder.beginRecording(SkRect::MakeIWH(width, height)), width, height, colors); SkAutoTUnref<SkPicture> picture(recorder.endRecording()); - return SkImage::NewFromPicture(picture, SkISize::Make(width, height), - nullptr, nullptr); + return SkImage::MakeFromPicture(sk_ref_sp(picture.get()), SkISize::Make(width, height), + nullptr, nullptr); } -typedef SkImage* (*ImageMakerProc)(int width, int height, SkColor colors[2]); +typedef sk_sp<SkImage> (*ImageMakerProc)(int width, int height, SkColor colors[2]); static void show_image(SkCanvas* canvas, int width, int height, SkColor colors[2], ImageMakerProc proc) { - SkAutoTUnref<SkImage> image(proc(width, height, colors)); + sk_sp<SkImage> image(proc(width, height, colors)); SkPaint paint; SkRect r; diff --git a/gm/xfermodeimagefilter.cpp b/gm/xfermodeimagefilter.cpp index 85bbf44765..805e2201ea 100644 --- a/gm/xfermodeimagefilter.cpp +++ b/gm/xfermodeimagefilter.cpp @@ -37,11 +37,11 @@ protected: void onOnceBeforeDraw() override { fBitmap = sk_tool_utils::create_string_bitmap(80, 80, 0xD000D000, 15, 65, 96, "e"); - fCheckerboard.reset(SkImage::NewFromBitmap( + fCheckerboard = SkImage::MakeFromBitmap( sk_tool_utils::create_checkerboard_bitmap(80, 80, sk_tool_utils::color_to_565(0xFFA0A0A0), sk_tool_utils::color_to_565(0xFF404040), - 8))); + 8)); } void onDraw(SkCanvas* canvas) override { @@ -85,7 +85,7 @@ protected: }; int x = 0, y = 0; - SkAutoTUnref<SkImageFilter> background(SkImageSource::Create(fCheckerboard)); + SkAutoTUnref<SkImageFilter> background(SkImageSource::Create(fCheckerboard.get())); for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); i++) { SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(gModes[i].fMode)); SkAutoTUnref<SkImageFilter> filter(SkXfermodeImageFilter::Create(mode, background)); @@ -119,8 +119,8 @@ protected: SkRect clipRect = SkRect::MakeWH(SkIntToScalar(fBitmap.width() + 4), SkIntToScalar(fBitmap.height() + 4)); // Test offsets on SrcMode (uses fixed-function blend) - SkAutoTUnref<SkImage> bitmapImage(SkImage::NewFromBitmap(fBitmap)); - SkAutoTUnref<SkImageFilter> foreground(SkImageSource::Create(bitmapImage)); + sk_sp<SkImage> bitmapImage(SkImage::MakeFromBitmap(fBitmap)); + SkAutoTUnref<SkImageFilter> foreground(SkImageSource::Create(bitmapImage.get())); SkAutoTUnref<SkImageFilter> offsetForeground(SkOffsetImageFilter::Create( SkIntToScalar(4), SkIntToScalar(-4), foreground)); SkAutoTUnref<SkImageFilter> offsetBackground(SkOffsetImageFilter::Create( @@ -213,8 +213,8 @@ private: canvas->restore(); } - SkBitmap fBitmap; - SkAutoTUnref<SkImage> fCheckerboard; + SkBitmap fBitmap; + sk_sp<SkImage> fCheckerboard; typedef GM INHERITED; }; diff --git a/include/core/SkSurface.h b/include/core/SkSurface.h index b873c24d55..c420c524c1 100644 --- a/include/core/SkSurface.h +++ b/include/core/SkSurface.h @@ -232,7 +232,7 @@ public: * parameter controls whether it counts against the resource budget * (currently for the gpu backend only). */ - SkImage* newImageSnapshot(SkBudgeted = SkBudgeted::kYes); + sk_sp<SkImage> makeImageSnapshot(SkBudgeted = SkBudgeted::kYes); /** * In rare instances a client may want a unique copy of the SkSurface's contents in an image @@ -244,7 +244,16 @@ public: kNo_ForceUnique, kYes_ForceUnique }; - SkImage* newImageSnapshot(SkBudgeted, ForceUnique); + sk_sp<SkImage> makeImageSnapshot(SkBudgeted, ForceUnique); + +#ifdef SK_SUPPORT_LEGACY_IMAGEFACTORY + SkImage* newImageSnapshot(SkBudgeted budgeted = SkBudgeted::kYes) { + return this->makeImageSnapshot(budgeted).release(); + } + SkImage* newImageSnapshot(SkBudgeted budgeted, ForceUnique force) { + return this->makeImageSnapshot(budgeted, force).release(); + } +#endif /** * Though the caller could get a snapshot image explicitly, and draw that, diff --git a/samplecode/SampleAtlas.cpp b/samplecode/SampleAtlas.cpp index a7d5cbe9fd..1075f4d12e 100644 --- a/samplecode/SampleAtlas.cpp +++ b/samplecode/SampleAtlas.cpp @@ -39,7 +39,7 @@ static void draw_atlas_sim(SkCanvas* canvas, SkImage* atlas, const SkRSXform xfo } } -static SkImage* make_atlas(int atlasSize, int cellSize) { +static sk_sp<SkImage> make_atlas(int atlasSize, int cellSize) { SkImageInfo info = SkImageInfo::MakeN32Premul(atlasSize, atlasSize); SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info)); SkCanvas* canvas = surface->getCanvas(); @@ -62,7 +62,7 @@ static SkImage* make_atlas(int atlasSize, int cellSize) { i += 1; } } - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } class DrawAtlasDrawable : public SkDrawable { @@ -131,7 +131,7 @@ class DrawAtlasDrawable : public SkDrawable { N = 256, }; - SkAutoTUnref<SkImage> fAtlas; + sk_sp<SkImage> fAtlas; Rec fRec[N]; SkRect fTex[N]; SkRect fBounds; @@ -142,7 +142,7 @@ public: : fProc(proc), fBounds(r), fUseColors(false) { SkRandom rand; - fAtlas.reset(make_atlas(kAtlasSize, kCellSize)); + fAtlas = make_atlas(kAtlasSize, kCellSize); const SkScalar kMaxSpeed = 5; const SkScalar cell = SkIntToScalar(kCellSize); int i = 0; @@ -187,7 +187,7 @@ protected: const SkRect cull = this->getBounds(); const SkColor* colorsPtr = fUseColors ? colors : nullptr; - fProc(canvas, fAtlas, xform, fTex, colorsPtr, N, &cull, &paint); + fProc(canvas, fAtlas.get(), xform, fTex, colorsPtr, N, &cull, &paint); } SkRect onGetBounds() override { diff --git a/samplecode/SampleFilterFuzz.cpp b/samplecode/SampleFilterFuzz.cpp index 28155f14fd..81ea2eaed4 100644 --- a/samplecode/SampleFilterFuzz.cpp +++ b/samplecode/SampleFilterFuzz.cpp @@ -688,11 +688,11 @@ static SkImageFilter* make_image_filter(bool canBeNull) { break; case BITMAP: { - SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(make_bitmap())); + sk_sp<SkImage> image(SkImage::MakeFromBitmap(make_bitmap())); if (R(2) == 1) { - filter = SkImageSource::Create(image, make_rect(), make_rect(), kHigh_SkFilterQuality); + filter = SkImageSource::Create(image.get(), make_rect(), make_rect(), kHigh_SkFilterQuality); } else { - filter = SkImageSource::Create(image); + filter = SkImageSource::Create(image.get()); } } break; diff --git a/samplecode/SampleFilterQuality.cpp b/samplecode/SampleFilterQuality.cpp index 27c092fc47..9098901959 100644 --- a/samplecode/SampleFilterQuality.cpp +++ b/samplecode/SampleFilterQuality.cpp @@ -28,32 +28,18 @@ static SkSurface* make_surface(SkCanvas* canvas, const SkImageInfo& info) { } static sk_sp<SkShader> make_shader(const SkRect& bounds) { -#if 0 - const SkPoint pts[] = { - { bounds.left(), bounds.top() }, - { bounds.right(), bounds.bottom() }, - }; - const SkColor colors[] = { - SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorBLACK, - SK_ColorCYAN, SK_ColorMAGENTA, SK_ColorYELLOW, - }; - return SkGradientShader::CreateLinear(pts, - colors, nullptr, SK_ARRAY_COUNT(colors), - SkShader::kClamp_TileMode); -#else - SkAutoTUnref<SkImage> image(GetResourceAsImage("mandrill_128.png")); - if (nullptr == image) { + sk_sp<SkImage> image(GetResourceAsImage("mandrill_128.png")); + if (!image) { return nullptr; } return image->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode); -#endif } #define N 128 #define ANGLE_DELTA 3 #define SCALE_DELTA (SK_Scalar1 / 32) -static SkImage* make_image() { +static sk_sp<SkImage> make_image() { SkImageInfo info = SkImageInfo::MakeN32(N, N, kOpaque_SkAlphaType); SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info)); SkCanvas* canvas = surface->getCanvas(); @@ -70,10 +56,10 @@ static SkImage* make_image() { paint.setShader(make_shader(SkRect::MakeWH(N, N))); canvas->drawPath(path, paint); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } -static SkImage* zoom_up(SkSurface* origSurf, SkImage* orig) { +static sk_sp<SkImage> zoom_up(SkSurface* origSurf, SkImage* orig) { const SkScalar S = 16; // amount to scale up const int D = 2; // dimension scaling for the offscreen // since we only view the center, don't need to produce the entire thing @@ -100,7 +86,7 @@ static SkImage* zoom_up(SkSurface* origSurf, SkImage* orig) { canvas->drawLine(x, 0, x, SkIntToScalar(orig->height()), paint); } } - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } struct AnimValue { @@ -156,12 +142,12 @@ static void draw_box_frame(SkCanvas* canvas, int width, int height) { } class FilterQualityView : public SampleView { - SkAutoTUnref<SkImage> fImage; - AnimValue fScale, fAngle; - SkSize fCell; - SkInterpolator fTrans; - SkMSec fCurrTime; - bool fShowFatBits; + sk_sp<SkImage> fImage; + AnimValue fScale, fAngle; + SkSize fCell; + SkInterpolator fTrans; + SkMSec fCurrTime; + bool fShowFatBits; public: FilterQualityView() : fImage(make_image()), fTrans(2, 2), fShowFatBits(true) { @@ -216,7 +202,7 @@ protected: canvas->translate(SkScalarHalf(size.width()), SkScalarHalf(size.height())); canvas->scale(fScale, fScale); canvas->rotate(fAngle); - canvas->drawImage(fImage, -SkScalarHalf(fImage->width()), -SkScalarHalf(fImage->height()), + canvas->drawImage(fImage.get(), -SkScalarHalf(fImage->width()), -SkScalarHalf(fImage->height()), &paint); if (false) { @@ -247,9 +233,9 @@ protected: this->drawTheImage(canvas, size, filter, dx, dy); if (surface) { - SkAutoTUnref<SkImage> orig(surface->newImageSnapshot()); - SkAutoTUnref<SkImage> zoomed(zoom_up(surface, orig)); - origCanvas->drawImage(zoomed, + sk_sp<SkImage> orig(surface->makeImageSnapshot()); + sk_sp<SkImage> zoomed(zoom_up(surface, orig.get())); + origCanvas->drawImage(zoomed.get(), SkScalarHalf(fCell.width() - zoomed->width()), SkScalarHalf(fCell.height() - zoomed->height())); } diff --git a/samplecode/SampleLayers.cpp b/samplecode/SampleLayers.cpp index beb7e4ae1a..118356872a 100644 --- a/samplecode/SampleLayers.cpp +++ b/samplecode/SampleLayers.cpp @@ -244,13 +244,13 @@ DEF_SAMPLE( return new LayersView; ) class BackdropView : public SampleView { SkPoint fCenter; SkScalar fAngle; - SkAutoTUnref<SkImage> fImage; + sk_sp<SkImage> fImage; SkAutoTUnref<SkImageFilter> fFilter; public: BackdropView() { fCenter.set(200, 150); fAngle = 0; - fImage.reset(GetResourceAsImage("mandrill_512.png")); + fImage = GetResourceAsImage("mandrill_512.png"); fFilter.reset(SkDilateImageFilter::Create(8, 8)); } @@ -265,7 +265,7 @@ protected: } void onDrawContent(SkCanvas* canvas) override { - canvas->drawImage(fImage, 0, 0, nullptr); + canvas->drawImage(fImage.get(), 0, 0, nullptr); const SkScalar w = 250; const SkScalar h = 150; diff --git a/samplecode/SampleShip.cpp b/samplecode/SampleShip.cpp index fddf0235ba..daaf5e3551 100644 --- a/samplecode/SampleShip.cpp +++ b/samplecode/SampleShip.cpp @@ -48,10 +48,10 @@ static void draw_atlas_sim(SkCanvas* canvas, SkImage* atlas, const SkRSXform xfo class DrawShipView : public SampleView { public: DrawShipView(const char name[], DrawAtlasProc proc) : fName(name), fProc(proc) { - fAtlas.reset(GetResourceAsImage("ship.png")); + fAtlas = GetResourceAsImage("ship.png"); if (!fAtlas) { SkDebugf("\nCould not decode file ship.png. Falling back to penguin mode.\n"); - fAtlas.reset(GetResourceAsImage("baby_tux.png")); + fAtlas = GetResourceAsImage("baby_tux.png"); if (!fAtlas) { SkDebugf("\nCould not decode file baby_tux.png. Did you forget" " to set the resourcePath?\n"); @@ -146,7 +146,7 @@ protected: fXform[i].fTy += dy; } - fProc(canvas, fAtlas, fXform, fTex, nullptr, kGrid*kGrid+1, nullptr, &paint); + fProc(canvas, fAtlas.get(), fXform, fTex, nullptr, kGrid*kGrid+1, nullptr, &paint); paint.setColor(SK_ColorBLACK); canvas->drawRect(SkRect::MakeXYWH(0, 0, 200, 24), paint); paint.setColor(SK_ColorWHITE); @@ -168,7 +168,7 @@ private: const char* fName; DrawAtlasProc fProc; - SkAutoTUnref<SkImage> fAtlas; + sk_sp<SkImage> fAtlas; SkRSXform fXform[kGrid*kGrid+1]; SkRect fTex[kGrid*kGrid+1]; WallTimer fTimer; diff --git a/samplecode/SampleTextureDomain.cpp b/samplecode/SampleTextureDomain.cpp index 65575338c9..2c6dd64301 100644 --- a/samplecode/SampleTextureDomain.cpp +++ b/samplecode/SampleTextureDomain.cpp @@ -67,7 +67,7 @@ protected: surface->getCanvas()->drawBitmapRect(fBM, srcRect, dstRect, &paint, SkCanvas::kStrict_SrcRectConstraint); - SkAutoTUnref<SkImage> image(surface->newImageSnapshot()); + sk_sp<SkImage> image(surface->makeImageSnapshot()); srcRect.setXYWH(1, 1, 3, 3); dstRect.setXYWH(405, 5, 305, 305); diff --git a/src/c/sk_surface.cpp b/src/c/sk_surface.cpp index 8dd7a6c503..79036f75fe 100644 --- a/src/c/sk_surface.cpp +++ b/src/c/sk_surface.cpp @@ -463,7 +463,7 @@ sk_canvas_t* sk_surface_get_canvas(sk_surface_t* csurf) { sk_image_t* sk_surface_new_image_snapshot(sk_surface_t* csurf) { SkSurface* surf = (SkSurface*)csurf; - return (sk_image_t*)surf->newImageSnapshot(); + return (sk_image_t*)surf->makeImageSnapshot().release(); } /////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/core/SkPictureImageGenerator.cpp b/src/core/SkPictureImageGenerator.cpp index 67834876ca..f90ac0f1ee 100644 --- a/src/core/SkPictureImageGenerator.cpp +++ b/src/core/SkPictureImageGenerator.cpp @@ -151,8 +151,8 @@ GrTexture* SkPictureImageGenerator::onGenerateTexture(GrContext* ctx, const SkIR } surface->getCanvas()->clear(0); // does NewRenderTarget promise to do this for us? surface->getCanvas()->drawPicture(fPicture, &matrix, fPaint.getMaybeNull()); - SkAutoTUnref<SkImage> image(surface->newImageSnapshot()); - if (!image.get()) { + sk_sp<SkImage> image(surface->makeImageSnapshot()); + if (!image) { return nullptr; } return SkSafeRef(as_IB(image)->peekTexture()); diff --git a/src/image/SkImage_Base.h b/src/image/SkImage_Base.h index ade891f4cb..8dc2cb6eae 100644 --- a/src/image/SkImage_Base.h +++ b/src/image/SkImage_Base.h @@ -78,6 +78,10 @@ static inline SkImage_Base* as_IB(SkImage* image) { return static_cast<SkImage_Base*>(image); } +static inline SkImage_Base* as_IB(const sk_sp<SkImage>& image) { + return static_cast<SkImage_Base*>(image.get()); +} + static inline const SkImage_Base* as_IB(const SkImage* image) { return static_cast<const SkImage_Base*>(image); } diff --git a/src/image/SkImage_Generator.cpp b/src/image/SkImage_Generator.cpp index 62b492e288..f8af12a612 100644 --- a/src/image/SkImage_Generator.cpp +++ b/src/image/SkImage_Generator.cpp @@ -86,7 +86,7 @@ sk_sp<SkImage> SkImage_Generator::onMakeSubset(const SkIRect& subset) const { surface->getCanvas()->clear(0); surface->getCanvas()->drawImage(this, SkIntToScalar(-subset.x()), SkIntToScalar(-subset.y()), nullptr); - return sk_sp<SkImage>(surface->newImageSnapshot()); + return surface->makeImageSnapshot(); } sk_sp<SkImage> SkImage::MakeFromGenerator(SkImageGenerator* generator, const SkIRect* subset) { diff --git a/src/image/SkImage_Raster.cpp b/src/image/SkImage_Raster.cpp index 7f2f5c07ef..764d5eb290 100644 --- a/src/image/SkImage_Raster.cpp +++ b/src/image/SkImage_Raster.cpp @@ -183,7 +183,7 @@ sk_sp<SkImage> SkImage_Raster::onMakeSubset(const SkIRect& subset) const { surface->getCanvas()->clear(0); surface->getCanvas()->drawImage(this, SkIntToScalar(-subset.x()), SkIntToScalar(-subset.y()), nullptr); - return sk_sp<SkImage>(surface->newImageSnapshot()); + return surface->makeImageSnapshot(); } /////////////////////////////////////////////////////////////////////////////// diff --git a/src/image/SkSurface.cpp b/src/image/SkSurface.cpp index 9bec562df9..bb807ba7a5 100644 --- a/src/image/SkSurface.cpp +++ b/src/image/SkSurface.cpp @@ -79,10 +79,9 @@ SkSurface_Base::~SkSurface_Base() { } void SkSurface_Base::onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) { - SkImage* image = this->newImageSnapshot(SkBudgeted::kYes); + auto image = this->makeImageSnapshot(SkBudgeted::kYes); if (image) { canvas->drawImage(image, x, y, paint); - image->unref(); } } @@ -163,12 +162,12 @@ SkCanvas* SkSurface::getCanvas() { return asSB(this)->getCachedCanvas(); } -SkImage* SkSurface::newImageSnapshot(SkBudgeted budgeted) { +sk_sp<SkImage> SkSurface::makeImageSnapshot(SkBudgeted budgeted) { // the caller will call unref() to balance this return asSB(this)->refCachedImage(budgeted, kNo_ForceUnique); } -SkImage* SkSurface::newImageSnapshot(SkBudgeted budgeted, ForceUnique unique) { +sk_sp<SkImage> SkSurface::makeImageSnapshot(SkBudgeted budgeted, ForceUnique unique) { // the caller will call unref() to balance this return asSB(this)->refCachedImage(budgeted, unique); } diff --git a/src/image/SkSurface_Base.h b/src/image/SkSurface_Base.h index 0519a9b3c0..96dd305960 100644 --- a/src/image/SkSurface_Base.h +++ b/src/image/SkSurface_Base.h @@ -81,7 +81,7 @@ public: virtual void onPrepareForExternalIO() {} inline SkCanvas* getCachedCanvas(); - inline SkImage* refCachedImage(SkBudgeted, ForceUnique); + inline sk_sp<SkImage> refCachedImage(SkBudgeted, ForceUnique); bool hasCachedImage() const { return fCachedImage != nullptr; } @@ -114,13 +114,13 @@ SkCanvas* SkSurface_Base::getCachedCanvas() { return fCachedCanvas; } -SkImage* SkSurface_Base::refCachedImage(SkBudgeted budgeted, ForceUnique unique) { +sk_sp<SkImage> SkSurface_Base::refCachedImage(SkBudgeted budgeted, ForceUnique unique) { SkImage* snap = fCachedImage; if (kYes_ForceUnique == unique && snap && !snap->unique()) { snap = nullptr; } if (snap) { - return SkRef(snap); + return sk_ref_sp(snap); } ForceCopyMode fcm = (kYes_ForceUnique == unique) ? kYes_ForceCopyMode : kNo_ForceCopyMode; @@ -130,7 +130,7 @@ SkImage* SkSurface_Base::refCachedImage(SkBudgeted budgeted, ForceUnique unique) fCachedImage = SkSafeRef(snap); } SkASSERT(!fCachedCanvas || fCachedCanvas->getSurfaceBase() == this); - return snap; + return sk_sp<SkImage>(snap); } #endif diff --git a/src/image/SkSurface_Gpu.cpp b/src/image/SkSurface_Gpu.cpp index 35c521ca86..649db129c3 100644 --- a/src/image/SkSurface_Gpu.cpp +++ b/src/image/SkSurface_Gpu.cpp @@ -114,11 +114,11 @@ void SkSurface_Gpu::onCopyOnWrite(ContentChangeMode mode) { GrRenderTarget* rt = fDevice->accessRenderTarget(); // are we sharing our render target with the image? Note this call should never create a new // image because onCopyOnWrite is only called when there is a cached image. - SkAutoTUnref<SkImage> image(this->refCachedImage(SkBudgeted::kNo, kNo_ForceUnique)); + sk_sp<SkImage> image(this->refCachedImage(SkBudgeted::kNo, kNo_ForceUnique)); SkASSERT(image); if (rt->asTexture() == as_IB(image)->peekTexture()) { this->fDevice->replaceRenderTarget(SkSurface::kRetain_ContentChangeMode == mode); - SkTextureImageApplyBudgetedDecision(image); + SkTextureImageApplyBudgetedDecision(image.get()); } else if (kDiscard_ContentChangeMode == mode) { this->SkSurface_Gpu::onDiscard(); } diff --git a/src/image/SkSurface_Raster.cpp b/src/image/SkSurface_Raster.cpp index 192415341f..b5844d1f5b 100644 --- a/src/image/SkSurface_Raster.cpp +++ b/src/image/SkSurface_Raster.cpp @@ -143,9 +143,9 @@ void SkSurface_Raster::onRestoreBackingMutability() { void SkSurface_Raster::onCopyOnWrite(ContentChangeMode mode) { // are we sharing pixelrefs with the image? - SkAutoTUnref<SkImage> cached(this->refCachedImage(SkBudgeted::kNo, kNo_ForceUnique)); + sk_sp<SkImage> cached(this->refCachedImage(SkBudgeted::kNo, kNo_ForceUnique)); SkASSERT(cached); - if (SkBitmapImageGetPixelRef(cached) == fBitmap.pixelRef()) { + if (SkBitmapImageGetPixelRef(cached.get()) == fBitmap.pixelRef()) { SkASSERT(fWeOwnThePixels); if (kDiscard_ContentChangeMode == mode) { fBitmap.allocPixels(); diff --git a/src/pdf/SkPDFCanon.cpp b/src/pdf/SkPDFCanon.cpp index d7aea8ad69..48f3aef69e 100644 --- a/src/pdf/SkPDFCanon.cpp +++ b/src/pdf/SkPDFCanon.cpp @@ -142,12 +142,12 @@ const SkImage* SkPDFCanon::bitmapToImage(const SkBitmap& bm) { if (const SkImage** img = fBitmapToImageMap.find(key)) { return *img; } - if (SkImage* image = SkImage::NewFromBitmap(bm)) { + if (SkImage* image = SkImage::MakeFromBitmap(bm).release()) { return *fBitmapToImageMap.set(key, image); } SkBitmap n32bitmap; // SkImage::NewFromBitmap can be finicky. bm.copyTo(&n32bitmap, kN32_SkColorType); - return *fBitmapToImageMap.set(key, SkImage::NewFromBitmap(n32bitmap)); + return *fBitmapToImageMap.set(key, SkImage::MakeFromBitmap(n32bitmap).release()); } sk_sp<SkPDFStream> SkPDFCanon::makeInvertFunction() { diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp index 94a103aeb1..3febc1acb6 100644 --- a/src/pdf/SkPDFDevice.cpp +++ b/src/pdf/SkPDFDevice.cpp @@ -1160,7 +1160,7 @@ void SkPDFDevice::drawImageRect(const SkDraw& draw, SkIRect srcIR; tmpSrc.roundOut(&srcIR); - autoImageUnref.reset(image->newSubset(srcIR)); + autoImageUnref = image->makeSubset(srcIR); if (!autoImageUnref) { return; } @@ -2187,7 +2187,7 @@ static const SkImage* color_filter(const SkImage* image, paint.setColorFilter(colorFilter); canvas->drawImage(image, 0, 0, &paint); canvas->flush(); - return surface->newImageSnapshot(); + return surface->makeImageSnapshot().release(); } //////////////////////////////////////////////////////////////////////////////// @@ -2207,7 +2207,7 @@ void SkPDFDevice::internalDrawImage(const SkMatrix& origMatrix, sk_sp<const SkImage> autoImageUnref; if (srcRect) { - autoImageUnref.reset(image->newSubset(*srcRect)); + autoImageUnref = image->makeSubset(*srcRect); if (!autoImageUnref) { return; } @@ -2286,7 +2286,7 @@ void SkPDFDevice::internalDrawImage(const SkMatrix& origMatrix, clipRegion = &perspectiveBounds; srcRect = nullptr; - autoImageUnref.reset(surface->newImageSnapshot()); + autoImageUnref.reset(surface->makeImageSnapshot().release()); image = autoImageUnref.get(); } diff --git a/src/utils/SkLua.cpp b/src/utils/SkLua.cpp index 95ca5adc07..868a8250ef 100644 --- a/src/utils/SkLua.cpp +++ b/src/utils/SkLua.cpp @@ -1756,11 +1756,11 @@ static int lsurface_getCanvas(lua_State* L) { } static int lsurface_newImageSnapshot(lua_State* L) { - SkImage* image = get_ref<SkSurface>(L, 1)->newImageSnapshot(); - if (nullptr == image) { + sk_sp<SkImage> image = get_ref<SkSurface>(L, 1)->makeImageSnapshot(); + if (!image) { lua_pushnil(L); } else { - push_ref(L, image)->unref(); + push_ref(L, image); } return 1; } @@ -2075,11 +2075,11 @@ static int lsk_newRasterSurface(lua_State* L) { static int lsk_loadImage(lua_State* L) { if (lua_gettop(L) > 0 && lua_isstring(L, 1)) { const char* name = lua_tolstring(L, 1, nullptr); - SkAutoDataUnref data(SkData::NewFromFileName(name)); - if (data.get()) { - SkImage* image = SkImage::NewFromEncoded(data); + sk_sp<SkData> data(SkData::MakeFromFileName(name)); + if (data) { + auto image = SkImage::MakeFromEncoded(std::move(data)); if (image) { - push_ref(L, image)->unref(); + push_ref(L, std::move(image)); return 1; } } diff --git a/tests/CachedDecodingPixelRefTest.cpp b/tests/CachedDecodingPixelRefTest.cpp index fe6b412cd1..da4a111b28 100644 --- a/tests/CachedDecodingPixelRefTest.cpp +++ b/tests/CachedDecodingPixelRefTest.cpp @@ -320,8 +320,8 @@ DEF_TEST(Image_NewFromGenerator, r) { 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 c8f4a62e82..28d491b26f 100644 --- a/tests/FlattenableFactoryToName.cpp +++ b/tests/FlattenableFactoryToName.cpp @@ -35,7 +35,7 @@ DEF_TEST(FlattenableFactoryToName, r) { 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 f355714c52..c7b2170c0f 100644 --- a/tests/ImageFilterCacheTest.cpp +++ b/tests/ImageFilterCacheTest.cpp @@ -169,9 +169,9 @@ static void test_image_backed(skiatest::Reporter* reporter, SkImage* srcImage) { 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 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, co 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 a0bc5f010e..d4e92762fa 100644 --- a/tests/ImageFilterTest.cpp +++ b/tests/ImageFilterTest.cpp @@ -96,7 +96,7 @@ void MatrixTestImageFilter::toString(SkString* str) const { } #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 @@ static SkImage* make_small_image() { } } - return surface->newImageSnapshot(); + return surface->makeImageSnapshot(); } static SkImageFilter* make_scale(float amount, SkImageFilter* input = nullptr) { @@ -280,7 +280,7 @@ DEF_TEST(ImageFilter, reporter) { { // 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 @@ DEF_TEST(ImageFilter, reporter) { // 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 @@ DEF_TEST(ImageFilterDrawTiled, reporter) { 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 @@ static void test_imagefilter_merge_result_size(SkImageFilter::Proxy* proxy, 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(ImageFilterCanComputeFastBounds, reporter) { 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 @@ static void test_large_blur_input(skiatest::Reporter* reporter, SkCanvas* canvas 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 d910a47560..fada9f0b62 100644 --- a/tests/ImageFrom565Bitmap.cpp +++ b/tests/ImageFrom565Bitmap.cpp @@ -16,6 +16,5 @@ DEF_TEST(ImageFrom565Bitmap, r) { 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 739af2bd49..6f13708335 100644 --- a/tests/ImageIsOpaqueTest.cpp +++ b/tests/ImageIsOpaqueTest.cpp @@ -49,7 +49,7 @@ DEF_TEST(ImageInfo_flattening, reporter) { } 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 0822dbd054..b6266ed60d 100644 --- a/tests/ImageNewShaderTest.cpp +++ b/tests/ImageNewShaderTest.cpp @@ -44,7 +44,7 @@ void paintSource(SkSurface* sourceSurface) { 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 da9268dded..4781aea625 100644 --- a/tests/ImageTest.cpp +++ b/tests/ImageTest.cpp @@ -60,19 +60,19 @@ static void draw_image_test_pattern(SkCanvas* canvas) { 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 @@ static SkImage* create_image_ct() { 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 @@ static SkData* create_image_data(SkImageInfo* info) { } 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 @@ struct RasterDataHolder { 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 @@ private: // 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_Encode_Serializer, reporter) { 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 @@ DEF_TEST(Image_NewRasterCopy, reporter) { 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 @@ DEF_TEST(Image_RetainSnapshot, reporter) { 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 @@ DEF_TEST(Image_RetainSnapshot, reporter) { 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 @@ DEF_TEST(image_newfrombitmap, reporter) { 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_TEST(image_newfrombitmap, reporter) { */ 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 @@ DEF_GPUTEST_FOR_NATIVE_CONTEXT(SkImage_newTextureImage, reporter, context, glCon 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 @@ DEF_GPUTEST_FOR_NATIVE_CONTEXT(SkImage_newTextureImage, reporter, context, glCon // 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 @@ DEF_TEST(ImageFromIndex8Bitmap, r) { 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 @@ public: 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 @@ static void test_read_pixels(skiatest::Reporter* reporter, SkImage* image) { 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 @@ static void test_legacy_bitmap(skiatest::Reporter* reporter, const SkImage* imag 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 @@ DEF_TEST(ImageLegacyBitmap, reporter) { 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 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageLegacyBitmap_Gpu, reporter, context) { 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 @@ static void test_peek(skiatest::Reporter* reporter, SkImage* image, bool expectP } } 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 @@ DEF_GPUTEST_FOR_NATIVE_CONTEXT(SkImage_NewFromTexture, reporter, context) { 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 @@ DEF_GPUTEST_FOR_NATIVE_CONTEXT(SkImage_NewFromTexture, reporter, context) { // 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 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(NewTextureFromPixmap, reporter, context) { 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 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(NewTextureFromPixmap, reporter, context) { 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 @@ DEF_GPUTEST_FOR_NATIVE_CONTEXT(DeferredTextureImage, reporter, context, glContex 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 @@ DEF_GPUTEST_FOR_NATIVE_CONTEXT(DeferredTextureImage, reporter, context, glContex // 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 @@ DEF_GPUTEST_FOR_NATIVE_CONTEXT(DeferredTextureImage, reporter, context, glContex 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 @@ DEF_GPUTEST_FOR_NATIVE_CONTEXT(DeferredTextureImage, reporter, context, glContex 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 9d83fe6757..2dcbdd05d8 100644 --- a/tests/PDFJpegEmbedTest.cpp +++ b/tests/PDFJpegEmbedTest.cpp @@ -56,9 +56,8 @@ static SkData* load_resource( */ 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 @@ DEF_TEST(PDFJpegEmbedTest, r) { 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 @@ DEF_TEST(PDFJpegEmbedTest, r) { 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 @@ DEF_TEST(PDFJpegEmbedTest, r) { 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 @@ DEF_TEST(PDFJpegEmbedTest, r) { 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 3d2f19d54c..ba787a0c1b 100644 --- a/tests/PictureTest.cpp +++ b/tests/PictureTest.cpp @@ -50,7 +50,7 @@ static void test_images_are_found_by_willPlayBackBitmaps(skiatest::Reporter* rep // 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 b87d2b8ad7..77a11e5f8b 100644 --- a/tests/ReadPixelsTest.cpp +++ b/tests/ReadPixelsTest.cpp @@ -556,8 +556,7 @@ static SkData* draw_into_surface(SkSurface* surf, const SkBitmap& bm, SkFilterQu 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 8dfdc976f5..8d91fbc8d2 100644 --- a/tests/RecordDrawTest.cpp +++ b/tests/RecordDrawTest.cpp @@ -281,7 +281,7 @@ DEF_TEST(RecordDraw_drawImage, r){ 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 9d7fda5483..b1af1388fb 100644 --- a/tests/RecorderTest.cpp +++ b/tests/RecorderTest.cpp @@ -72,18 +72,18 @@ DEF_TEST(Recorder_RefLeaking, r) { 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 @@ DEF_TEST(Recorder_drawImage_takeReference, reporter) { 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 d6a88cf465..eca9e64dbe 100644 --- a/tests/SerializationTest.cpp +++ b/tests/SerializationTest.cpp @@ -242,10 +242,10 @@ static void TestBitmapSerialization(const SkBitmap& validBitmap, 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 0b5a4e05f7..94e1b68816 100644 --- a/tests/SkColor4fTest.cpp +++ b/tests/SkColor4fTest.cpp @@ -108,7 +108,7 @@ static sk_sp<SkShader> make_image_sh() { 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 8817f0b597..4a05b44be1 100644 --- a/tests/SkImageTest.cpp +++ b/tests/SkImageTest.cpp @@ -14,7 +14,7 @@ static const int gHeight = 20; // 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 @@ DEF_TEST(SkImageFromBitmap_extractSubset, reporter) { 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 f9a0e6d505..625b98a903 100644 --- a/tests/SkResourceCacheTest.cpp +++ b/tests/SkResourceCacheTest.cpp @@ -263,7 +263,7 @@ DEF_TEST(BitmapCache_discarded_bitmap, reporter) { } 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 @@ static void test_discarded_image(skiatest::Reporter* reporter, const SkMatrix& t 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 @@ DEF_TEST(BitmapCache_discarded_image, reporter) { 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 7511e62971..03a496dbba 100644 --- a/tests/SpecialImageTest.cpp +++ b/tests/SpecialImageTest.cpp @@ -119,19 +119,19 @@ DEF_TEST(SpecialImage_Raster, reporter) { 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 d6c7acd916..89c7765c56 100644 --- a/tests/SurfaceTest.cpp +++ b/tests/SurfaceTest.cpp @@ -231,7 +231,7 @@ static void test_snapshot_alphatype(skiatest::Reporter* reporter, SkSurface* sur 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 @@ static void test_backend_handle_access_copy_on_write( 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 @@ static void test_unique_image_snap(skiatest::Reporter* reporter, SkSurface* surf 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 @@ static uint32_t get_legacy_gen_id(SkSurface* surface) { * 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_gen_id( 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 @@ static void test_copy_on_write(skiatest::Reporter* reporter, SkSurface* surface) #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 @@ static void test_writable_after_snapshot_release(skiatest::Reporter* reporter, // 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 @@ static void test_crbug263329(skiatest::Reporter* reporter, 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_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCRBug263329_Gpu, reporter, context) { 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_TEST(SurfaceGetTexture, reporter) { 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 @@ static SkBudgeted is_budgeted(SkImage* image) { 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 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceBudget, reporter, context) { 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 @@ static void test_no_canvas2(skiatest::Reporter* reporter, 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 @@ static void check_rowbytes_remain_consistent(SkSurface* surface, skiatest::Repor 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 @@ static void check_rowbytes_remain_consistent(SkSurface* surface, skiatest::Repor // 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 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceClear_Gpu, reporter, context) { 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 73d9dc0ed9..5c9962e2c6 100644 --- a/tests/TextureStorageAllocator.cpp +++ b/tests/TextureStorageAllocator.cpp @@ -72,7 +72,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(CustomTexture, reporter, context, glContext) 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 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(CustomTexture, reporter, context, glContext) 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); diff --git a/tools/Resources.cpp b/tools/Resources.cpp index ecbf88c17a..0117404ac2 100644 --- a/tools/Resources.cpp +++ b/tools/Resources.cpp @@ -32,10 +32,10 @@ bool GetResourceAsBitmap(const char* resource, SkBitmap* dst) { return gen && gen->tryGenerateBitmap(dst); } -SkImage* GetResourceAsImage(const char* resource) { +sk_sp<SkImage> GetResourceAsImage(const char* resource) { SkString path = GetResourcePath(resource); - SkAutoTUnref<SkData> resourceData(SkData::NewFromFileName(path.c_str())); - return SkImage::NewFromEncoded(resourceData); + sk_sp<SkData> resourceData(SkData::NewFromFileName(path.c_str())); + return SkImage::MakeFromEncoded(resourceData); } SkStreamAsset* GetResourceAsStream(const char* resource) { diff --git a/tools/Resources.h b/tools/Resources.h index 5e76eb3ae8..678e4c8627 100644 --- a/tools/Resources.h +++ b/tools/Resources.h @@ -8,6 +8,7 @@ #ifndef Resources_DEFINED #define Resources_DEFINED +#include "SkRefCnt.h" #include "SkString.h" class SkBitmap; @@ -19,7 +20,7 @@ SkString GetResourcePath(const char* resource = ""); void SetResourcePath(const char* ); bool GetResourceAsBitmap(const char* resource, SkBitmap* dst); -SkImage* GetResourceAsImage(const char* resource); +sk_sp<SkImage> GetResourceAsImage(const char* resource); SkStreamAsset* GetResourceAsStream(const char* resource); SkTypeface* GetResourceAsTypeface(const char* resource); diff --git a/tools/VisualBench/WrappedBenchmark.h b/tools/VisualBench/WrappedBenchmark.h index c947a3ed37..35d64ee182 100644 --- a/tools/VisualBench/WrappedBenchmark.h +++ b/tools/VisualBench/WrappedBenchmark.h @@ -84,10 +84,10 @@ private: } void onBlitToScreen(SkCanvas* canvas, int w, int h) override { - SkAutoTUnref<SkImage> image(fOffScreen->newImageSnapshot()); + sk_sp<SkImage> image(fOffScreen->makeImageSnapshot()); SkPaint blitPaint; blitPaint.setXfermodeMode(SkXfermode::kSrc_Mode); - canvas->drawImageRect(image, SkIRect::MakeWH(w, h), + canvas->drawImageRect(image.get(), SkIRect::MakeWH(w, h), SkRect::MakeWH(SkIntToScalar(w), SkIntToScalar(h)), &blitPaint); } diff --git a/tools/debugger/SkDrawCommand.cpp b/tools/debugger/SkDrawCommand.cpp index 2f5a875ac3..847254a30f 100644 --- a/tools/debugger/SkDrawCommand.cpp +++ b/tools/debugger/SkDrawCommand.cpp @@ -620,13 +620,12 @@ static bool SK_WARN_UNUSED_RESULT flatten(const SkImage& image, Json::Value* tar SkDebugf("readPixels failed\n"); return false; } - SkImage* converted = SkImage::NewRasterCopy(dstInfo, buffer, rowBytes); + sk_sp<SkImage> converted = SkImage::MakeRasterCopy(SkPixmap(dstInfo, buffer, rowBytes)); encoded = converted->encode(SkImageEncoder::kPNG_Type, 100); if (encoded == nullptr) { SkDebugf("image encode failed\n"); return false; } - sk_free(converted); sk_free(buffer); } Json::Value jsonData; @@ -755,8 +754,8 @@ static SkBitmap* load_bitmap(const Json::Value& jsonBitmap, UrlDataManager& urlD } const void* data; int size = decode_data(jsonBitmap[SKDEBUGCANVAS_ATTRIBUTE_DATA], urlDataManager, &data); - SkAutoTUnref<SkData> encoded(SkData::NewWithoutCopy(data, size)); - SkAutoTDelete<SkImage> image(SkImage::NewFromEncoded(encoded, nullptr)); + sk_sp<SkData> encoded(SkData::NewWithoutCopy(data, size)); + sk_sp<SkImage> image(SkImage::MakeFromEncoded(std::move(encoded), nullptr)); SkAutoTDelete<SkBitmap> bitmap(new SkBitmap()); if (nullptr != image) { @@ -778,12 +777,12 @@ static SkBitmap* load_bitmap(const Json::Value& jsonBitmap, UrlDataManager& urlD return nullptr; } -static SkImage* load_image(const Json::Value& jsonImage, UrlDataManager& urlDataManager) { +static sk_sp<SkImage> load_image(const Json::Value& jsonImage, UrlDataManager& urlDataManager) { SkBitmap* bitmap = load_bitmap(jsonImage, urlDataManager); if (bitmap == nullptr) { return nullptr; } - SkImage* result = SkImage::NewFromBitmap(*bitmap); + auto result = SkImage::MakeFromBitmap(*bitmap); delete bitmap; return result; } @@ -791,7 +790,7 @@ static SkImage* load_image(const Json::Value& jsonImage, UrlDataManager& urlData static bool SK_WARN_UNUSED_RESULT flatten(const SkBitmap& bitmap, Json::Value* target, UrlDataManager& urlDataManager) { bitmap.lockPixels(); - SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(bitmap)); + sk_sp<SkImage> image(SkImage::MakeFromBitmap(bitmap)); bitmap.unlockPixels(); (*target)[SKDEBUGCANVAS_ATTRIBUTE_COLOR] = Json::Value(color_type_name(bitmap.colorType())); (*target)[SKDEBUGCANVAS_ATTRIBUTE_ALPHA] = Json::Value(alpha_type_name(bitmap.alphaType())); @@ -1965,7 +1964,7 @@ Json::Value SkDrawImageCommand::toJSON(UrlDataManager& urlDataManager) const { SkDrawImageCommand* SkDrawImageCommand::fromJSON(Json::Value& command, UrlDataManager& urlDataManager) { - SkImage* image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE], urlDataManager); + sk_sp<SkImage> image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE], urlDataManager); if (image == nullptr) { return nullptr; } @@ -1979,9 +1978,8 @@ SkDrawImageCommand* SkDrawImageCommand::fromJSON(Json::Value& command, else { paintPtr = nullptr; } - SkDrawImageCommand* result = new SkDrawImageCommand(image, point[0].asFloat(), + SkDrawImageCommand* result = new SkDrawImageCommand(image.get(), point[0].asFloat(), point[1].asFloat(), paintPtr); - image->unref(); return result; } @@ -2048,7 +2046,7 @@ Json::Value SkDrawImageRectCommand::toJSON(UrlDataManager& urlDataManager) const SkDrawImageRectCommand* SkDrawImageRectCommand::fromJSON(Json::Value& command, UrlDataManager& urlDataManager) { - SkImage* image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE], urlDataManager); + sk_sp<SkImage> image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE], urlDataManager); if (image == nullptr) { return nullptr; } @@ -2080,9 +2078,8 @@ SkDrawImageRectCommand* SkDrawImageRectCommand::fromJSON(Json::Value& command, else { srcPtr = nullptr; } - SkDrawImageRectCommand* result = new SkDrawImageRectCommand(image, srcPtr, dst, paintPtr, + SkDrawImageRectCommand* result = new SkDrawImageRectCommand(image.get(), srcPtr, dst, paintPtr, constraint); - image->unref(); return result; } diff --git a/tools/imgblur.cpp b/tools/imgblur.cpp index 4f106dc712..c47bb02b75 100644 --- a/tools/imgblur.cpp +++ b/tools/imgblur.cpp @@ -40,7 +40,7 @@ int tool_main(int argc, char** argv) { return kError; } - SkAutoTUnref<SkData> data(SkData::NewFromFileName(FLAGS_in[0])); + sk_sp<SkData> data(SkData::MakeFromFileName(FLAGS_in[0])); if (nullptr == data) { if (!FLAGS_quiet) { SkDebugf("Couldn't open file: %s\n", FLAGS_in[0]); @@ -48,7 +48,7 @@ int tool_main(int argc, char** argv) { return kError; } - SkAutoTDelete<SkImage> image(SkImage::NewFromEncoded(data)); + sk_sp<SkImage> image(SkImage::MakeFromEncoded(data)); if (!image) { if (!FLAGS_quiet) { SkDebugf("Couldn't create image for: %s.\n", FLAGS_in[0]); diff --git a/tools/imgslice.cpp b/tools/imgslice.cpp index 8128f77dd4..3585c06352 100644 --- a/tools/imgslice.cpp +++ b/tools/imgslice.cpp @@ -59,7 +59,7 @@ int tool_main(int argc, char** argv) { return kError; } - SkAutoTUnref<SkData> data(SkData::NewFromFileName(FLAGS_image[0])); + sk_sp<SkData> data(SkData::MakeFromFileName(FLAGS_image[0])); if (nullptr == data) { if (!FLAGS_quiet) { SkDebugf("Couldn't open file: %s\n", FLAGS_image[0]); @@ -67,7 +67,7 @@ int tool_main(int argc, char** argv) { return kError; } - SkAutoTDelete<SkImage> image(SkImage::NewFromEncoded(data)); + sk_sp<SkImage> image(SkImage::MakeFromEncoded(data)); if (!image) { if (!FLAGS_quiet) { SkDebugf("Couldn't create image for: %s.\n", FLAGS_image[0]); diff --git a/tools/skhello.cpp b/tools/skhello.cpp index 5614a56f5d..61502a6fb8 100644 --- a/tools/skhello.cpp +++ b/tools/skhello.cpp @@ -37,7 +37,7 @@ static bool do_surface(int w, int h, const char path[], const char text[], SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(w, h, &props)); doDraw(surface->getCanvas(), paint, text); - SkAutoTUnref<SkImage> image(surface->newImageSnapshot()); + sk_sp<SkImage> image(surface->makeImageSnapshot()); SkAutoDataUnref data(image->encode()); if (nullptr == data.get()) { return false; |