Update SkBlurImageFilter to sk_sp
TBR=reed@google.com
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1852743002
Review URL: https://codereview.chromium.org/1852743002
diff --git a/bench/BlurImageFilterBench.cpp b/bench/BlurImageFilterBench.cpp
index cf93774..9560263 100644
--- a/bench/BlurImageFilterBench.cpp
+++ b/bench/BlurImageFilterBench.cpp
@@ -34,6 +34,30 @@
// of the source (not inset). This is intended to exercise blurring a smaller source bitmap to a
// larger destination.
+static SkBitmap make_checkerboard(int width, int height) {
+ SkBitmap bm;
+ bm.allocN32Pixels(width, height);
+ SkCanvas canvas(bm);
+ canvas.clear(0x00000000);
+ SkPaint darkPaint;
+ darkPaint.setColor(0xFF804020);
+ SkPaint lightPaint;
+ lightPaint.setColor(0xFF244484);
+ for (int y = 0; y < height; y += 16) {
+ for (int x = 0; x < width; x += 16) {
+ canvas.save();
+ canvas.translate(SkIntToScalar(x), SkIntToScalar(y));
+ canvas.drawRect(SkRect::MakeXYWH(0, 0, 8, 8), darkPaint);
+ canvas.drawRect(SkRect::MakeXYWH(8, 0, 8, 8), lightPaint);
+ canvas.drawRect(SkRect::MakeXYWH(0, 8, 8, 8), lightPaint);
+ canvas.drawRect(SkRect::MakeXYWH(8, 8, 8, 8), darkPaint);
+ canvas.restore();
+ }
+ }
+
+ return bm;
+}
+
class BlurImageFilterBench : public Benchmark {
public:
BlurImageFilterBench(SkScalar sigmaX, SkScalar sigmaY, bool small, bool cropped,
@@ -59,13 +83,13 @@
void onDelayedSetup() override {
if (!fInitialized) {
- make_checkerboard();
+ fCheckerboard = make_checkerboard(fIsSmall ? FILTER_WIDTH_SMALL : FILTER_WIDTH_LARGE,
+ fIsSmall ? FILTER_HEIGHT_SMALL : FILTER_HEIGHT_LARGE);
fInitialized = true;
}
}
void onDraw(int loops, SkCanvas* canvas) override {
- SkPaint paint;
static const SkScalar kX = 0;
static const SkScalar kY = 0;
const SkRect bmpRect = SkRect::MakeXYWH(kX, kY,
@@ -73,14 +97,15 @@
SkIntToScalar(fCheckerboard.height()));
const SkImageFilter::CropRect cropRect(bmpRect.makeInset(10.f, 10.f));
const SkImageFilter::CropRect cropRectLarge(bmpRect);
- sk_sp<SkImageFilter> noOpCropped(SkOffsetImageFilter::Make(0, 0, nullptr, &cropRect));
- SkImageFilter* input = fIsExpanded ? noOpCropped.get() : nullptr;
+ sk_sp<SkImageFilter> input = fIsExpanded
+ ? SkOffsetImageFilter::Make(0, 0, nullptr, &cropRect)
+ : nullptr;
const SkImageFilter::CropRect* crop =
fIsExpanded ? &cropRectLarge : fIsCropped ? &cropRect : nullptr;
- SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(fSigmaX, fSigmaY, input, crop));
- paint.setImageFilter(blur);
+ SkPaint paint;
+ paint.setImageFilter(SkBlurImageFilter::Make(fSigmaX, fSigmaY, std::move(input), crop));
for (int i = 0; i < loops; i++) {
canvas->drawBitmap(fCheckerboard, kX, kY, &paint);
@@ -88,28 +113,6 @@
}
private:
- void make_checkerboard() {
- const int w = fIsSmall ? FILTER_WIDTH_SMALL : FILTER_WIDTH_LARGE;
- const int h = fIsSmall ? FILTER_HEIGHT_LARGE : FILTER_HEIGHT_LARGE;
- fCheckerboard.allocN32Pixels(w, h);
- SkCanvas canvas(fCheckerboard);
- canvas.clear(0x00000000);
- SkPaint darkPaint;
- darkPaint.setColor(0xFF804020);
- SkPaint lightPaint;
- lightPaint.setColor(0xFF244484);
- for (int y = 0; y < h; y += 16) {
- for (int x = 0; x < w; x += 16) {
- canvas.save();
- canvas.translate(SkIntToScalar(x), SkIntToScalar(y));
- canvas.drawRect(SkRect::MakeXYWH(0, 0, 8, 8), darkPaint);
- canvas.drawRect(SkRect::MakeXYWH(8, 0, 8, 8), lightPaint);
- canvas.drawRect(SkRect::MakeXYWH(0, 8, 8, 8), lightPaint);
- canvas.drawRect(SkRect::MakeXYWH(8, 8, 8, 8), darkPaint);
- canvas.restore();
- }
- }
- }
SkString fName;
bool fIsSmall;
diff --git a/bench/ImageFilterDAGBench.cpp b/bench/ImageFilterDAGBench.cpp
index 5fdf95b..308b3b0 100644
--- a/bench/ImageFilterDAGBench.cpp
+++ b/bench/ImageFilterDAGBench.cpp
@@ -28,7 +28,7 @@
const SkRect rect = SkRect::Make(SkIRect::MakeWH(400, 400));
for (int j = 0; j < loops; j++) {
- sk_sp<SkImageFilter> blur(SkBlurImageFilter::Create(20.0f, 20.0f));
+ sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(20.0f, 20.0f, nullptr));
sk_sp<SkImageFilter> inputs[kNumInputs];
for (int i = 0; i < kNumInputs; ++i) {
inputs[i] = blur;
@@ -58,14 +58,14 @@
void onDraw(int loops, SkCanvas* canvas) override {
for (int j = 0; j < loops; j++) {
- SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(4.0f, 4.0f));
- SkDisplacementMapEffect::ChannelSelectorType xSelector = SkDisplacementMapEffect::kR_ChannelSelectorType;
- SkDisplacementMapEffect::ChannelSelectorType ySelector = SkDisplacementMapEffect::kB_ChannelSelectorType;
+ sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(4.0f, 4.0f, nullptr));
+ auto xSelector = SkDisplacementMapEffect::kR_ChannelSelectorType;
+ auto ySelector = SkDisplacementMapEffect::kB_ChannelSelectorType;
SkScalar scale = 2;
- SkAutoTUnref<SkImageFilter> displ(SkDisplacementMapEffect::Create(xSelector, ySelector, scale,
- blur.get(), blur.get()));
+ sk_sp<SkImageFilter> displ(SkDisplacementMapEffect::Create(xSelector, ySelector, scale,
+ blur.get(), blur.get()));
SkPaint paint;
- paint.setImageFilter(displ);
+ paint.setImageFilter(std::move(displ));
SkRect rect = SkRect::Make(SkIRect::MakeWH(400, 400));
canvas->drawRect(rect, paint);
}
diff --git a/gm/coloremoji.cpp b/gm/coloremoji.cpp
index 4be8202..5132d71 100644
--- a/gm/coloremoji.cpp
+++ b/gm/coloremoji.cpp
@@ -27,19 +27,19 @@
SkShader::kClamp_TileMode);
}
-static SkImageFilter* make_grayscale(SkImageFilter* input = nullptr) {
+static sk_sp<SkImageFilter> make_grayscale(sk_sp<SkImageFilter> input) {
SkScalar matrix[20];
memset(matrix, 0, 20 * sizeof(SkScalar));
matrix[0] = matrix[5] = matrix[10] = 0.2126f;
matrix[1] = matrix[6] = matrix[11] = 0.7152f;
matrix[2] = matrix[7] = matrix[12] = 0.0722f;
matrix[18] = 1.0f;
- auto filter(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
- return SkColorFilterImageFilter::Create(filter.get(), input);
+ sk_sp<SkColorFilter> filter(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
+ return sk_sp<SkImageFilter>(SkColorFilterImageFilter::Create(filter.get(), input.get()));
}
-static SkImageFilter* make_blur(float amount, SkImageFilter* input = nullptr) {
- return SkBlurImageFilter::Create(amount, amount, input);
+static sk_sp<SkImageFilter> make_blur(float amount, sk_sp<SkImageFilter> input) {
+ return SkBlurImageFilter::Make(amount, amount, std::move(input));
}
namespace skiagm {
@@ -98,15 +98,13 @@
}
if (SkToBool(makeBlur) && SkToBool(makeGray)) {
- SkAutoTUnref<SkImageFilter> grayScale(make_grayscale(nullptr));
- SkAutoTUnref<SkImageFilter> blur(make_blur(3.0f, grayScale));
- shaderPaint.setImageFilter(blur);
+ sk_sp<SkImageFilter> grayScale(make_grayscale(nullptr));
+ sk_sp<SkImageFilter> blur(make_blur(3.0f, std::move(grayScale)));
+ shaderPaint.setImageFilter(std::move(blur));
} else if (SkToBool(makeBlur)) {
- SkAutoTUnref<SkImageFilter> blur(make_blur(3.0f, nullptr));
- shaderPaint.setImageFilter(blur);
+ shaderPaint.setImageFilter(make_blur(3.0f, nullptr));
} else if (SkToBool(makeGray)) {
- SkAutoTUnref<SkImageFilter> grayScale(make_grayscale(nullptr));
- shaderPaint.setImageFilter(grayScale);
+ shaderPaint.setImageFilter(make_grayscale(nullptr));
}
shaderPaint.setTextSize(30);
canvas->drawText(text, strlen(text), 380, SkIntToScalar(y_offset),
@@ -160,7 +158,6 @@
//////////////////////////////////////////////////////////////////////////////
-static GM* MyFactory(void*) { return new ColorEmojiGM; }
-static GMRegistry reg(MyFactory);
+DEF_GM(return new ColorEmojiGM;)
}
diff --git a/gm/colorfilterimagefilter.cpp b/gm/colorfilterimagefilter.cpp
index 497757e..38ff0dd 100644
--- a/gm/colorfilterimagefilter.cpp
+++ b/gm/colorfilterimagefilter.cpp
@@ -87,26 +87,29 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
-static SkImageFilter* make_blur(float amount, SkImageFilter* input = nullptr) {
- return SkBlurImageFilter::Create(amount, amount, input);
+static sk_sp<SkImageFilter> make_blur(float amount, sk_sp<SkImageFilter> input) {
+ return SkBlurImageFilter::Make(amount, amount, std::move(input));
}
-static SkImageFilter* make_brightness(float amount, SkImageFilter* input = nullptr) {
- return SkColorFilterImageFilter::Create(cf_make_brightness(amount).get(), input);
+static sk_sp<SkImageFilter> make_brightness(float amount, sk_sp<SkImageFilter> input) {
+ return sk_sp<SkImageFilter>(SkColorFilterImageFilter::Create(cf_make_brightness(amount).get(),
+ input.get()));
}
-static SkImageFilter* make_grayscale(SkImageFilter* input = nullptr) {
- return SkColorFilterImageFilter::Create(cf_make_grayscale().get(), input);
+static sk_sp<SkImageFilter> make_grayscale(sk_sp<SkImageFilter> input) {
+ return sk_sp<SkImageFilter>(SkColorFilterImageFilter::Create(cf_make_grayscale().get(),
+ input.get()));
}
-static SkImageFilter* make_mode_blue(SkImageFilter* input = nullptr) {
- return SkColorFilterImageFilter::Create(cf_make_colorize(SK_ColorBLUE).get(), input);
+static sk_sp<SkImageFilter> make_mode_blue(sk_sp<SkImageFilter> input) {
+ return sk_sp<SkImageFilter>(SkColorFilterImageFilter::Create(cf_make_colorize(SK_ColorBLUE).get(),
+ input.get()));
}
-static void drawClippedRect(SkCanvas* canvas,
- const SkRect& r,
- const SkPaint& paint,
- float outset = 0.0f) {
+static void draw_clipped_rect(SkCanvas* canvas,
+ const SkRect& r,
+ const SkPaint& paint,
+ float outset = 0.0f) {
canvas->save();
SkRect clip(r);
clip.outset(outset, outset);
@@ -121,53 +124,53 @@
paint.setColor(SK_ColorRED);
canvas->save();
for (float brightness = -1.0f; brightness <= 1.0f; brightness += 0.2f) {
- SkAutoTUnref<SkImageFilter> dim(make_brightness(-brightness));
- SkAutoTUnref<SkImageFilter> bright(make_brightness(brightness, dim));
- paint.setImageFilter(bright);
- drawClippedRect(canvas, r, paint);
+ sk_sp<SkImageFilter> dim(make_brightness(-brightness, nullptr));
+ sk_sp<SkImageFilter> bright(make_brightness(brightness, std::move(dim)));
+ paint.setImageFilter(std::move(bright));
+ draw_clipped_rect(canvas, r, paint);
canvas->translate(FILTER_WIDTH + MARGIN, 0);
}
canvas->restore();
canvas->translate(0, FILTER_HEIGHT + MARGIN);
{
- SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.9f));
- SkAutoTUnref<SkImageFilter> grayscale(make_grayscale(brightness));
- paint.setImageFilter(grayscale);
- drawClippedRect(canvas, r, paint);
+ sk_sp<SkImageFilter> brightness(make_brightness(0.9f, nullptr));
+ sk_sp<SkImageFilter> grayscale(make_grayscale(std::move(brightness)));
+ paint.setImageFilter(std::move(grayscale));
+ draw_clipped_rect(canvas, r, paint);
canvas->translate(FILTER_WIDTH + MARGIN, 0);
}
{
- SkAutoTUnref<SkImageFilter> grayscale(make_grayscale());
- SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.9f, grayscale));
- paint.setImageFilter(brightness);
- drawClippedRect(canvas, r, paint);
+ sk_sp<SkImageFilter> grayscale(make_grayscale(nullptr));
+ sk_sp<SkImageFilter> brightness(make_brightness(0.9f, std::move(grayscale)));
+ paint.setImageFilter(std::move(brightness));
+ draw_clipped_rect(canvas, r, paint);
canvas->translate(FILTER_WIDTH + MARGIN, 0);
}
{
- SkAutoTUnref<SkImageFilter> blue(make_mode_blue());
- SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f, blue));
- paint.setImageFilter(brightness);
- drawClippedRect(canvas, r, paint);
+ sk_sp<SkImageFilter> blue(make_mode_blue(nullptr));
+ sk_sp<SkImageFilter> brightness(make_brightness(1.0f, std::move(blue)));
+ paint.setImageFilter(std::move(brightness));
+ draw_clipped_rect(canvas, r, paint);
canvas->translate(FILTER_WIDTH + MARGIN, 0);
}
{
- SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f));
- SkAutoTUnref<SkImageFilter> blue(make_mode_blue(brightness));
- paint.setImageFilter(blue);
- drawClippedRect(canvas, r, paint);
+ sk_sp<SkImageFilter> brightness(make_brightness(1.0f, nullptr));
+ sk_sp<SkImageFilter> blue(make_mode_blue(std::move(brightness)));
+ paint.setImageFilter(std::move(blue));
+ draw_clipped_rect(canvas, r, paint);
canvas->translate(FILTER_WIDTH + MARGIN, 0);
}
{
- SkAutoTUnref<SkImageFilter> blur(make_blur(3.0f));
- SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.5f, blur));
- paint.setImageFilter(brightness);
- drawClippedRect(canvas, r, paint, 3);
+ sk_sp<SkImageFilter> blur(make_blur(3.0f, nullptr));
+ sk_sp<SkImageFilter> brightness(make_brightness(0.5f, std::move(blur)));
+ paint.setImageFilter(std::move(brightness));
+ draw_clipped_rect(canvas, r, paint, 3);
canvas->translate(FILTER_WIDTH + MARGIN, 0);
}
{
- SkAutoTUnref<SkImageFilter> blue(make_mode_blue());
- paint.setImageFilter(blue.get());
- drawClippedRect(canvas, r, paint, 5);
+ sk_sp<SkImageFilter> blue(make_mode_blue(nullptr));
+ paint.setImageFilter(std::move(blue));
+ draw_clipped_rect(canvas, r, paint, 5);
canvas->translate(FILTER_WIDTH + MARGIN, 0);
}
}
@@ -177,9 +180,9 @@
SkColorMatrix cm;
cm.setSaturation(0.0f);
auto cf(SkColorFilter::MakeMatrixFilterRowMajor255(cm.fMat));
- SkAutoTUnref<SkImageFilter> imf(SkColorFilterImageFilter::Create(cf.get()));
+ sk_sp<SkImageFilter> imf(SkColorFilterImageFilter::Create(cf.get()));
SkPaint p;
- p.setImageFilter(imf);
+ p.setImageFilter(std::move(imf));
canvas->saveLayer(NULL, &p);
canvas->clear(SK_ColorRED);
}
diff --git a/gm/complexclip_blur_tiled.cpp b/gm/complexclip_blur_tiled.cpp
index 9413e64..979c7e7 100644
--- a/gm/complexclip_blur_tiled.cpp
+++ b/gm/complexclip_blur_tiled.cpp
@@ -31,22 +31,21 @@
void onDraw(SkCanvas* canvas) override {
SkPaint blurPaint;
- SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(5.0f, 5.0f));
- blurPaint.setImageFilter(blur);
- const SkScalar tile_size = SkIntToScalar(128);
+ blurPaint.setImageFilter(SkBlurImageFilter::Make(5.0f, 5.0f, nullptr));
+ const SkScalar tileSize = SkIntToScalar(128);
SkRect bounds;
if (!canvas->getClipBounds(&bounds)) {
bounds.setEmpty();
}
- int ts = SkScalarCeilToInt(tile_size);
+ int ts = SkScalarCeilToInt(tileSize);
SkImageInfo info = SkImageInfo::MakeN32Premul(ts, ts);
auto tileSurface(canvas->makeSurface(info));
if (!tileSurface) {
tileSurface = SkSurface::MakeRaster(info);
}
SkCanvas* tileCanvas = tileSurface->getCanvas();
- for (SkScalar y = bounds.top(); y < bounds.bottom(); y += tile_size) {
- for (SkScalar x = bounds.left(); x < bounds.right(); x += tile_size) {
+ for (SkScalar y = bounds.top(); y < bounds.bottom(); y += tileSize) {
+ for (SkScalar x = bounds.left(); x < bounds.right(); x += tileSize) {
tileCanvas->save();
tileCanvas->clear(0);
tileCanvas->translate(-x, -y);
@@ -69,7 +68,6 @@
//////////////////////////////////////////////////////////////////////////////
-static GM* MyFactory1(void*) { return new ComplexClipBlurTiledGM(); }
-static GMRegistry reg1(MyFactory1);
+DEF_GM(return new ComplexClipBlurTiledGM;)
}
diff --git a/gm/filterfastbounds.cpp b/gm/filterfastbounds.cpp
index 9d07095..a254ec9 100644
--- a/gm/filterfastbounds.cpp
+++ b/gm/filterfastbounds.cpp
@@ -82,79 +82,68 @@
draw_rect, draw_oval, draw_rrect, draw_drrect, draw_path, draw_points, draw_bitmap
};
-static void add_paint(SkImageFilter* filter, SkTArray<SkPaint>* paints) {
+static void add_paint(SkTArray<SkPaint>* paints, sk_sp<SkImageFilter> filter) {
SkPaint& p = paints->push_back();
- p.setImageFilter(filter);
+ p.setImageFilter(std::move(filter));
SkASSERT(p.canComputeFastBounds());
}
// Create a selection of imagefilter-based paints to test
-static void create_paints(SkImageFilter* source, SkTArray<SkPaint>* paints) {
+static void create_paints(SkTArray<SkPaint>* paints, sk_sp<SkImageFilter> source) {
{
SkMatrix scale;
scale.setScale(2.0f, 2.0f);
- SkAutoTUnref<SkImageFilter> scaleMIF(
- SkImageFilter::CreateMatrixFilter(scale, kLow_SkFilterQuality, source));
+ sk_sp<SkImageFilter> scaleMIF(
+ SkImageFilter::CreateMatrixFilter(scale, kLow_SkFilterQuality, source.get()));
- add_paint(scaleMIF, paints);
+ add_paint(paints, std::move(scaleMIF));
}
{
SkMatrix rot;
rot.setRotate(-33.3f);
- SkAutoTUnref<SkImageFilter> rotMIF(
- SkImageFilter::CreateMatrixFilter(rot, kLow_SkFilterQuality, source));
+ sk_sp<SkImageFilter> rotMIF(
+ SkImageFilter::CreateMatrixFilter(rot, kLow_SkFilterQuality, source.get()));
- add_paint(rotMIF, paints);
+ add_paint(paints, std::move(rotMIF));
}
{
SkRect src = SkRect::MakeXYWH(20, 20, 10, 10);
SkRect dst = SkRect::MakeXYWH(30, 30, 30, 30);
- SkAutoTUnref<SkImageFilter> tileIF(
- SkTileImageFilter::Create(src, dst, nullptr));
+ sk_sp<SkImageFilter> tileIF(SkTileImageFilter::Create(src, dst, nullptr));
- add_paint(tileIF, paints);
+ add_paint(paints, std::move(tileIF));
}
{
static const SkDropShadowImageFilter::ShadowMode kBoth =
SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode;
- SkAutoTUnref<SkImageFilter> dsif(
+ sk_sp<SkImageFilter> dsif(
SkDropShadowImageFilter::Create(10.0f, 10.0f,
3.0f, 3.0f,
SK_ColorRED, kBoth,
- source, nullptr));
+ source.get(), nullptr));
- add_paint(dsif, paints);
+ add_paint(paints, std::move(dsif));
}
{
- SkAutoTUnref<SkImageFilter> dsif(
+ sk_sp<SkImageFilter> dsif(
SkDropShadowImageFilter::Create(27.0f, 27.0f,
3.0f, 3.0f,
SK_ColorRED,
SkDropShadowImageFilter::kDrawShadowOnly_ShadowMode,
- source, nullptr));
+ source.get(), nullptr));
- add_paint(dsif, paints);
+ add_paint(paints, std::move(dsif));
}
- {
- SkAutoTUnref<SkImageFilter> bif(SkBlurImageFilter::Create(3, 3, source));
-
- add_paint(bif, paints);
- }
-
- {
- sk_sp<SkImageFilter> oif(SkOffsetImageFilter::Make(15, 15,
- sk_ref_sp<SkImageFilter>(source)));
-
- add_paint(oif.get(), paints);
- }
+ add_paint(paints, SkBlurImageFilter::Make(3, 3, source));
+ add_paint(paints, SkOffsetImageFilter::Make(15, 15, source));
}
// This GM visualizes the fast bounds for various combinations of geometry
@@ -243,7 +232,7 @@
//-----------
// Normal paints (no source)
SkTArray<SkPaint> paints;
- create_paints(nullptr, &paints);
+ create_paints(&paints, nullptr);
//-----------
// Paints with a PictureImageFilter as a source
@@ -257,10 +246,8 @@
pic = rec.finishRecordingAsPicture();
}
- sk_sp<SkImageFilter> pif(SkPictureImageFilter::Make(pic));
-
SkTArray<SkPaint> pifPaints;
- create_paints(pif.get(), &pifPaints);
+ create_paints(&pifPaints, SkPictureImageFilter::Make(pic));
//-----------
// Paints with a SkImageSource as a source
@@ -278,9 +265,8 @@
sk_sp<SkImage> image(surface->makeImageSnapshot());
sk_sp<SkImageFilter> imageSource(SkImageSource::Make(std::move(image)));
-
SkTArray<SkPaint> bmsPaints;
- create_paints(imageSource.get(), &bmsPaints);
+ create_paints(&bmsPaints, std::move(imageSource));
//-----------
SkASSERT(paints.count() == kNumVertTiles);
diff --git a/gm/imageblur.cpp b/gm/imageblur.cpp
index 22ea408..6a27c65 100644
--- a/gm/imageblur.cpp
+++ b/gm/imageblur.cpp
@@ -14,8 +14,7 @@
void imageblurgm_draw(SkScalar fSigmaX, SkScalar fSigmaY, SkCanvas* canvas) {
SkPaint paint;
- SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(fSigmaX, fSigmaY));
- paint.setImageFilter(blur);
+ paint.setImageFilter(SkBlurImageFilter::Make(fSigmaX, fSigmaY, nullptr));
canvas->saveLayer(nullptr, &paint);
const char* str = "The quick brown fox jumped over the lazy dog.";
diff --git a/gm/imageblur2.cpp b/gm/imageblur2.cpp
index 2b95c02..c6835d8 100644
--- a/gm/imageblur2.cpp
+++ b/gm/imageblur2.cpp
@@ -58,8 +58,7 @@
SkScalar sigmaY = kBlurSigmas[y];
SkPaint paint;
- SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(sigmaX, sigmaY));
- paint.setImageFilter(blur);
+ paint.setImageFilter(SkBlurImageFilter::Make(sigmaX, sigmaY, nullptr));
canvas->saveLayer(nullptr, &paint);
SkRandom rand;
@@ -89,7 +88,6 @@
//////////////////////////////////////////////////////////////////////////////
-static GM* MyFactory(void*) { return new BlurImageFilter; }
-static GMRegistry reg(MyFactory);
+DEF_GM(return new BlurImageFilter;)
}
diff --git a/gm/imageblurtiled.cpp b/gm/imageblurtiled.cpp
index 9f8bfe5..415fa73 100644
--- a/gm/imageblurtiled.cpp
+++ b/gm/imageblurtiled.cpp
@@ -21,27 +21,26 @@
}
protected:
- virtual SkString onShortName() {
+ SkString onShortName() override {
return SkString("imageblurtiled");
}
- virtual SkISize onISize() {
+ SkISize onISize() override {
return SkISize::Make(WIDTH, HEIGHT);
}
- virtual void onDraw(SkCanvas* canvas) {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
- SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(fSigmaX, fSigmaY));
- paint.setImageFilter(blur);
- const SkScalar tile_size = SkIntToScalar(128);
+ paint.setImageFilter(SkBlurImageFilter::Make(fSigmaX, fSigmaY, nullptr));
+ const SkScalar tileSize = SkIntToScalar(128);
SkRect bounds;
if (!canvas->getClipBounds(&bounds)) {
bounds.setEmpty();
}
- for (SkScalar y = bounds.top(); y < bounds.bottom(); y += tile_size) {
- for (SkScalar x = bounds.left(); x < bounds.right(); x += tile_size) {
+ for (SkScalar y = bounds.top(); y < bounds.bottom(); y += tileSize) {
+ for (SkScalar x = bounds.left(); x < bounds.right(); x += tileSize) {
canvas->save();
- canvas->clipRect(SkRect::MakeXYWH(x, y, tile_size, tile_size));
+ canvas->clipRect(SkRect::MakeXYWH(x, y, tileSize, tileSize));
canvas->saveLayer(nullptr, &paint);
const char* str[] = {
"The quick",
@@ -74,7 +73,6 @@
//////////////////////////////////////////////////////////////////////////////
-static GM* MyFactory1(void*) { return new ImageBlurTiledGM(3.0f, 3.0f); }
-static GMRegistry reg1(MyFactory1);
+DEF_GM(return new ImageBlurTiledGM(3.0f, 3.0f);)
}
diff --git a/gm/imagefilters.cpp b/gm/imagefilters.cpp
index ab9ddf4..10072c8 100644
--- a/gm/imagefilters.cpp
+++ b/gm/imagefilters.cpp
@@ -87,8 +87,7 @@
canvas->translate(10, 10);
for (SkScalar sigma = 8; sigma <= 128; sigma *= 2) {
SkPaint paint;
- SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(sigma, sigma));
- paint.setImageFilter(blur);
+ paint.setImageFilter(SkBlurImageFilter::Make(sigma, sigma, nullptr));
canvas->save();
// we outset the clip by 1, to fall out of the fast-case in drawImage
@@ -143,7 +142,7 @@
auto cf(SkColorFilter::MakeMatrixFilterRowMajor255(cm.fMat));
const SkScalar kernel[] = { 4, 0, 4, 0, -15, 0, 4, 0, 4 };
SkImageFilter* filters[] = {
- SkBlurImageFilter::Create(10, 10),
+ SkBlurImageFilter::Make(10, 10, nullptr).release(),
SkDilateImageFilter::Create(8, 8),
SkMatrixConvolutionImageFilter::Create({ 3, 3 }, kernel, 1, 0, { 0, 0 },
SkMatrixConvolutionImageFilter::kClampToBlack_TileMode,
diff --git a/gm/imagefiltersbase.cpp b/gm/imagefiltersbase.cpp
index 3c1cf09..d2367e2 100644
--- a/gm/imagefiltersbase.cpp
+++ b/gm/imagefiltersbase.cpp
@@ -198,7 +198,7 @@
IdentityImageFilter::Create(),
FailImageFilter::Create(),
SkColorFilterImageFilter::Create(cf.get()),
- SkBlurImageFilter::Create(12.0f, 0.0f),
+ SkBlurImageFilter::Make(12.0f, 0.0f, nullptr).release(),
SkDropShadowImageFilter::Create(10.0f, 5.0f, 3.0f, 3.0f, SK_ColorBLUE,
SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
};
@@ -308,7 +308,7 @@
ImageFiltersText_IF() : ImageFiltersTextBaseGM("image") {}
void installFilter(SkPaint* paint) override {
- paint->setImageFilter(SkBlurImageFilter::Create(1.5f, 1.5f))->unref();
+ paint->setImageFilter(SkBlurImageFilter::Make(1.5f, 1.5f, nullptr));
}
};
DEF_GM( return new ImageFiltersText_IF; )
diff --git a/gm/imagefiltersclipped.cpp b/gm/imagefiltersclipped.cpp
index 31f8ad2..85c5438 100644
--- a/gm/imagefiltersclipped.cpp
+++ b/gm/imagefiltersclipped.cpp
@@ -94,7 +94,7 @@
SkPoint3 pointLocation = SkPoint3::Make(32, 32, SkIntToScalar(10));
SkImageFilter* filters[] = {
- SkBlurImageFilter::Create(SkIntToScalar(12), SkIntToScalar(12)),
+ SkBlurImageFilter::Make(SkIntToScalar(12), SkIntToScalar(12), nullptr).release(),
SkDropShadowImageFilter::Create(SkIntToScalar(10), SkIntToScalar(10),
SkIntToScalar(3), SkIntToScalar(3), SK_ColorGREEN,
SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
diff --git a/gm/imagefilterscropexpand.cpp b/gm/imagefilterscropexpand.cpp
index 82df81c..f1a1323 100644
--- a/gm/imagefilterscropexpand.cpp
+++ b/gm/imagefilterscropexpand.cpp
@@ -80,15 +80,13 @@
noopCropped.get(),
&bigRect)));
- Draw(canvas, checkerboard, rect,
- sk_sp<SkImageFilter>(SkBlurImageFilter::Create(0.3f, 0.3f,
- noopCropped.get(),
- &bigRect)));
+ Draw(canvas, checkerboard, rect, SkBlurImageFilter::Make(0.3f, 0.3f,
+ noopCropped,
+ &bigRect));
- Draw(canvas, checkerboard, rect,
- sk_sp<SkImageFilter>(SkBlurImageFilter::Create(8.0f, 8.0f,
- noopCropped.get(),
- &bigRect)));
+ Draw(canvas, checkerboard, rect, SkBlurImageFilter::Make(8.0f, 8.0f,
+ noopCropped,
+ &bigRect));
Draw(canvas, checkerboard, rect,
sk_sp<SkImageFilter>(SkDilateImageFilter::Create(2, 2,
diff --git a/gm/imagefilterscropped.cpp b/gm/imagefilterscropped.cpp
index 9c8705c..1e880fe 100644
--- a/gm/imagefilterscropped.cpp
+++ b/gm/imagefilterscropped.cpp
@@ -131,18 +131,18 @@
SkImageFilter* filters[] = {
nullptr,
SkColorFilterImageFilter::Create(cf.get(), nullptr, &cropRect),
- SkBlurImageFilter::Create(0.0f, 0.0f, nullptr, &cropRect),
- SkBlurImageFilter::Create(1.0f, 1.0f, nullptr, &cropRect),
- SkBlurImageFilter::Create(8.0f, 0.0f, nullptr, &cropRect),
- SkBlurImageFilter::Create(0.0f, 8.0f, nullptr, &cropRect),
- SkBlurImageFilter::Create(8.0f, 8.0f, nullptr, &cropRect),
+ SkBlurImageFilter::Make(0.0f, 0.0f, nullptr, &cropRect).release(),
+ SkBlurImageFilter::Make(1.0f, 1.0f, nullptr, &cropRect).release(),
+ SkBlurImageFilter::Make(8.0f, 0.0f, nullptr, &cropRect).release(),
+ SkBlurImageFilter::Make(0.0f, 8.0f, nullptr, &cropRect).release(),
+ SkBlurImageFilter::Make(8.0f, 8.0f, nullptr, &cropRect).release(),
SkErodeImageFilter::Create(1, 1, nullptr, &cropRect),
SkErodeImageFilter::Create(8, 0, erodeY, &cropRect),
SkErodeImageFilter::Create(0, 8, erodeX, &cropRect),
SkErodeImageFilter::Create(8, 8, nullptr, &cropRect),
SkMergeImageFilter::Make(nullptr, std::move(cfOffset),
SkXfermode::kSrcOver_Mode, &cropRect).release(),
- SkBlurImageFilter::Create(8.0f, 8.0f, nullptr, &bogusRect),
+ SkBlurImageFilter::Make(8.0f, 8.0f, nullptr, &bogusRect).release(),
SkColorFilterImageFilter::Create(cf.get(), nullptr, &bogusRect),
};
diff --git a/gm/imagefiltersgraph.cpp b/gm/imagefiltersgraph.cpp
index c0c652b..b7402ee 100644
--- a/gm/imagefiltersgraph.cpp
+++ b/gm/imagefiltersgraph.cpp
@@ -121,7 +121,7 @@
sk_sp<SkImageFilter> bitmapSource(SkImageSource::Make(fImage));
sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorRED,
SkXfermode::kSrcIn_Mode));
- sk_sp<SkImageFilter> blur(SkBlurImageFilter::Create(4.0f, 4.0f, bitmapSource.get()));
+ sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(4.0f, 4.0f, std::move(bitmapSource)));
sk_sp<SkImageFilter> erode(SkErodeImageFilter::Create(4, 4, blur.get()));
sk_sp<SkImageFilter> color(SkColorFilterImageFilter::Create(cf.get(), erode.get()));
sk_sp<SkImageFilter> merge(SkMergeImageFilter::Make(blur, color));
@@ -167,13 +167,14 @@
canvas->translate(SkIntToScalar(100), 0);
}
{
- SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(
- SkIntToScalar(10), SkIntToScalar(10)));
+ sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(SkIntToScalar(10),
+ SkIntToScalar(10),
+ nullptr));
SkImageFilter::CropRect cropRect(SkRect::MakeWH(SkIntToScalar(95), SkIntToScalar(100)));
SkPaint paint;
paint.setImageFilter(
- SkXfermodeImageFilter::Make(SkXfermode::Make(SkXfermode::kSrcIn_Mode), blur,
+ SkXfermodeImageFilter::Make(SkXfermode::Make(SkXfermode::kSrcIn_Mode), blur.get(),
nullptr, &cropRect));
DrawClippedImage(canvas, fImage.get(), paint);
canvas->translate(SkIntToScalar(100), 0);
diff --git a/gm/imagefiltersscaled.cpp b/gm/imagefiltersscaled.cpp
index 61eb469..56a1484 100644
--- a/gm/imagefiltersscaled.cpp
+++ b/gm/imagefiltersscaled.cpp
@@ -73,7 +73,7 @@
resizeMatrix.setScale(RESIZE_FACTOR, RESIZE_FACTOR);
SkImageFilter* filters[] = {
- SkBlurImageFilter::Create(SkIntToScalar(4), SkIntToScalar(4)),
+ SkBlurImageFilter::Make(SkIntToScalar(4), SkIntToScalar(4), nullptr).release(),
SkDropShadowImageFilter::Create(SkIntToScalar(5), SkIntToScalar(10),
SkIntToScalar(3), SkIntToScalar(3), SK_ColorYELLOW,
SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
diff --git a/gm/imagefiltersstroked.cpp b/gm/imagefiltersstroked.cpp
index 9275990..81f8145 100644
--- a/gm/imagefiltersstroked.cpp
+++ b/gm/imagefiltersstroked.cpp
@@ -58,7 +58,7 @@
resizeMatrix.setScale(RESIZE_FACTOR_X, RESIZE_FACTOR_Y);
SkImageFilter* filters[] = {
- SkBlurImageFilter::Create(5, 5),
+ SkBlurImageFilter::Make(5, 5, nullptr).release(),
SkDropShadowImageFilter::Create(10, 10, 3, 3, SK_ColorGREEN,
SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
SkOffsetImageFilter::Make(-16, 32, nullptr).release(),
diff --git a/gm/imagefilterstransformed.cpp b/gm/imagefilterstransformed.cpp
index a9b1863..687e458 100644
--- a/gm/imagefilterstransformed.cpp
+++ b/gm/imagefilterstransformed.cpp
@@ -66,7 +66,7 @@
sk_sp<SkImageFilter> gradient(SkImageSource::Make(fGradientCircle));
sk_sp<SkImageFilter> checkerboard(SkImageSource::Make(fCheckerboard));
SkImageFilter* filters[] = {
- SkBlurImageFilter::Create(12, 0),
+ SkBlurImageFilter::Make(12, 0, nullptr).release(),
SkDropShadowImageFilter::Create(0, 15, 8, 0, SK_ColorGREEN,
SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType,
diff --git a/gm/localmatriximagefilter.cpp b/gm/localmatriximagefilter.cpp
index 5c49671..baa44b9 100644
--- a/gm/localmatriximagefilter.cpp
+++ b/gm/localmatriximagefilter.cpp
@@ -65,7 +65,7 @@
sk_sp<SkImage> image0(make_image(canvas));
const ImageFilterFactory factories[] = {
- IFCCast([]{ return SkBlurImageFilter::Create(8, 8); }),
+ IFCCast([]{ return SkBlurImageFilter::Make(8, 8, nullptr).release(); }),
IFCCast([]{ return SkDilateImageFilter::Create(8, 8); }),
IFCCast([]{ return SkErodeImageFilter::Create(8, 8); }),
IFCCast([]{ return SkOffsetImageFilter::Make(8, 8, nullptr).release(); }),
diff --git a/gm/spritebitmap.cpp b/gm/spritebitmap.cpp
index 6c438fa..38fe9f4 100644
--- a/gm/spritebitmap.cpp
+++ b/gm/spritebitmap.cpp
@@ -23,7 +23,7 @@
}
static void draw_1_bitmap(SkCanvas* canvas, const SkBitmap& bm, bool doClip,
- int dx, int dy, SkImageFilter* filter = nullptr) {
+ int dx, int dy, sk_sp<SkImageFilter> filter) {
SkAutoCanvasRestore acr(canvas, true);
SkPaint paint;
@@ -32,7 +32,7 @@
SkIntToScalar(bm.width()),
SkIntToScalar(bm.height()));
- paint.setImageFilter(filter);
+ paint.setImageFilter(std::move(filter));
clipR.inset(5, 5);
canvas->translate(SkIntToScalar(bm.width() + 20), 0);
@@ -72,13 +72,13 @@
int dy = 10;
SkScalar sigma = 8;
- SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(sigma, sigma));
+ sk_sp<SkImageFilter> filter(SkBlurImageFilter::Make(sigma, sigma, nullptr));
- draw_1_bitmap(canvas, bm, false, dx, dy);
+ draw_1_bitmap(canvas, bm, false, dx, dy, nullptr);
dy += bm.height() + 20;
draw_1_bitmap(canvas, bm, false, dx, dy, filter);
dy += bm.height() + 20;
- draw_1_bitmap(canvas, bm, true, dx, dy);
+ draw_1_bitmap(canvas, bm, true, dx, dy, nullptr);
dy += bm.height() + 20;
draw_1_bitmap(canvas, bm, true, dx, dy, filter);
}
diff --git a/gm/testimagefilters.cpp b/gm/testimagefilters.cpp
index 9c2a5a9..ab27771 100644
--- a/gm/testimagefilters.cpp
+++ b/gm/testimagefilters.cpp
@@ -35,7 +35,7 @@
}
static sk_sp<SkImageFilter> make3() {
- return sk_sp<SkImageFilter>(SkBlurImageFilter::Create(8, 0));
+ return SkBlurImageFilter::Make(8, 0, nullptr);
}
static sk_sp<SkImageFilter> make4() {
diff --git a/include/effects/SkBlurImageFilter.h b/include/effects/SkBlurImageFilter.h
index 682c08f..607e76d 100644
--- a/include/effects/SkBlurImageFilter.h
+++ b/include/effects/SkBlurImageFilter.h
@@ -13,12 +13,12 @@
class SK_API SkBlurImageFilter : public SkImageFilter {
public:
- static SkImageFilter* Create(SkScalar sigmaX, SkScalar sigmaY, SkImageFilter* input = NULL,
- const CropRect* cropRect = NULL) {
+ static sk_sp<SkImageFilter> Make(SkScalar sigmaX, SkScalar sigmaY, sk_sp<SkImageFilter> input,
+ const CropRect* cropRect = nullptr) {
if (0 == sigmaX && 0 == sigmaY && nullptr == cropRect) {
- return SkSafeRef(input);
+ return input;
}
- return new SkBlurImageFilter(sigmaX, sigmaY, input, cropRect);
+ return sk_sp<SkImageFilter>(new SkBlurImageFilter(sigmaX, sigmaY, input, cropRect));
}
SkRect computeFastBounds(const SkRect&) const override;
@@ -26,6 +26,13 @@
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBlurImageFilter)
+#ifdef SK_SUPPORT_LEGACY_IMAGEFILTER_PTR
+ static SkImageFilter* Create(SkScalar sigmaX, SkScalar sigmaY, SkImageFilter* input = nullptr,
+ const CropRect* cropRect = nullptr) {
+ return Make(sigmaX, sigmaY, sk_ref_sp<SkImageFilter>(input), cropRect).release();
+ }
+#endif
+
protected:
void flatten(SkWriteBuffer&) const override;
sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source, const Context&,
@@ -35,7 +42,7 @@
private:
SkBlurImageFilter(SkScalar sigmaX,
SkScalar sigmaY,
- SkImageFilter* input,
+ sk_sp<SkImageFilter> input,
const CropRect* cropRect);
SkSize fSigma;
diff --git a/samplecode/SampleFilterFuzz.cpp b/samplecode/SampleFilterFuzz.cpp
index dd17e7e..6413aa1 100644
--- a/samplecode/SampleFilterFuzz.cpp
+++ b/samplecode/SampleFilterFuzz.cpp
@@ -583,13 +583,11 @@
: nullptr;
break;
}
- case BLUR: {
- sk_sp<SkImageFilter> subFilter(make_image_filter());
- filter = sk_sp<SkImageFilter>(SkBlurImageFilter::Create(make_scalar(true),
- make_scalar(true),
- subFilter.get()));
+ case BLUR:
+ filter = SkBlurImageFilter::Make(make_scalar(true),
+ make_scalar(true),
+ make_image_filter());
break;
- }
case MAGNIFIER:
filter = sk_sp<SkImageFilter>(SkMagnifierImageFilter::Create(make_rect(),
make_scalar(true)));
diff --git a/src/effects/SkBlurImageFilter.cpp b/src/effects/SkBlurImageFilter.cpp
index e7b326b..b7745e2 100644
--- a/src/effects/SkBlurImageFilter.cpp
+++ b/src/effects/SkBlurImageFilter.cpp
@@ -37,17 +37,17 @@
SkBlurImageFilter::SkBlurImageFilter(SkScalar sigmaX,
SkScalar sigmaY,
- SkImageFilter* input,
+ sk_sp<SkImageFilter> input,
const CropRect* cropRect)
- : INHERITED(1, &input, cropRect), fSigma(SkSize::Make(sigmaX, sigmaY)) {
+ : INHERITED(&input, 1, cropRect)
+ , fSigma(SkSize::Make(sigmaX, sigmaY)) {
}
sk_sp<SkFlattenable> SkBlurImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
SkScalar sigmaX = buffer.readScalar();
SkScalar sigmaY = buffer.readScalar();
- return sk_sp<SkFlattenable>(Create(sigmaX, sigmaY, common.getInput(0).get(),
- &common.cropRect()));
+ return Make(sigmaX, sigmaY, common.getInput(0), &common.cropRect());
}
void SkBlurImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkDropShadowImageFilter.cpp b/src/effects/SkDropShadowImageFilter.cpp
index 331cfbd..9cacad5 100644
--- a/src/effects/SkDropShadowImageFilter.cpp
+++ b/src/effects/SkDropShadowImageFilter.cpp
@@ -84,9 +84,8 @@
sigma.fX = SkMaxScalar(0, sigma.fX);
sigma.fY = SkMaxScalar(0, sigma.fY);
- SkAutoTUnref<SkImageFilter> blurFilter(SkBlurImageFilter::Create(sigma.fX, sigma.fY));
SkPaint paint;
- paint.setImageFilter(blurFilter.get());
+ paint.setImageFilter(SkBlurImageFilter::Make(sigma.fX, sigma.fY, nullptr));
paint.setColorFilter(SkColorFilter::MakeModeFilter(fColor, SkXfermode::kSrcIn_Mode));
paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
diff --git a/src/utils/SkLua.cpp b/src/utils/SkLua.cpp
index 9af5bfd..9369a6b 100644
--- a/src/utils/SkLua.cpp
+++ b/src/utils/SkLua.cpp
@@ -1963,11 +1963,11 @@
static int lsk_newBlurImageFilter(lua_State* L) {
SkScalar sigmaX = lua2scalar_def(L, 1, 0);
SkScalar sigmaY = lua2scalar_def(L, 2, 0);
- SkImageFilter* imf = SkBlurImageFilter::Create(sigmaX, sigmaY);
- if (nullptr == imf) {
+ sk_sp<SkImageFilter> imf(SkBlurImageFilter::Make(sigmaX, sigmaY, nullptr));
+ if (!imf) {
lua_pushnil(L);
} else {
- push_ref(L, imf)->unref();
+ push_ref(L, std::move(imf));
}
return 1;
}
@@ -1982,7 +1982,8 @@
SkPoint pts[] = { { x0, y0 }, { x1, y1 } };
SkColor colors[] = { c0, c1 };
- auto s = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+ sk_sp<SkShader> s(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
+ SkShader::kClamp_TileMode));
if (!s) {
lua_pushnil(L);
} else {
diff --git a/tests/ImageFilterTest.cpp b/tests/ImageFilterTest.cpp
index 3f60286..f873fa0 100644
--- a/tests/ImageFilterTest.cpp
+++ b/tests/ImageFilterTest.cpp
@@ -106,7 +106,6 @@
class FilterList {
public:
FilterList(SkImageFilter* input = nullptr, const SkImageFilter::CropRect* cropRect = nullptr) {
- auto cf(SkColorFilter::MakeModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode));
SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
SkScalar kernel[9] = {
SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
@@ -117,46 +116,33 @@
const SkScalar gain = SK_Scalar1, bias = 0;
const SkScalar five = SkIntToScalar(5);
- sk_sp<SkImage> gradientImage(SkImage::MakeFromBitmap(make_gradient_circle(64, 64)));
- sk_sp<SkImageFilter> gradientSource(SkImageSource::Make(std::move(gradientImage)));
- sk_sp<SkImageFilter> blur(SkBlurImageFilter::Create(five, five, input));
SkMatrix matrix;
matrix.setTranslate(SK_Scalar1, SK_Scalar1);
matrix.postRotate(SkIntToScalar(45), SK_Scalar1, SK_Scalar1);
- SkRTreeFactory factory;
- SkPictureRecorder recorder;
- SkCanvas* recordingCanvas = recorder.beginRecording(64, 64, &factory, 0);
+ {
+ sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorRED,
+ SkXfermode::kSrcIn_Mode));
- SkPaint greenPaint;
- greenPaint.setColor(SK_ColorGREEN);
- recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 30, 20)), greenPaint);
- sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
- sk_sp<SkImageFilter> pictureFilter(SkPictureImageFilter::Make(picture));
- sk_sp<SkShader> shader(SkPerlinNoiseShader::MakeTurbulence(SK_Scalar1, SK_Scalar1, 1, 0));
+ this->addFilter("color filter",
+ SkColorFilterImageFilter::Create(cf.get(), input, cropRect));
+ }
- SkPaint paint;
- paint.setShader(shader);
- sk_sp<SkImageFilter> paintFilter(SkPaintImageFilter::Make(paint));
+ {
+ sk_sp<SkImage> gradientImage(SkImage::MakeFromBitmap(make_gradient_circle(64, 64)));
+ sk_sp<SkImageFilter> gradientSource(SkImageSource::Make(std::move(gradientImage)));
- sk_sp<SkShader> greenColorShader(SkShader::MakeColorShader(SK_ColorGREEN));
- SkPaint greenColorShaderPaint;
- greenColorShaderPaint.setShader(greenColorShader);
- SkImageFilter::CropRect leftSideCropRect(SkRect::MakeXYWH(0, 0, 32, 64));
- sk_sp<SkImageFilter> paintFilterLeft(SkPaintImageFilter::Make(greenColorShaderPaint,
- &leftSideCropRect));
- SkImageFilter::CropRect rightSideCropRect(SkRect::MakeXYWH(32, 0, 32, 64));
- sk_sp<SkImageFilter> paintFilterRight(SkPaintImageFilter::Make(greenColorShaderPaint,
- &rightSideCropRect));
+ this->addFilter("displacement map", SkDisplacementMapEffect::Create(
+ SkDisplacementMapEffect::kR_ChannelSelectorType,
+ SkDisplacementMapEffect::kB_ChannelSelectorType,
+ 20.0f, gradientSource.get(), input, cropRect));
+ }
- this->addFilter("color filter",
- SkColorFilterImageFilter::Create(cf.get(), input, cropRect));
- this->addFilter("displacement map", SkDisplacementMapEffect::Create(
- SkDisplacementMapEffect::kR_ChannelSelectorType,
- SkDisplacementMapEffect::kB_ChannelSelectorType,
- 20.0f, gradientSource.get(), input, cropRect));
- this->addFilter("blur", SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1, input, cropRect));
+ this->addFilter("blur", SkBlurImageFilter::Make(SK_Scalar1,
+ SK_Scalar1,
+ sk_ref_sp<SkImageFilter>(input),
+ cropRect).release());
this->addFilter("drop shadow", SkDropShadowImageFilter::Create(
SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_ColorGREEN,
SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, input, cropRect));
@@ -173,9 +159,23 @@
sk_ref_sp<SkImageFilter>(input),
SkXfermode::kSrcOver_Mode,
cropRect).release());
- this->addFilter("merge with disjoint inputs", SkMergeImageFilter::Make(
+ {
+ SkPaint greenColorShaderPaint;
+ greenColorShaderPaint.setShader(SkShader::MakeColorShader(SK_ColorGREEN));
+
+ SkImageFilter::CropRect leftSideCropRect(SkRect::MakeXYWH(0, 0, 32, 64));
+ sk_sp<SkImageFilter> paintFilterLeft(SkPaintImageFilter::Make(greenColorShaderPaint,
+ &leftSideCropRect));
+ SkImageFilter::CropRect rightSideCropRect(SkRect::MakeXYWH(32, 0, 32, 64));
+ sk_sp<SkImageFilter> paintFilterRight(SkPaintImageFilter::Make(greenColorShaderPaint,
+ &rightSideCropRect));
+
+
+ this->addFilter("merge with disjoint inputs", SkMergeImageFilter::Make(
std::move(paintFilterLeft), std::move(paintFilterRight),
SkXfermode::kSrcOver_Mode, cropRect).release());
+ }
+
this->addFilter("offset",
SkOffsetImageFilter::Make(SK_Scalar1, SK_Scalar1,
sk_ref_sp<SkImageFilter>(input),
@@ -190,13 +190,39 @@
this->addFilter("matrix", SkImageFilter::CreateMatrixFilter(
matrix, kLow_SkFilterQuality, input));
}
- this->addFilter("blur and offset",
- SkOffsetImageFilter::Make(five, five, blur,
- cropRect).release());
- this->addFilter("picture and blur", SkBlurImageFilter::Create(
- five, five, pictureFilter.get(), cropRect));
- this->addFilter("paint and blur", SkBlurImageFilter::Create(
- five, five, paintFilter.get(), cropRect));
+
+ {
+ sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(five, five,
+ sk_ref_sp<SkImageFilter>(input)));
+
+ this->addFilter("blur and offset", SkOffsetImageFilter::Make(five, five,
+ std::move(blur),
+ cropRect).release());
+ }
+ {
+ SkRTreeFactory factory;
+ SkPictureRecorder recorder;
+ SkCanvas* recordingCanvas = recorder.beginRecording(64, 64, &factory, 0);
+
+ SkPaint greenPaint;
+ greenPaint.setColor(SK_ColorGREEN);
+ recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 30, 20)), greenPaint);
+ sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
+ sk_sp<SkImageFilter> pictureFilter(SkPictureImageFilter::Make(std::move(picture)));
+
+ this->addFilter("picture and blur", SkBlurImageFilter::Make(five, five,
+ std::move(pictureFilter),
+ cropRect).release());
+ }
+ {
+ SkPaint paint;
+ paint.setShader(SkPerlinNoiseShader::MakeTurbulence(SK_Scalar1, SK_Scalar1, 1, 0));
+ sk_sp<SkImageFilter> paintFilter(SkPaintImageFilter::Make(paint));
+
+ this->addFilter("paint and blur", SkBlurImageFilter::Make(five, five,
+ std::move(paintFilter),
+ cropRect).release());
+ }
this->addFilter("xfermode", SkXfermodeImageFilter::Make(
SkXfermode::Make(SkXfermode::kSrc_Mode), input, input, cropRect).release());
}
@@ -477,8 +503,8 @@
const int width = 32, height = 32;
const SkScalar five = SkIntToScalar(5);
- SkAutoTUnref<SkImageFilter> positiveFilter(SkBlurImageFilter::Create(five, five));
- SkAutoTUnref<SkImageFilter> negativeFilter(SkBlurImageFilter::Create(-five, five));
+ sk_sp<SkImageFilter> positiveFilter(SkBlurImageFilter::Make(five, five, nullptr));
+ sk_sp<SkImageFilter> negativeFilter(SkBlurImageFilter::Make(-five, five, nullptr));
SkBitmap gradient = make_gradient_circle(width, height);
sk_sp<SkSpecialImage> imgSrc(SkSpecialImage::MakeFromRaster(proxy,
@@ -599,7 +625,7 @@
// Check that SkBlurImageFilter with a zero sigma and a non-zero srcOffset works correctly.
SkImageFilter::CropRect cropRect(SkRect::Make(SkIRect::MakeXYWH(5, 0, 5, 10)));
sk_sp<SkImageFilter> input(SkOffsetImageFilter::Make(0, 0, nullptr, &cropRect));
- sk_sp<SkImageFilter> filter(SkBlurImageFilter::Create(0, 0, input.get(), &cropRect));
+ sk_sp<SkImageFilter> filter(SkBlurImageFilter::Make(0, 0, std::move(input), &cropRect));
sk_sp<SkSpecialSurface> surf(create_empty_special_surface(context, proxy, 10));
surf->getCanvas()->clear(SK_ColorGREEN);
@@ -742,21 +768,21 @@
}
}
-static SkImageFilter* makeBlur(SkImageFilter* input = nullptr) {
- return SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1, input);
+static sk_sp<SkImageFilter> make_blur(sk_sp<SkImageFilter> input) {
+ return SkBlurImageFilter::Make(SK_Scalar1, SK_Scalar1, std::move(input));
}
-static SkImageFilter* makeDropShadow(SkImageFilter* input = nullptr) {
- return SkDropShadowImageFilter::Create(
+static sk_sp<SkImageFilter> make_drop_shadow(sk_sp<SkImageFilter> input) {
+ return sk_sp<SkImageFilter>(SkDropShadowImageFilter::Create(
SkIntToScalar(100), SkIntToScalar(100),
SkIntToScalar(10), SkIntToScalar(10),
SK_ColorBLUE, SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
- input, nullptr);
+ input.get(), nullptr));
}
DEF_TEST(ImageFilterBlurThenShadowBounds, reporter) {
- SkAutoTUnref<SkImageFilter> filter1(makeBlur());
- SkAutoTUnref<SkImageFilter> filter2(makeDropShadow(filter1.get()));
+ sk_sp<SkImageFilter> filter1(make_blur(nullptr));
+ sk_sp<SkImageFilter> filter2(make_drop_shadow(std::move(filter1)));
SkIRect bounds = SkIRect::MakeXYWH(0, 0, 100, 100);
SkIRect expectedBounds = SkIRect::MakeXYWH(-133, -133, 236, 236);
@@ -766,8 +792,8 @@
}
DEF_TEST(ImageFilterShadowThenBlurBounds, reporter) {
- SkAutoTUnref<SkImageFilter> filter1(makeDropShadow());
- SkAutoTUnref<SkImageFilter> filter2(makeBlur(filter1.get()));
+ sk_sp<SkImageFilter> filter1(make_drop_shadow(nullptr));
+ sk_sp<SkImageFilter> filter2(make_blur(std::move(filter1)));
SkIRect bounds = SkIRect::MakeXYWH(0, 0, 100, 100);
SkIRect expectedBounds = SkIRect::MakeXYWH(-133, -133, 236, 236);
@@ -777,8 +803,8 @@
}
DEF_TEST(ImageFilterDilateThenBlurBounds, reporter) {
- SkAutoTUnref<SkImageFilter> filter1(SkDilateImageFilter::Create(2, 2));
- SkAutoTUnref<SkImageFilter> filter2(makeDropShadow(filter1.get()));
+ sk_sp<SkImageFilter> filter1(SkDilateImageFilter::Create(2, 2));
+ sk_sp<SkImageFilter> filter2(make_drop_shadow(std::move(filter1)));
SkIRect bounds = SkIRect::MakeXYWH(0, 0, 100, 100);
SkIRect expectedBounds = SkIRect::MakeXYWH(-132, -132, 234, 234);
@@ -788,8 +814,8 @@
}
DEF_TEST(ImageFilterComposedBlurFastBounds, reporter) {
- sk_sp<SkImageFilter> filter1(makeBlur());
- sk_sp<SkImageFilter> filter2(makeBlur());
+ sk_sp<SkImageFilter> filter1(make_blur(nullptr));
+ sk_sp<SkImageFilter> filter2(make_blur(nullptr));
sk_sp<SkImageFilter> composedFilter(SkComposeImageFilter::Make(std::move(filter1),
std::move(filter2)));
@@ -854,10 +880,9 @@
#endif
static void draw_blurred_rect(SkCanvas* canvas) {
- SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(SkIntToScalar(8), 0));
SkPaint filterPaint;
filterPaint.setColor(SK_ColorWHITE);
- filterPaint.setImageFilter(filter);
+ filterPaint.setImageFilter(SkBlurImageFilter::Make(SkIntToScalar(8), 0, nullptr));
canvas->saveLayer(nullptr, &filterPaint);
SkPaint whitePaint;
whitePaint.setColor(SK_ColorWHITE);
@@ -1172,10 +1197,10 @@
bitmap.eraseARGB(0, 0, 0, 0);
// Check that a blur with an insane radius does not crash or assert.
- SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(SkIntToScalar(1<<30), SkIntToScalar(1<<30)));
-
SkPaint paint;
- paint.setImageFilter(blur);
+ paint.setImageFilter(SkBlurImageFilter::Make(SkIntToScalar(1<<30),
+ SkIntToScalar(1<<30),
+ nullptr));
canvas->drawBitmap(bitmap, 0, 0, &paint);
}
@@ -1344,8 +1369,8 @@
SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(1, 0, 20, 20));
sk_sp<SkImageFilter> offsetFilter(SkOffsetImageFilter::Make(0, 0, nullptr, &cropRect));
- sk_sp<SkImageFilter> blurFilter(SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1,
- nullptr, &cropRect));
+ sk_sp<SkImageFilter> blurFilter(SkBlurImageFilter::Make(SK_Scalar1, SK_Scalar1,
+ nullptr, &cropRect));
sk_sp<SkImageFilter> composedFilter(SkComposeImageFilter::Make(std::move(blurFilter),
std::move(offsetFilter)));
SkIPoint offset;
@@ -1447,31 +1472,37 @@
location, SK_ColorGREEN, 0, 0));
REPORTER_ASSERT(reporter, !lighting->canComputeFastBounds());
- SkAutoTUnref<SkImageFilter> gray(make_grayscale(nullptr, nullptr));
- REPORTER_ASSERT(reporter, gray->canComputeFastBounds());
{
- SkColorFilter* grayCF;
- REPORTER_ASSERT(reporter, gray->asAColorFilter(&grayCF));
- REPORTER_ASSERT(reporter, !grayCF->affectsTransparentBlack());
- grayCF->unref();
+ sk_sp<SkImageFilter> gray(make_grayscale(nullptr, nullptr));
+ REPORTER_ASSERT(reporter, gray->canComputeFastBounds());
+ {
+ SkColorFilter* grayCF;
+ REPORTER_ASSERT(reporter, gray->asAColorFilter(&grayCF));
+ REPORTER_ASSERT(reporter, !grayCF->affectsTransparentBlack());
+ grayCF->unref();
+ }
+ REPORTER_ASSERT(reporter, gray->canComputeFastBounds());
+
+ sk_sp<SkImageFilter> grayBlur(SkBlurImageFilter::Make(SK_Scalar1, SK_Scalar1,
+ std::move(gray)));
+ REPORTER_ASSERT(reporter, grayBlur->canComputeFastBounds());
}
- REPORTER_ASSERT(reporter, gray->canComputeFastBounds());
- SkAutoTUnref<SkImageFilter> grayBlur(SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1, gray.get()));
- REPORTER_ASSERT(reporter, grayBlur->canComputeFastBounds());
+ {
+ SkScalar greenMatrix[20] = { 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1 };
+ sk_sp<SkColorFilter> greenCF(SkColorFilter::MakeMatrixFilterRowMajor255(greenMatrix));
+ sk_sp<SkImageFilter> green(SkColorFilterImageFilter::Create(greenCF.get()));
- SkScalar greenMatrix[20] = { 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 1,
- 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 1 };
- auto greenCF(SkColorFilter::MakeMatrixFilterRowMajor255(greenMatrix));
- SkAutoTUnref<SkImageFilter> green(SkColorFilterImageFilter::Create(greenCF.get()));
+ REPORTER_ASSERT(reporter, greenCF->affectsTransparentBlack());
+ REPORTER_ASSERT(reporter, !green->canComputeFastBounds());
- REPORTER_ASSERT(reporter, greenCF->affectsTransparentBlack());
- REPORTER_ASSERT(reporter, !green->canComputeFastBounds());
-
- SkAutoTUnref<SkImageFilter> greenBlur(SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1, green.get()));
- REPORTER_ASSERT(reporter, !greenBlur->canComputeFastBounds());
+ sk_sp<SkImageFilter> greenBlur(SkBlurImageFilter::Make(SK_Scalar1, SK_Scalar1,
+ std::move(green)));
+ REPORTER_ASSERT(reporter, !greenBlur->canComputeFastBounds());
+ }
uint8_t allOne[256], identity[256];
for (int i = 0; i < 256; ++i) {
@@ -1545,7 +1576,7 @@
return;
}
- sk_sp<SkImageFilter> blur(SkBlurImageFilter::Create(10.f, 10.f, largeSource.get()));
+ sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(10.f, 10.f, std::move(largeSource)));
if (!blur) {
ERRORF(reporter, "Failed to create SkBlurImageFilter.");
return;
diff --git a/tests/RecordOptsTest.cpp b/tests/RecordOptsTest.cpp
index 242712d..4341b87 100644
--- a/tests/RecordOptsTest.cpp
+++ b/tests/RecordOptsTest.cpp
@@ -188,8 +188,8 @@
REPORTER_ASSERT(r, drawRect->paint.getColor() == 0x03020202);
// saveLayer w/ backdrop should NOT go away
- SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(3, 3));
- recorder.saveLayer({ nullptr, nullptr, filter, 0});
+ sk_sp<SkImageFilter> filter(SkBlurImageFilter::Make(3, 3, nullptr));
+ recorder.saveLayer({ nullptr, nullptr, filter.get(), 0});
recorder.drawRect(draw, opaqueDrawPaint);
recorder.restore();
assert_savelayer_draw_restore(r, &record, 18, false);
@@ -244,7 +244,7 @@
int index = 0;
{
- SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(3, 3));
+ sk_sp<SkImageFilter> filter(SkBlurImageFilter::Make(3, 3, nullptr));
// first (null) should be optimized, 2nd should not
SkImageFilter* filters[] = { nullptr, filter.get() };