diff options
79 files changed, 455 insertions, 419 deletions
diff --git a/bench/BlurRoundRectBench.cpp b/bench/BlurRoundRectBench.cpp index 46f410d3b3..85852d581e 100644 --- a/bench/BlurRoundRectBench.cpp +++ b/bench/BlurRoundRectBench.cpp @@ -54,8 +54,9 @@ public: SkBlurMask::ConvertRadiusToSigma(SK_ScalarHalf), SkBlurMaskFilter::kHighQuality_BlurFlag); paint->setMaskFilter(maskFilter)->unref(); - paint->setColorFilter(SkColorFilter::MakeModeFilter(SK_ColorLTGRAY, - SkXfermode::kSrcIn_Mode)); + SkColorFilter* colorFilter = SkColorFilter::CreateModeFilter(SK_ColorLTGRAY, + SkXfermode::kSrcIn_Mode); + paint->setColorFilter(colorFilter)->unref(); paint->setColor(SK_ColorGRAY); } { diff --git a/bench/ColorCubeBench.cpp b/bench/ColorCubeBench.cpp index 6a7774012d..9f6bd001ff 100644 --- a/bench/ColorCubeBench.cpp +++ b/bench/ColorCubeBench.cpp @@ -13,14 +13,20 @@ class ColorCubeBench : public Benchmark { SkISize fSize; int fCubeDimension; - sk_sp<SkData> fCubeData; + SkData* fCubeData; SkBitmap fBitmap; public: - ColorCubeBench() : fCubeDimension(0) { + ColorCubeBench() + : fCubeDimension(0) + , fCubeData(nullptr) { fSize = SkISize::Make(2880, 1800); // 2014 Macbook Pro resolution } + ~ColorCubeBench() { + SkSafeUnref(fCubeData); + } + protected: const char* onGetName() override { return "colorcube"; @@ -65,7 +71,7 @@ private: void makeCubeData() { fCubeDimension = 32; - fCubeData = SkData::MakeUninitialized(sizeof(SkColor) * + fCubeData = SkData::NewUninitialized(sizeof(SkColor) * fCubeDimension * fCubeDimension * fCubeDimension); SkColor* pixels = (SkColor*)(fCubeData->writable_data()); SkAutoTMalloc<uint8_t> lutMemory(fCubeDimension); @@ -89,7 +95,9 @@ private: void test(int loops, SkCanvas* canvas) { SkPaint paint; for (int i = 0; i < loops; i++) { - paint.setColorFilter(SkColorCubeFilter::Make(fCubeData, fCubeDimension)); + SkAutoTUnref<SkColorFilter> colorCube( + SkColorCubeFilter::Create(fCubeData, fCubeDimension)); + paint.setColorFilter(colorCube); canvas->drawBitmap(fBitmap, 0, 0, &paint); } } diff --git a/bench/ColorFilterBench.cpp b/bench/ColorFilterBench.cpp index c4ba1e5dcb..5365a9c2ad 100644 --- a/bench/ColorFilterBench.cpp +++ b/bench/ColorFilterBench.cpp @@ -34,8 +34,8 @@ protected: 0, 1, 0, 0, amount255, 0, 0, 1, 0, amount255, 0, 0, 0, 1, 0 }; - auto filter(SkColorFilter::MakeMatrixFilterRowMajor255(matrix)); - return SkColorFilterImageFilter::Create(filter.get(), input); + SkAutoTUnref<SkColorFilter> filter(SkColorMatrixFilter::Create(matrix)); + return SkColorFilterImageFilter::Create(filter, input); } static SkImageFilter* make_grayscale(SkImageFilter* input = nullptr) { @@ -45,13 +45,14 @@ protected: 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); + SkAutoTUnref<SkColorFilter> filter(SkColorMatrixFilter::Create(matrix)); + return SkColorFilterImageFilter::Create(filter, input); } static SkImageFilter* make_mode_blue(SkImageFilter* input = nullptr) { - auto filter(SkColorFilter::MakeModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode)); - return SkColorFilterImageFilter::Create(filter.get(), input); + SkAutoTUnref<SkColorFilter> filter( + SkColorFilter::CreateModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode)); + return SkColorFilterImageFilter::Create(filter, input); } inline bool isSmall() const { return fIsSmall; } diff --git a/bench/ImageFilterCollapse.cpp b/bench/ImageFilterCollapse.cpp index cafcd38c6e..bd3f80fefb 100644 --- a/bench/ImageFilterCollapse.cpp +++ b/bench/ImageFilterCollapse.cpp @@ -28,12 +28,12 @@ public: } protected: - void doPreDraw(sk_sp<SkColorFilter> colorFilters[], int nFilters) { + void doPreDraw(SkColorFilter* colorFilters[], int nFilters) { // Create a chain of ImageFilters from colorFilters fImageFilter = nullptr; for(int i = nFilters; i --> 0;) { SkAutoTUnref<SkImageFilter> filter( - SkColorFilterImageFilter::Create(colorFilters[i].get(), fImageFilter, nullptr) + SkColorFilterImageFilter::Create(colorFilters[i], fImageFilter, nullptr) ); SkRefCnt_SafeAssign(fImageFilter, filter.get()); } @@ -73,12 +73,15 @@ private: }; class TableCollapseBench: public BaseImageFilterCollapseBench { +public: + virtual ~TableCollapseBench() {} + protected: - const char* onGetName() override { + virtual const char* onGetName() override { return "image_filter_collapse_table"; } - void onDelayedSetup() override { + virtual void onDelayedSetup() override { for (int i = 0; i < 256; ++i) { int n = i >> 5; table1[i] = (n << 5) | (n << 2) | (n >> 1); @@ -89,52 +92,63 @@ protected: table3[i] = static_cast<uint8_t>(sqrtf(fi) * 255); } - sk_sp<SkColorFilter> colorFilters[] = { - SkTableColorFilter::Make(table1), - SkTableColorFilter::Make(table2), - SkTableColorFilter::Make(table3), + SkColorFilter* colorFilters[] = { + SkTableColorFilter::Create(table1), + SkTableColorFilter::Create(table2), + SkTableColorFilter::Create(table3), }; doPreDraw(colorFilters, SK_ARRAY_COUNT(colorFilters)); + + for(unsigned i = 0; i < SK_ARRAY_COUNT(colorFilters); i++) { + colorFilters[i]->unref(); + } } private: uint8_t table1[256], table2[256], table3[256]; }; -static sk_sp<SkColorFilter> make_brightness(float amount) { +static SkColorFilter* make_brightness(float amount) { SkScalar amount255 = SkScalarMul(amount, SkIntToScalar(255)); SkScalar matrix[20] = { 1, 0, 0, 0, amount255, 0, 1, 0, 0, amount255, 0, 0, 1, 0, amount255, 0, 0, 0, 1, 0 }; - return SkColorFilter::MakeMatrixFilterRowMajor255(matrix); + return SkColorMatrixFilter::Create(matrix); } -static sk_sp<SkColorFilter> make_grayscale() { +static SkColorFilter* make_grayscale() { 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; - return SkColorFilter::MakeMatrixFilterRowMajor255(matrix); + return SkColorMatrixFilter::Create(matrix); } class MatrixCollapseBench: public BaseImageFilterCollapseBench { +public: + virtual ~MatrixCollapseBench() {} + protected: - const char* onGetName() override { + virtual const char* onGetName() override { return "image_filter_collapse_matrix"; } - void onDelayedSetup() override { - sk_sp<SkColorFilter> colorFilters[] = { + virtual void onDelayedSetup() override { + SkColorFilter* colorFilters[] = { make_brightness(0.1f), make_grayscale(), make_brightness(-0.1f), }; doPreDraw(colorFilters, SK_ARRAY_COUNT(colorFilters)); + + for(unsigned i = 0; i < SK_ARRAY_COUNT(colorFilters); i++) { + colorFilters[i]->unref(); + } } }; diff --git a/gm/blurredclippedcircle.cpp b/gm/blurredclippedcircle.cpp index 3bbff755e9..d1d374c7d4 100644 --- a/gm/blurredclippedcircle.cpp +++ b/gm/blurredclippedcircle.cpp @@ -67,9 +67,9 @@ protected: kNormal_SkBlurStyle, 1.366025f, SkBlurMaskFilter::kHighQuality_BlurFlag))->unref(); - paint.setColorFilter(SkColorFilter::MakeModeFilter( + paint.setColorFilter(SkColorFilter::CreateModeFilter( SK_ColorRED, - SkXfermode::kSrcIn_Mode)); + SkXfermode::kSrcIn_Mode))->unref(); paint.setAntiAlias(true); canvas->drawRRect(rr, paint); diff --git a/gm/blurroundrect.cpp b/gm/blurroundrect.cpp index 9135ba099f..fe4a939946 100644 --- a/gm/blurroundrect.cpp +++ b/gm/blurroundrect.cpp @@ -60,9 +60,10 @@ public: SkBlurMask::ConvertRadiusToSigma(SK_ScalarHalf), SkBlurMaskFilter::kHighQuality_BlurFlag); paint->setMaskFilter(maskFilter)->unref(); - paint->setColorFilter(SkColorFilter::MakeModeFilter( + SkColorFilter* colorFilter = SkColorFilter::CreateModeFilter( sk_tool_utils::color_to_565(SK_ColorLTGRAY), - SkXfermode::kSrcIn_Mode)); + SkXfermode::kSrcIn_Mode); + paint->setColorFilter(colorFilter)->unref(); paint->setColor(sk_tool_utils::color_to_565(SK_ColorGRAY)); } { diff --git a/gm/color4f.cpp b/gm/color4f.cpp index ec9bbcbfba..2d5b7d2c1a 100644 --- a/gm/color4f.cpp +++ b/gm/color4f.cpp @@ -22,43 +22,43 @@ static sk_sp<SkShader> make_alpha_color() { return SkShader::MakeColorShader(0x80FF0000); } -static sk_sp<SkColorFilter> make_cf_null() { +static SkColorFilter* make_cf_null() { return nullptr; } -static sk_sp<SkColorFilter> make_cf0() { +static SkColorFilter* make_cf0() { SkColorMatrix cm; cm.setSaturation(0.75f); - return SkColorFilter::MakeMatrixFilterRowMajor255(cm.fMat); + return SkColorMatrixFilter::Create(cm); } -static sk_sp<SkColorFilter> make_cf1() { +static SkColorFilter* make_cf1() { SkColorMatrix cm; cm.setSaturation(0.75f); - auto a(SkColorFilter::MakeMatrixFilterRowMajor255(cm.fMat)); + SkAutoTUnref<SkColorFilter> a(SkColorMatrixFilter::Create(cm)); // CreateComposedFilter will try to concat these two matrices, resulting in a single // filter (which is good for speed). For this test, we want to force a real compose of // these two, so our inner filter has a scale-up, which disables the optimization of // combining the two matrices. cm.setScale(1.1f, 0.9f, 1); - auto b(SkColorFilter::MakeMatrixFilterRowMajor255(cm.fMat)); - return SkColorFilter::MakeComposeFilter(a, b); + SkAutoTUnref<SkColorFilter> b(SkColorMatrixFilter::Create(cm)); + return SkColorFilter::CreateComposeFilter(a, b); } -static sk_sp<SkColorFilter> make_cf2() { - return SkColorFilter::MakeModeFilter(0x8044CC88, SkXfermode::kSrcATop_Mode); +static SkColorFilter* make_cf2() { + return SkColorFilter::CreateModeFilter(0x8044CC88, SkXfermode::kSrcATop_Mode); } static void draw_into_canvas(SkCanvas* canvas) { const SkRect r = SkRect::MakeWH(50, 100); sk_sp<SkShader> (*shaders[])() { make_opaque_color, make_alpha_color }; - sk_sp<SkColorFilter> (*filters[])() { make_cf_null, make_cf0, make_cf1, make_cf2 }; + SkColorFilter* (*filters[])() { make_cf_null, make_cf0, make_cf1, make_cf2 }; SkPaint paint; for (auto shProc : shaders) { paint.setShader(shProc()); for (auto cfProc : filters) { - paint.setColorFilter(cfProc()); + SkSafeUnref(paint.setColorFilter(cfProc())); canvas->drawRect(r, paint); canvas->translate(60, 0); } diff --git a/gm/colorcube.cpp b/gm/colorcube.cpp index 54e0688c6a..01aaf15610 100644 --- a/gm/colorcube.cpp +++ b/gm/colorcube.cpp @@ -25,12 +25,27 @@ static sk_sp<SkShader> MakeLinear() { class ColorCubeGM : public GM { public: - ColorCubeGM() : fInitialized(false) { + ColorCubeGM() + : fInitialized(false) + , f3DLut4(nullptr) + , f3DLut8(nullptr) + , f3DLut16(nullptr) + , f3DLut32(nullptr) + , f3DLut64(nullptr) + { this->setBGColor(0xFF000000); } + ~ColorCubeGM() { + SkSafeUnref(f3DLut4); + SkSafeUnref(f3DLut8); + SkSafeUnref(f3DLut16); + SkSafeUnref(f3DLut32); + SkSafeUnref(f3DLut64); + } + protected: - SkString onShortName() override { + virtual SkString onShortName() { return SkString("colorcube"); } @@ -52,8 +67,8 @@ protected: canvas.drawRect(SkRect::MakeWH(80, 80), paint); } - void make_3Dlut(sk_sp<SkData>* data, int size, bool invR, bool invG, bool invB) { - *data = SkData::MakeUninitialized(sizeof(SkColor) * size * size * size); + void make_3Dlut(SkData** data, int size, bool invR, bool invG, bool invB) { + *data = SkData::NewUninitialized(sizeof(SkColor) * size * size * size); SkColor* pixels = (SkColor*)((*data)->writable_data()); SkAutoTMalloc<uint8_t> lutMemory(size); SkAutoTMalloc<uint8_t> invLutMemory(size); @@ -77,11 +92,11 @@ protected: } } - SkISize onISize() override { + virtual SkISize onISize() { return SkISize::Make(500, 100); } - void onDraw(SkCanvas* canvas) override { + virtual void onDraw(SkCanvas* canvas) { if (!fInitialized) { this->make_bitmap(); this->make_3Dluts(); @@ -89,19 +104,19 @@ protected: } canvas->clear(0x00000000); SkPaint paint; - paint.setColorFilter(SkColorCubeFilter::Make(f3DLut4, 4)); + paint.setColorFilter(SkColorCubeFilter::Create(f3DLut4, 4))->unref(); canvas->drawBitmap(fBitmap, 10, 10, &paint); - paint.setColorFilter(SkColorCubeFilter::Make(f3DLut8, 8)); + paint.setColorFilter(SkColorCubeFilter::Create(f3DLut8, 8))->unref(); canvas->drawBitmap(fBitmap, 110, 10, &paint); - paint.setColorFilter(SkColorCubeFilter::Make(f3DLut16, 16)); + paint.setColorFilter(SkColorCubeFilter::Create(f3DLut16, 16))->unref(); canvas->drawBitmap(fBitmap, 210, 10, &paint); - paint.setColorFilter(SkColorCubeFilter::Make(f3DLut32, 32)); + paint.setColorFilter(SkColorCubeFilter::Create(f3DLut32, 32))->unref(); canvas->drawBitmap(fBitmap, 310, 10, &paint); - paint.setColorFilter(SkColorCubeFilter::Make(f3DLut64, 64)); + paint.setColorFilter(SkColorCubeFilter::Create(f3DLut64, 64))->unref(); canvas->drawBitmap(fBitmap, 410, 10, &paint); } @@ -109,11 +124,11 @@ private: typedef GM INHERITED; bool fInitialized; SkBitmap fBitmap; - sk_sp<SkData> f3DLut4; - sk_sp<SkData> f3DLut8; - sk_sp<SkData> f3DLut16; - sk_sp<SkData> f3DLut32; - sk_sp<SkData> f3DLut64; + SkData* f3DLut4; + SkData* f3DLut8; + SkData* f3DLut16; + SkData* f3DLut32; + SkData* f3DLut64; }; ////////////////////////////////////////////////////////////////////////////// diff --git a/gm/coloremoji.cpp b/gm/coloremoji.cpp index 4be8202d19..78c347c079 100644 --- a/gm/coloremoji.cpp +++ b/gm/coloremoji.cpp @@ -34,8 +34,8 @@ static SkImageFilter* make_grayscale(SkImageFilter* input = nullptr) { 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); + SkAutoTUnref<SkColorFilter> filter(SkColorMatrixFilter::Create(matrix)); + return SkColorFilterImageFilter::Create(filter, input); } static SkImageFilter* make_blur(float amount, SkImageFilter* input = nullptr) { diff --git a/gm/colorfilterimagefilter.cpp b/gm/colorfilterimagefilter.cpp index 497757e128..f72108f433 100644 --- a/gm/colorfilterimagefilter.cpp +++ b/gm/colorfilterimagefilter.cpp @@ -18,34 +18,34 @@ #define FILTER_HEIGHT SkIntToScalar(30) #define MARGIN SkIntToScalar(10) -static sk_sp<SkColorFilter> cf_make_brightness(float brightness) { +static SkColorFilter* cf_make_brightness(float brightness) { SkScalar amount255 = SkScalarMul(brightness, SkIntToScalar(255)); SkScalar matrix[20] = { 1, 0, 0, 0, amount255, 0, 1, 0, 0, amount255, 0, 0, 1, 0, amount255, 0, 0, 0, 1, 0 }; - return SkColorFilter::MakeMatrixFilterRowMajor255(matrix); + return SkColorMatrixFilter::Create(matrix); } -static sk_sp<SkColorFilter> cf_make_grayscale() { +static SkColorFilter* cf_make_grayscale() { 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; - return SkColorFilter::MakeMatrixFilterRowMajor255(matrix); + return SkColorMatrixFilter::Create(matrix); } -static sk_sp<SkColorFilter> cf_make_colorize(SkColor color) { - return SkColorFilter::MakeModeFilter(color, SkXfermode::kSrc_Mode); +static SkColorFilter* cf_make_colorize(SkColor color) { + return SkColorFilter::CreateModeFilter(color, SkXfermode::kSrc_Mode); } -static void sk_gm_get_colorfilters(SkTArray<sk_sp<SkColorFilter>>* array) { - array->push_back(cf_make_brightness(0.5f)); - array->push_back(cf_make_grayscale()); - array->push_back(cf_make_colorize(SK_ColorBLUE)); +static void sk_gm_get_colorfilters(SkTDArray<SkColorFilter*>* array) { + *array->append() = cf_make_brightness(0.5f); + *array->append() = cf_make_grayscale(); + *array->append() = cf_make_colorize(SK_ColorBLUE); } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -92,15 +92,18 @@ static SkImageFilter* make_blur(float amount, SkImageFilter* input = nullptr) { } static SkImageFilter* make_brightness(float amount, SkImageFilter* input = nullptr) { - return SkColorFilterImageFilter::Create(cf_make_brightness(amount).get(), input); + SkAutoTUnref<SkColorFilter> filter(cf_make_brightness(amount)); + return SkColorFilterImageFilter::Create(filter, input); } static SkImageFilter* make_grayscale(SkImageFilter* input = nullptr) { - return SkColorFilterImageFilter::Create(cf_make_grayscale().get(), input); + SkAutoTUnref<SkColorFilter> filter(cf_make_grayscale()); + return SkColorFilterImageFilter::Create(filter, input); } static SkImageFilter* make_mode_blue(SkImageFilter* input = nullptr) { - return SkColorFilterImageFilter::Create(cf_make_colorize(SK_ColorBLUE).get(), input); + SkAutoTUnref<SkColorFilter> filter(cf_make_colorize(SK_ColorBLUE)); + return SkColorFilterImageFilter::Create(filter, input); } static void drawClippedRect(SkCanvas* canvas, @@ -176,8 +179,8 @@ DEF_SIMPLE_GM(colorfilterimagefilter_layer, canvas, 32, 32) { SkAutoCanvasRestore autoCanvasRestore(canvas, false); SkColorMatrix cm; cm.setSaturation(0.0f); - auto cf(SkColorFilter::MakeMatrixFilterRowMajor255(cm.fMat)); - SkAutoTUnref<SkImageFilter> imf(SkColorFilterImageFilter::Create(cf.get())); + SkAutoTUnref<SkColorFilter> cf(SkColorMatrixFilter::Create(cm)); + SkAutoTUnref<SkImageFilter> imf(SkColorFilterImageFilter::Create(cf)); SkPaint p; p.setImageFilter(imf); canvas->saveLayer(NULL, &p); @@ -192,7 +195,7 @@ public: }; DEF_SIMPLE_GM(colorfiltershader, canvas, 800, 800) { - SkTArray<sk_sp<SkColorFilter>> filters; + SkTRefArray<SkColorFilter*> filters; sk_gm_get_colorfilters(&filters); SkTRefArray<SkShader*> shaders; @@ -207,7 +210,7 @@ DEF_SIMPLE_GM(colorfiltershader, canvas, 800, 800) { canvas->save(); for (int x = -1; x < filters.count(); ++x) { - sk_sp<SkColorFilter> filter = x >= 0 ? filters[x] : nullptr; + SkColorFilter* filter = x >= 0 ? filters[x] : nullptr; paint.setShader(shader->makeWithColorFilter(filter)); canvas->drawRect(r, paint); diff --git a/gm/colorfilters.cpp b/gm/colorfilters.cpp index 635298533b..eaee39dd55 100644 --- a/gm/colorfilters.cpp +++ b/gm/colorfilters.cpp @@ -30,7 +30,7 @@ static void install_nothing(SkPaint* paint, uint32_t, uint32_t) { } static void install_lighting(SkPaint* paint, uint32_t mul, uint32_t add) { - paint->setColorFilter(SkColorMatrixFilter::MakeLightingFilter(mul, add)); + paint->setColorFilter(SkColorMatrixFilter::CreateLightingFilter(mul, add))->unref(); } class ColorFiltersGM : public skiagm::GM { diff --git a/gm/colormatrix.cpp b/gm/colormatrix.cpp index 8ac15dba8e..de80ebb64b 100644 --- a/gm/colormatrix.cpp +++ b/gm/colormatrix.cpp @@ -14,11 +14,11 @@ #define HEIGHT 500 static void set_color_matrix(SkPaint* paint, const SkColorMatrix& matrix) { - paint->setColorFilter(SkColorFilter::MakeMatrixFilterRowMajor255(matrix.fMat)); + paint->setColorFilter(SkColorMatrixFilter::Create(matrix))->unref(); } static void set_array(SkPaint* paint, const SkScalar array[]) { - paint->setColorFilter(SkColorFilter::MakeMatrixFilterRowMajor255(array)); + paint->setColorFilter(SkColorMatrixFilter::Create(array))->unref(); } class ColorMatrixGM : public skiagm::GM { diff --git a/gm/dropshadowimagefilter.cpp b/gm/dropshadowimagefilter.cpp index 567ef803b5..512c82de01 100644 --- a/gm/dropshadowimagefilter.cpp +++ b/gm/dropshadowimagefilter.cpp @@ -93,7 +93,8 @@ protected: draw_bitmap, draw_path, draw_paint, draw_text }; - auto cf(SkColorFilter::MakeModeFilter(SK_ColorMAGENTA, SkXfermode::kSrcIn_Mode)); + SkAutoTUnref<SkColorFilter> cf( + SkColorFilter::CreateModeFilter(SK_ColorMAGENTA, SkXfermode::kSrcIn_Mode)); SkAutoTUnref<SkImageFilter> cfif(SkColorFilterImageFilter::Create(cf.get())); SkImageFilter::CropRect cropRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 44, 44)), SkImageFilter::CropRect::kHasAll_CropEdge); diff --git a/gm/emboss.cpp b/gm/emboss.cpp index 5773577389..20d3c91890 100644 --- a/gm/emboss.cpp +++ b/gm/emboss.cpp @@ -49,7 +49,7 @@ protected: // this combination of emboss+colorfilter used to crash -- so we exercise it to // confirm that we have a fix. - paint.setColorFilter(SkColorFilter::MakeModeFilter(0xFFFF0000, SkXfermode::kSrcATop_Mode)); + paint.setColorFilter(SkColorFilter::CreateModeFilter(0xFFFF0000, SkXfermode::kSrcATop_Mode))->unref(); canvas->translate(bm.width() + SkIntToScalar(10), 0); canvas->drawBitmap(bm, 10, 10, &paint); } diff --git a/gm/fadefilter.cpp b/gm/fadefilter.cpp index 386e32b098..6f64e1e30e 100644 --- a/gm/fadefilter.cpp +++ b/gm/fadefilter.cpp @@ -15,8 +15,10 @@ DEF_SIMPLE_GM(fadefilter, canvas, 256, 256) { 0, 1, 0, 0, 128.0f, 0, 0, 1, 0, 128.0f, 0, 0, 0, 1, 0 }; - auto colorFilter(SkColorFilter::MakeMatrixFilterRowMajor255(matrix)); - SkAutoTUnref<SkImageFilter> filter(SkColorFilterImageFilter::Create(colorFilter.get())); + SkAutoTUnref<SkColorFilter> colorFilter( + SkColorMatrixFilter::Create(matrix)); + SkAutoTUnref<SkImageFilter> filter( + SkColorFilterImageFilter::Create(colorFilter)); SkPaint layerPaint; layerPaint.setImageFilter(filter); canvas->drawRect(SkRect::MakeLTRB(64, 64, 192, 192), layerPaint); diff --git a/gm/imagefilters.cpp b/gm/imagefilters.cpp index 21ce0fef97..24a08ff865 100644 --- a/gm/imagefilters.cpp +++ b/gm/imagefilters.cpp @@ -140,7 +140,7 @@ static void draw_set(SkCanvas* canvas, SkImageFilter* filters[], int count) { DEF_SIMPLE_GM(savelayer_with_backdrop, canvas, 830, 550) { SkColorMatrix cm; cm.setSaturation(10); - auto cf(SkColorFilter::MakeMatrixFilterRowMajor255(cm.fMat)); + SkAutoTUnref<SkColorFilter> cf(SkColorMatrixFilter::Create(cm)); const SkScalar kernel[] = { 4, 0, 4, 0, -15, 0, 4, 0, 4 }; SkImageFilter* filters[] = { SkBlurImageFilter::Create(10, 10), @@ -148,7 +148,7 @@ DEF_SIMPLE_GM(savelayer_with_backdrop, canvas, 830, 550) { SkMatrixConvolutionImageFilter::Create({ 3, 3 }, kernel, 1, 0, { 0, 0 }, SkMatrixConvolutionImageFilter::kClampToBlack_TileMode, true), - SkColorFilterImageFilter::Create(cf.get()), + SkColorFilterImageFilter::Create(cf), }; const struct { diff --git a/gm/imagefiltersbase.cpp b/gm/imagefiltersbase.cpp index ca8a2d421a..a55328a999 100644 --- a/gm/imagefiltersbase.cpp +++ b/gm/imagefiltersbase.cpp @@ -192,16 +192,18 @@ protected: draw_bitmap, }; - auto cf = SkColorFilter::MakeModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode); + SkColorFilter* cf = SkColorFilter::CreateModeFilter(SK_ColorRED, + SkXfermode::kSrcIn_Mode); SkImageFilter* filters[] = { nullptr, IdentityImageFilter::Create(), FailImageFilter::Create(), - SkColorFilterImageFilter::Create(cf.get()), + SkColorFilterImageFilter::Create(cf), SkBlurImageFilter::Create(12.0f, 0.0f), SkDropShadowImageFilter::Create(10.0f, 5.0f, 3.0f, 3.0f, SK_ColorBLUE, SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode), }; + cf->unref(); SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64)); SkScalar MARGIN = SkIntToScalar(16); @@ -318,7 +320,7 @@ public: ImageFiltersText_CF() : ImageFiltersTextBaseGM("color") {} void installFilter(SkPaint* paint) override { - paint->setColorFilter(SkColorFilter::MakeModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode)); + paint->setColorFilter(SkColorFilter::CreateModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode))->unref(); } }; DEF_GM( return new ImageFiltersText_CF; ) diff --git a/gm/imagefilterscropexpand.cpp b/gm/imagefilterscropexpand.cpp index ada206cea4..f3ca4d32a6 100644 --- a/gm/imagefilterscropexpand.cpp +++ b/gm/imagefilterscropexpand.cpp @@ -40,6 +40,8 @@ protected: SkISize onISize() override { return SkISize::Make(730, 650); } void onDraw(SkCanvas* canvas) override { + SkAutoTUnref<SkColorFilter> cf( + SkColorFilter::CreateModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode)); SkImageFilter::CropRect cropRect( SkRect::Make(SkIRect::MakeXYWH(10, 10, 44, 44)), SkImageFilter::CropRect::kHasAll_CropEdge); @@ -57,7 +59,7 @@ protected: 0, 1, 0, 0, sk255, 0, 0, 1, 0, 0, 0, 0, 0, 0, sk255 }; - auto cfAlphaTrans(SkColorFilter::MakeMatrixFilterRowMajor255(matrix)); + SkAutoTUnref<SkColorFilter> cfAlphaTrans(SkColorMatrixFilter::Create(matrix)); SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64)); SkScalar MARGIN = SkIntToScalar(12); @@ -78,7 +80,7 @@ protected: SkImageFilter::CropRect bigRect(rect, SkImageFilter::CropRect::kHasAll_CropEdge); Draw(canvas, checkerboard, rect, SkColorFilterImageFilter::Create( - cfAlphaTrans.get(), noopCropped.get(), &bigRect)); + cfAlphaTrans, noopCropped.get(), &bigRect)); Draw(canvas, checkerboard, rect, SkBlurImageFilter::Create( 0.3f, 0.3f, noopCropped.get(), &bigRect)); diff --git a/gm/imagefilterscropped.cpp b/gm/imagefilterscropped.cpp index b06761d80c..d39e6b026a 100644 --- a/gm/imagefilterscropped.cpp +++ b/gm/imagefilterscropped.cpp @@ -115,7 +115,8 @@ protected: draw_bitmap, draw_path, draw_paint, draw_text }; - auto cf(SkColorFilter::MakeModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode)); + SkAutoTUnref<SkColorFilter> cf( + SkColorFilter::CreateModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode)); SkImageFilter::CropRect cropRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 44, 44)), SkImageFilter::CropRect::kHasAll_CropEdge); SkImageFilter::CropRect bogusRect(SkRect::Make(SkIRect::MakeXYWH(-100, -100, 10, 10)), SkImageFilter::CropRect::kHasAll_CropEdge); diff --git a/gm/imagefiltersgraph.cpp b/gm/imagefiltersgraph.cpp index 547a3bbbe2..fa9c512591 100644 --- a/gm/imagefiltersgraph.cpp +++ b/gm/imagefiltersgraph.cpp @@ -119,10 +119,11 @@ protected: canvas->clear(SK_ColorBLACK); { SkAutoTUnref<SkImageFilter> bitmapSource(SkImageSource::Create(fImage.get())); - auto cf(SkColorFilter::MakeModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode)); + SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED, + SkXfermode::kSrcIn_Mode)); SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(4.0f, 4.0f, bitmapSource)); SkAutoTUnref<SkImageFilter> erode(SkErodeImageFilter::Create(4, 4, blur)); - SkAutoTUnref<SkImageFilter> color(SkColorFilterImageFilter::Create(cf.get(), erode)); + SkAutoTUnref<SkImageFilter> color(SkColorFilterImageFilter::Create(cf, erode)); SkAutoTUnref<SkImageFilter> merge(SkMergeImageFilter::Create(blur, color)); SkPaint paint; @@ -138,8 +139,8 @@ protected: 0, 0, SK_Scalar1, 0, 0, 0, 0, 0, 0.5f, 0 }; - auto matrixFilter(SkColorFilter::MakeMatrixFilterRowMajor255(matrix)); - SkAutoTUnref<SkImageFilter> colorMorph(SkColorFilterImageFilter::Create(matrixFilter.get(), morph)); + SkAutoTUnref<SkColorFilter> matrixFilter(SkColorMatrixFilter::Create(matrix)); + SkAutoTUnref<SkImageFilter> colorMorph(SkColorFilterImageFilter::Create(matrixFilter, morph)); SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kSrcOver_Mode)); SkAutoTUnref<SkImageFilter> blendColor(SkXfermodeImageFilter::Create(mode, colorMorph)); @@ -153,8 +154,8 @@ protected: 0, SK_Scalar1, 0, 0, 0, 0, 0, SK_Scalar1, 0, 0, 0, 0, 0, 0.5f, 0 }; - auto matrixCF(SkColorFilter::MakeMatrixFilterRowMajor255(matrix)); - SkAutoTUnref<SkImageFilter> matrixFilter(SkColorFilterImageFilter::Create(matrixCF.get())); + SkAutoTUnref<SkColorFilter> matrixCF(SkColorMatrixFilter::Create(matrix)); + SkAutoTUnref<SkImageFilter> matrixFilter(SkColorFilterImageFilter::Create(matrixCF)); SkAutoTUnref<SkImageFilter> offsetFilter( SimpleOffsetFilter::Create(10.0f, 10.f, matrixFilter)); @@ -217,14 +218,16 @@ protected: } { // Test that crop offsets are absolute, not relative to the parent's crop rect. - auto cf1(SkColorFilter::MakeModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode)); - auto cf2(SkColorFilter::MakeModeFilter(SK_ColorGREEN, SkXfermode::kSrcIn_Mode)); + SkAutoTUnref<SkColorFilter> cf1(SkColorFilter::CreateModeFilter(SK_ColorBLUE, + SkXfermode::kSrcIn_Mode)); + SkAutoTUnref<SkColorFilter> cf2(SkColorFilter::CreateModeFilter(SK_ColorGREEN, + SkXfermode::kSrcIn_Mode)); SkImageFilter::CropRect outerRect(SkRect::MakeXYWH(SkIntToScalar(10), SkIntToScalar(10), SkIntToScalar(80), SkIntToScalar(80))); SkImageFilter::CropRect innerRect(SkRect::MakeXYWH(SkIntToScalar(20), SkIntToScalar(20), SkIntToScalar(60), SkIntToScalar(60))); - SkAutoTUnref<SkImageFilter> color1(SkColorFilterImageFilter::Create(cf1.get(), nullptr, &outerRect)); - SkAutoTUnref<SkImageFilter> color2(SkColorFilterImageFilter::Create(cf2.get(), color1, &innerRect)); + SkAutoTUnref<SkImageFilter> color1(SkColorFilterImageFilter::Create(cf1, nullptr, &outerRect)); + SkAutoTUnref<SkImageFilter> color2(SkColorFilterImageFilter::Create(cf2, color1, &innerRect)); SkPaint paint; paint.setImageFilter(color2); diff --git a/gm/lumafilter.cpp b/gm/lumafilter.cpp index 10eefabd56..adffd008c1 100644 --- a/gm/lumafilter.cpp +++ b/gm/lumafilter.cpp @@ -26,7 +26,7 @@ static void draw_label(SkCanvas* canvas, const char* label, paint); } -static void draw_scene(SkCanvas* canvas, const sk_sp<SkColorFilter>& filter, SkXfermode::Mode mode, +static void draw_scene(SkCanvas* canvas, SkColorFilter* filter, SkXfermode::Mode mode, const sk_sp<SkShader>& s1, const sk_sp<SkShader>& s2) { SkPaint paint; paint.setAntiAlias(true); @@ -83,7 +83,7 @@ public: SkPoint g2Points[] = { { 0, 0 }, { kSize, 0 } }; SkScalar pos[] = { 0.2f, 1.0f }; - fFilter = SkLumaColorFilter::Make(); + fFilter.reset(SkLumaColorFilter::Create()); fGr1 = SkGradientShader::MakeLinear(g1Points, g1Colors, pos, SK_ARRAY_COUNT(g1Colors), SkShader::kClamp_TileMode); fGr2 = SkGradientShader::MakeLinear(g2Points, g2Colors, pos, SK_ARRAY_COUNT(g2Colors), @@ -137,8 +137,8 @@ protected: } private: - sk_sp<SkColorFilter> fFilter; - sk_sp<SkShader> fGr1, fGr2; + SkAutoTUnref<SkColorFilter> fFilter; + sk_sp<SkShader> fGr1, fGr2; typedef skiagm::GM INHERITED; }; diff --git a/gm/megalooper.cpp b/gm/megalooper.cpp index 6f5640272f..5fe9af298b 100644 --- a/gm/megalooper.cpp +++ b/gm/megalooper.cpp @@ -175,7 +175,8 @@ private: paint->setMaskFilter(this->createBlur())->unref(); - paint->setColorFilter(SkColorFilter::MakeModeFilter(color, SkXfermode::kSrcIn_Mode)); + SkColorFilter* cf = SkColorFilter::CreateModeFilter(color, SkXfermode::kSrcIn_Mode); + paint->setColorFilter(cf)->unref(); return looperBuilder.detach(); } @@ -221,8 +222,8 @@ private: paint->setMaskFilter(this->createBlur())->unref(); - paint->setColorFilter(SkColorFilter::MakeModeFilter(gColors[i], - SkXfermode::kSrcIn_Mode)); + SkColorFilter* cf = SkColorFilter::CreateModeFilter(gColors[i], SkXfermode::kSrcIn_Mode); + paint->setColorFilter(cf)->unref(); } return looperBuilder.detach(); diff --git a/gm/modecolorfilters.cpp b/gm/modecolorfilters.cpp index 4e5d45cf96..de6a18a41c 100644 --- a/gm/modecolorfilters.cpp +++ b/gm/modecolorfilters.cpp @@ -121,7 +121,9 @@ protected: static const int kRectsPerRow = SkMax32(this->getISize().fWidth / kRectWidth, 1); for (size_t cfm = 0; cfm < SK_ARRAY_COUNT(modes); ++cfm) { for (size_t cfc = 0; cfc < SK_ARRAY_COUNT(colors); ++cfc) { - paint.setColorFilter(SkColorFilter::MakeModeFilter(colors[cfc], modes[cfm])); + SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(colors[cfc], + modes[cfm])); + paint.setColorFilter(cf); for (size_t s = 0; s < SK_ARRAY_COUNT(shaders); ++s) { paint.setShader(shaders[s]); bool hasShader = nullptr == paint.getShader(); diff --git a/gm/multipicturedraw.cpp b/gm/multipicturedraw.cpp index a4b09b2c2f..1f302ee57a 100644 --- a/gm/multipicturedraw.cpp +++ b/gm/multipicturedraw.cpp @@ -420,7 +420,7 @@ static void tiled(SkCanvas* finalCanvas, SkMultiPictureDraw* mpd, step.fY = SkIntToScalar(y*kTileHeight); step.fPaint = new SkPaint; step.fPaint->setColorFilter( - SkColorFilter::MakeModeFilter(colors[x][y], SkXfermode::kModulate_Mode)); + SkColorFilter::CreateModeFilter(colors[x][y], SkXfermode::kModulate_Mode))->unref(); step.fSurf = create_compat_surface(finalCanvas, kTileWidth, kTileHeight); diff --git a/gm/recordopts.cpp b/gm/recordopts.cpp index bac6d8858c..97d13cb9c9 100644 --- a/gm/recordopts.cpp +++ b/gm/recordopts.cpp @@ -22,26 +22,26 @@ static const int kDetectorGreenValue = 50; // kDetectorGreenValue and then the incorrect value is observable by some part of the drawing // pipeline, that pixel will remain empty. -static sk_sp<SkColorFilter> make_detector_color_filter() { +static SkColorFilter* make_detector_color_filter() { uint8_t tableA[256] = { 0, }; uint8_t tableR[256] = { 0, }; uint8_t tableG[256] = { 0, }; uint8_t tableB[256] = { 0, }; tableA[255] = 255; tableG[kDetectorGreenValue] = 255; - return SkTableColorFilter::MakeARGB(tableA, tableR, tableG, tableB); + return SkTableColorFilter::CreateARGB(tableA, tableR, tableG, tableB); } // This detector detects that color filter phase of the pixel pipeline receives the correct value. static void install_detector_color_filter(SkPaint* drawPaint) { - drawPaint->setColorFilter(make_detector_color_filter()); + drawPaint->setColorFilter(make_detector_color_filter())->unref(); } // This detector detects that image filter phase of the pixel pipeline receives the correct value. static void install_detector_image_filter(SkPaint* drawPaint) { - auto colorFilter(make_detector_color_filter()); + SkAutoTUnref<SkColorFilter> colorFilter(make_detector_color_filter()); SkImageFilter* imageFilter = - SkColorFilterImageFilter::Create(colorFilter.get(), drawPaint->getImageFilter()); + SkColorFilterImageFilter::Create(colorFilter, drawPaint->getImageFilter()); drawPaint->setImageFilter(imageFilter)->unref(); } diff --git a/gm/skbug1719.cpp b/gm/skbug1719.cpp index 3358de5525..23c0c5fec0 100644 --- a/gm/skbug1719.cpp +++ b/gm/skbug1719.cpp @@ -64,7 +64,8 @@ DEF_SIMPLE_GM_BG(skbug1719, canvas, 300, 100, SkBlurMaskFilter::Create(kNormal_SkBlurStyle, 0.78867501f, SkBlurMaskFilter::kHighQuality_BlurFlag))->unref(); - paint.setColorFilter(SkColorFilter::MakeModeFilter(0xBFFFFFFF, SkXfermode::kSrcIn_Mode)); + paint.setColorFilter( + SkColorFilter::CreateModeFilter(0xBFFFFFFF, SkXfermode::kSrcIn_Mode))->unref(); canvas->clipPath(clipPath, SkRegion::kIntersect_Op, true); canvas->drawPath(drawPath, paint); diff --git a/gm/tablecolorfilter.cpp b/gm/tablecolorfilter.cpp index c9ca474e76..dcc29f37cf 100644 --- a/gm/tablecolorfilter.cpp +++ b/gm/tablecolorfilter.cpp @@ -73,27 +73,27 @@ static void make_table2(uint8_t table[]) { } } -static sk_sp<SkColorFilter> make_null_cf() { +static SkColorFilter* make_null_cf() { return nullptr; } -static sk_sp<SkColorFilter> make_cf0() { +static SkColorFilter* make_cf0() { uint8_t table[256]; make_table0(table); - return SkTableColorFilter::Make(table); + return SkTableColorFilter::Create(table); } -static sk_sp<SkColorFilter> make_cf1() { +static SkColorFilter* make_cf1() { uint8_t table[256]; make_table1(table); - return SkTableColorFilter::Make(table); + return SkTableColorFilter::Create(table); } -static sk_sp<SkColorFilter> make_cf2() { +static SkColorFilter* make_cf2() { uint8_t table[256]; make_table2(table); - return SkTableColorFilter::Make(table); + return SkTableColorFilter::Create(table); } -static sk_sp<SkColorFilter> make_cf3() { +static SkColorFilter* make_cf3() { uint8_t table0[256]; make_table0(table0); uint8_t table1[256]; make_table1(table1); uint8_t table2[256]; make_table2(table2); - return SkTableColorFilter::MakeARGB(nullptr, table0, table1, table2); + return SkTableColorFilter::CreateARGB(nullptr, table0, table1, table2); } class TableColorFilterGM : public skiagm::GM { @@ -114,9 +114,8 @@ protected: canvas->translate(20, 20); - static sk_sp<SkColorFilter> (*gColorFilterMakers[])() = { - make_null_cf, make_cf0, make_cf1, make_cf2, make_cf3 - }; + static SkColorFilter* (*gColorFilterMakers[])() = { make_null_cf, make_cf0, make_cf1, + make_cf2, make_cf3 }; static void (*gBitmapMakers[])(SkBitmap*) = { make_bm0, make_bm1 }; // This test will be done once for each bitmap with the results stacked vertically. @@ -156,25 +155,25 @@ protected: // each draw being at xOffset of the previous one for (unsigned i = 1; i < SK_ARRAY_COUNT(gColorFilterMakers); ++i) { x += xOffset; - paint.setColorFilter(gColorFilterMakers[i]()); + paint.setColorFilter(gColorFilterMakers[i]())->unref(); canvas->drawBitmap(bm, x, y, &paint); } paint.setColorFilter(nullptr); for (unsigned i = 0; i < SK_ARRAY_COUNT(gColorFilterMakers); ++i) { - auto colorFilter1(gColorFilterMakers[i]()); + SkAutoTUnref<SkColorFilter> colorFilter1(gColorFilterMakers[i]()); SkAutoTUnref<SkImageFilter> imageFilter1(SkColorFilterImageFilter::Create( - colorFilter1.get(), nullptr, nullptr)); + colorFilter1, nullptr, nullptr)); // Move down to the next line and draw it // each draw being at xOffset of the previous one y += yOffset; x = 0; for (unsigned j = 1; j < SK_ARRAY_COUNT(gColorFilterMakers); ++j) { - auto colorFilter2(gColorFilterMakers[j]()); + SkAutoTUnref<SkColorFilter> colorFilter2(gColorFilterMakers[j]()); SkAutoTUnref<SkImageFilter> imageFilter2(SkColorFilterImageFilter::Create( - colorFilter2.get(), imageFilter1, nullptr)); + colorFilter2, imageFilter1, nullptr)); paint.setImageFilter(imageFilter2); canvas->drawBitmap(bm, x, y, &paint); x += xOffset; @@ -226,11 +225,11 @@ protected: canvas->drawColor(sk_tool_utils::color_to_565(0xFFDDDDDD)); const int MODES = MODE_COUNT * COLOR_COUNT; - sk_sp<SkColorFilter> filters[MODES]; + SkAutoTUnref<SkColorFilter> filters[MODES]; int index = 0; for (int i = 0; i < MODE_COUNT; ++i) { for (int j = 0; j < COLOR_COUNT; ++j) { - filters[index++] = SkColorFilter::MakeModeFilter(fColors[j], fModes[i]); + filters[index++].reset(SkColorFilter::CreateModeFilter(fColors[j], fModes[i])); } } @@ -262,7 +261,9 @@ protected: for (int y = 0; y < MODES; ++y) { canvas->save(); for (int x = 0; x < MODES; ++x) { - paint.setColorFilter(SkColorFilter::MakeComposeFilter(filters[y], filters[x])); + SkAutoTUnref<SkColorFilter> compose(SkColorFilter::CreateComposeFilter(filters[y], + filters[x])); + paint.setColorFilter(compose); canvas->drawRect(r, paint); canvas->translate(r.width() + spacer, 0); } diff --git a/gm/testimagefilters.cpp b/gm/testimagefilters.cpp index 465d606e2b..1ea9575c7c 100644 --- a/gm/testimagefilters.cpp +++ b/gm/testimagefilters.cpp @@ -24,8 +24,10 @@ static SkImageFilter* make0() { return SkDownSampleImageFilter::Create(SK_Scalar1 / 5); } static SkImageFilter* make1() { return SkOffsetImageFilter::Create(SkIntToScalar(16), SkIntToScalar(16)); } static SkImageFilter* make2() { - auto cf = SkColorFilter::MakeModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode); - return SkColorFilterImageFilter::Create(cf.get()); + SkColorFilter* cf = SkColorFilter::CreateModeFilter(SK_ColorBLUE, + SkXfermode::kSrcIn_Mode); + SkAutoUnref aur(cf); + return SkColorFilterImageFilter::Create(cf); } static SkImageFilter* make3() { return SkBlurImageFilter::Create(8, 0); @@ -54,8 +56,10 @@ static SkImageFilter* make6() { SkImageFilter* compose = SkComposeImageFilter::Create(outer, inner); SkAutoUnref aur2(compose); - auto cf = SkColorFilter::MakeModeFilter(0x880000FF, SkXfermode::kSrcIn_Mode); - SkImageFilter* blue = SkColorFilterImageFilter::Create(cf.get()); + SkColorFilter* cf = SkColorFilter::CreateModeFilter(0x880000FF, + SkXfermode::kSrcIn_Mode); + SkAutoUnref aur3(cf); + SkImageFilter* blue = SkColorFilterImageFilter::Create(cf); SkAutoUnref aur4(blue); return SkMergeImageFilter::Create(compose, blue); @@ -69,8 +73,10 @@ static SkImageFilter* make7() { SkImageFilter* compose = SkComposeImageFilter::Create(outer, inner); SkAutoUnref aur2(compose); - auto cf = SkColorFilter::MakeModeFilter(0x880000FF, SkXfermode::kSrcIn_Mode); - SkImageFilter* blue = SkColorFilterImageFilter::Create(cf.get()); + SkColorFilter* cf = SkColorFilter::CreateModeFilter(0x880000FF, + SkXfermode::kSrcIn_Mode); + SkAutoUnref aur3(cf); + SkImageFilter* blue = SkColorFilterImageFilter::Create(cf); SkAutoUnref aur4(blue); return SkMergeImageFilter::Create(compose, blue); diff --git a/gm/textbloblooper.cpp b/gm/textbloblooper.cpp index ac8b7c9759..d9701131a4 100644 --- a/gm/textbloblooper.cpp +++ b/gm/textbloblooper.cpp @@ -97,7 +97,7 @@ static void color_filter(SkPaint* paint) { SkRect r; r.setWH(SkIntToScalar(kWidth), 50); paint->setShader(make_shader(r)); - paint->setColorFilter(SkColorMatrixFilter::MakeLightingFilter(0xF0F0F0, 0)); + paint->setColorFilter(SkColorMatrixFilter::CreateLightingFilter(0xF0F0F0, 0))->unref(); } static void kitchen_sink(SkPaint* paint) { diff --git a/gm/tileimagefilter.cpp b/gm/tileimagefilter.cpp index f75e7f9722..cf8825e5bb 100644 --- a/gm/tileimagefilter.cpp +++ b/gm/tileimagefilter.cpp @@ -93,9 +93,9 @@ protected: SkRect dstRect = SkRect::MakeWH(SkIntToScalar(fBitmap->width() * 2), SkIntToScalar(fBitmap->height() * 2)); SkAutoTUnref<SkImageFilter> tile(SkTileImageFilter::Create(srcRect, dstRect, nullptr)); - auto cf(SkColorFilter::MakeMatrixFilterRowMajor255(matrix)); + SkAutoTUnref<SkColorFilter> cf(SkColorMatrixFilter::Create(matrix)); - SkAutoTUnref<SkImageFilter> cfif(SkColorFilterImageFilter::Create(cf.get(), tile.get())); + SkAutoTUnref<SkImageFilter> cfif(SkColorFilterImageFilter::Create(cf, tile.get())); SkPaint paint; paint.setImageFilter(cfif); canvas->save(); diff --git a/gm/vertices.cpp b/gm/vertices.cpp index 9c4ccc16bb..177dc43c2b 100644 --- a/gm/vertices.cpp +++ b/gm/vertices.cpp @@ -26,17 +26,17 @@ static sk_sp<SkShader> make_shader2() { return SkShader::MakeColorShader(SK_ColorBLUE); } -static sk_sp<SkColorFilter> make_color_filter() { - return SkColorFilter::MakeModeFilter(0xFFAABBCC, SkXfermode::kDarken_Mode); +static SkColorFilter* make_color_filter() { + return SkColorFilter::CreateModeFilter(0xFFAABBCC, SkXfermode::kDarken_Mode); } class VerticesGM : public skiagm::GM { - SkPoint fPts[9]; - SkPoint fTexs[9]; - SkColor fColors[9]; - sk_sp<SkShader> fShader1; - sk_sp<SkShader> fShader2; - sk_sp<SkColorFilter> fColorFilter; + SkPoint fPts[9]; + SkPoint fTexs[9]; + SkColor fColors[9]; + sk_sp<SkShader> fShader1; + sk_sp<SkShader> fShader2; + SkAutoTUnref<SkColorFilter> fColorFilter; public: VerticesGM() {} @@ -60,7 +60,7 @@ protected: fShader1 = make_shader1(w, h); fShader2 = make_shader2(); - fColorFilter = make_color_filter(); + fColorFilter.reset(make_color_filter()); SkRandom rand; for (size_t i = 0; i < SK_ARRAY_COUNT(fColors); ++i) { @@ -85,11 +85,11 @@ protected: }; const struct { - const SkColor* fColors; - const SkPoint* fTexs; - const sk_sp<SkShader>& fShader; - const sk_sp<SkColorFilter>& fColorFilter; - uint8_t fAlpha; + const SkColor* fColors; + const SkPoint* fTexs; + const sk_sp<SkShader>& fShader; + SkColorFilter* fColorFilter; + uint8_t fAlpha; } rec[] = { { fColors, nullptr, fShader1, nullptr , 0xFF }, { nullptr, fTexs , fShader1, nullptr , 0xFF }, diff --git a/gyp/skia_for_android_framework_defines.gypi b/gyp/skia_for_android_framework_defines.gypi index a76108416b..8660475463 100644 --- a/gyp/skia_for_android_framework_defines.gypi +++ b/gyp/skia_for_android_framework_defines.gypi @@ -16,7 +16,6 @@ 'SK_SUPPORT_LEGACY_UNBALANCED_PIXELREF_LOCKCOUNT', # Needed until we fix https://bug.skia.org/2440 . 'SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG', - 'SK_SUPPORT_LEGACY_COLORFILTER_PTR', 'SK_IGNORE_LINEONLY_AA_CONVEX_PATH_OPTS', 'SK_SUPPORT_LEGACY_MINOR_EFFECT_PTR', 'SK_SUPPORT_LEGACY_GRADIENT_DITHERING', diff --git a/include/core/SkColorFilter.h b/include/core/SkColorFilter.h index 7ac335fb10..4c9795c271 100644 --- a/include/core/SkColorFilter.h +++ b/include/core/SkColorFilter.h @@ -86,7 +86,7 @@ public: * * e.g. result(color) == this_filter(inner(color)) */ - virtual sk_sp<SkColorFilter> makeComposed(sk_sp<SkColorFilter>) const { return nullptr; } + virtual SkColorFilter* newComposed(const SkColorFilter* /*inner*/) const { return NULL; } /** * Apply this colorfilter to the specified SkColor. This routine handles @@ -110,7 +110,7 @@ public: @return colorfilter object that applies the src color and mode, or NULL if the mode will have no effect. */ - static sk_sp<SkColorFilter> MakeModeFilter(SkColor c, SkXfermode::Mode mode); + static SkColorFilter* CreateModeFilter(SkColor c, SkXfermode::Mode mode); /** Construct a colorfilter whose effect is to first apply the inner filter and then apply * the outer filter to the result of the inner's. @@ -119,28 +119,12 @@ public: * Due to internal limits, it is possible that this will return NULL, so the caller must * always check. */ - static sk_sp<SkColorFilter> MakeComposeFilter(sk_sp<SkColorFilter> outer, - sk_sp<SkColorFilter> inner); + static SkColorFilter* CreateComposeFilter(SkColorFilter* outer, SkColorFilter* inner); /** Construct a color filter that transforms a color by a 4x5 matrix. The matrix is in row- * major order and the translation column is specified in unnormalized, 0...255, space. */ - static sk_sp<SkColorFilter> MakeMatrixFilterRowMajor255(const SkScalar array[20]); - -#ifdef SK_SUPPORT_LEGACY_COLORFILTER_PTR - static SkColorFilter* CreateModeFilter(SkColor c, SkXfermode::Mode mode) { - return MakeModeFilter(c, mode).release(); - } - static SkColorFilter* CreateComposeFilter(SkColorFilter* outer, SkColorFilter* inner) { - return MakeComposeFilter(sk_ref_sp(outer), sk_ref_sp(inner)).release(); - } - static SkColorFilter* CreateMatrixFilterRowMajor255(const SkScalar array[20]) { - return MakeMatrixFilterRowMajor255(array).release(); - } - virtual SkColorFilter* newComposed(const SkColorFilter* inner) const { - return this->makeComposed(sk_ref_sp(const_cast<SkColorFilter*>(inner))).release(); - } -#endif + static SkColorFilter* CreateMatrixFilterRowMajor255(const SkScalar array[20]); /** * A subclass may implement this factory function to work with the GPU backend. It returns diff --git a/include/core/SkPaint.h b/include/core/SkPaint.h index 21d7109cbb..f5c3bc3d4b 100644 --- a/include/core/SkPaint.h +++ b/include/core/SkPaint.h @@ -515,9 +515,7 @@ public: @param filter May be NULL. The filter to be installed in the paint @return filter */ -#ifdef SK_SUPPORT_LEGACY_COLORFILTER_PTR SkColorFilter* setColorFilter(SkColorFilter* filter); -#endif void setColorFilter(sk_sp<SkColorFilter>); /** Get the paint's xfermode object. diff --git a/include/core/SkShader.h b/include/core/SkShader.h index 44235adc28..c9c760d06d 100644 --- a/include/core/SkShader.h +++ b/include/core/SkShader.h @@ -359,7 +359,7 @@ public: * Create a new shader that produces the same colors as invoking this shader and then applying * the colorfilter. */ - sk_sp<SkShader> makeWithColorFilter(sk_sp<SkColorFilter>) const; + sk_sp<SkShader> makeWithColorFilter(SkColorFilter*) const; ////////////////////////////////////////////////////////////////////////// // Factory methods for stock shaders diff --git a/include/effects/SkBlurDrawLooper.h b/include/effects/SkBlurDrawLooper.h index 49b0c51f25..0371700ba4 100644 --- a/include/effects/SkBlurDrawLooper.h +++ b/include/effects/SkBlurDrawLooper.h @@ -65,7 +65,7 @@ protected: private: SkMaskFilter* fBlur; - sk_sp<SkColorFilter> fColorFilter; + SkColorFilter* fColorFilter; SkScalar fDx, fDy, fSigma; SkColor fBlurColor; uint32_t fBlurFlags; diff --git a/include/effects/SkColorCubeFilter.h b/include/effects/SkColorCubeFilter.h index 8b621292b0..8d63667c32 100644 --- a/include/effects/SkColorCubeFilter.h +++ b/include/effects/SkColorCubeFilter.h @@ -20,11 +20,7 @@ public: * This cube contains a transform where (x,y,z) maps to the (r,g,b). * The alpha components of the colors must be 0xFF. */ - static sk_sp<SkColorFilter> Make(sk_sp<SkData> cubeData, int cubeDimension); - -#ifdef SK_SUPPORT_LEGACY_COLORFILTER_PTR static SkColorFilter* Create(SkData* cubeData, int cubeDimension); -#endif void filterSpan(const SkPMColor src[], int count, SkPMColor[]) const override; uint32_t getFlags() const override; @@ -37,7 +33,7 @@ public: SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkColorCubeFilter) protected: - SkColorCubeFilter(sk_sp<SkData> cubeData, int cubeDimension); + SkColorCubeFilter(SkData* cubeData, int cubeDimension); void flatten(SkWriteBuffer&) const override; private: diff --git a/include/effects/SkColorFilterImageFilter.h b/include/effects/SkColorFilterImageFilter.h index c34e9ced59..6dd9df2495 100644 --- a/include/effects/SkColorFilterImageFilter.h +++ b/include/effects/SkColorFilterImageFilter.h @@ -31,8 +31,9 @@ private: SkColorFilterImageFilter(SkColorFilter* cf, SkImageFilter* input, const CropRect* cropRect); + virtual ~SkColorFilterImageFilter(); - sk_sp<SkColorFilter> fColorFilter; + SkColorFilter* fColorFilter; typedef SkImageFilter INHERITED; }; diff --git a/include/effects/SkColorMatrixFilter.h b/include/effects/SkColorMatrixFilter.h index 6e74bee315..d71d2ed533 100644 --- a/include/effects/SkColorMatrixFilter.h +++ b/include/effects/SkColorMatrixFilter.h @@ -13,25 +13,20 @@ class SK_API SkColorMatrixFilter : public SkColorFilter { public: + static SkColorFilter* Create(const SkColorMatrix& cm) { + return SkColorFilter::CreateMatrixFilterRowMajor255(cm.fMat); + } + static SkColorFilter* Create(const SkScalar array[20]) { + return SkColorFilter::CreateMatrixFilterRowMajor255(array); + } + /** * Create a colorfilter that multiplies the RGB channels by one color, and * then adds a second color, pinning the result for each component to * [0..255]. The alpha components of the mul and add arguments * are ignored. */ - static sk_sp<SkColorFilter> MakeLightingFilter(SkColor mul, SkColor add); - -#ifdef SK_SUPPORT_LEGACY_COLORFILTER_PTR - static SkColorFilter* Create(const SkColorMatrix& cm) { - return SkColorFilter::MakeMatrixFilterRowMajor255(cm.fMat).release(); - } - static SkColorFilter* Create(const SkScalar array[20]) { - return SkColorFilter::MakeMatrixFilterRowMajor255(array).release(); - } - static SkColorFilter* CreateLightingFilter(SkColor mul, SkColor add) { - return MakeLightingFilter(mul, add).release(); - } -#endif + static SkColorFilter* CreateLightingFilter(SkColor mul, SkColor add); }; #endif diff --git a/include/effects/SkLumaColorFilter.h b/include/effects/SkLumaColorFilter.h index 3a68607b19..8dd519af4a 100644 --- a/include/effects/SkLumaColorFilter.h +++ b/include/effects/SkLumaColorFilter.h @@ -23,11 +23,7 @@ */ class SK_API SkLumaColorFilter : public SkColorFilter { public: - static sk_sp<SkColorFilter> Make(); - -#ifdef SK_SUPPORT_LEGACY_COLORFILTER_PTR - static SkColorFilter* Create() { return Make().release(); } -#endif + static SkColorFilter* Create(); void filterSpan(const SkPMColor src[], int count, SkPMColor[]) const override; diff --git a/include/effects/SkTableColorFilter.h b/include/effects/SkTableColorFilter.h index fe31149464..e4d42dc00c 100644 --- a/include/effects/SkTableColorFilter.h +++ b/include/effects/SkTableColorFilter.h @@ -23,7 +23,7 @@ public: * colors are premultiplied, they are temporarily unpremultiplied, then * the table is applied, and then the result is remultiplied. */ - static sk_sp<SkColorFilter> Make(const uint8_t table[256]); + static SkColorFilter* Create(const uint8_t table[256]); /** * Create a table colorfilter, with a different table for each @@ -31,23 +31,11 @@ public: * treated as identity, with the component left unchanged. If a table * is not null, then its contents are copied into the filter. */ - static sk_sp<SkColorFilter> MakeARGB(const uint8_t tableA[256], - const uint8_t tableR[256], - const uint8_t tableG[256], - const uint8_t tableB[256]); - -#ifdef SK_SUPPORT_LEGACY_COLORFILTER_PTR - static SkColorFilter* Create(const uint8_t table[256]) { - return Make(table).release(); - } static SkColorFilter* CreateARGB(const uint8_t tableA[256], const uint8_t tableR[256], const uint8_t tableG[256], - const uint8_t tableB[256]) { - return MakeARGB(tableA, tableR, tableG, tableB).release(); - } -#endif - + const uint8_t tableB[256]); + SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP() }; diff --git a/public.bzl b/public.bzl index 20914ea69c..11a7ca3ab3 100644 --- a/public.bzl +++ b/public.bzl @@ -501,6 +501,7 @@ DEFINES_UNIX = [ "SK_CODEC_DECODES_PNG", "SK_CODEC_DECODES_RAW", "SK_CODEC_DECODES_WEBP", + "SK_SUPPORT_LEGACY_CREATESHADER_PTR", ] DEFINES_ANDROID = [ @@ -526,9 +527,6 @@ DEFINES_ALL = [ "SK_SUPPORT_LEGACY_PATHEFFECT_PTR", # Turn on a few Google3-specific build fixes. "GOOGLE3", - # Staging flags for API changes - "SK_SUPPORT_LEGACY_COLORFILTER_PTR", - "SK_SUPPORT_LEGACY_CREATESHADER_PTR", ] ################################################################################ diff --git a/samplecode/SampleAll.cpp b/samplecode/SampleAll.cpp index 70ecd9fe7e..b8b0ee677d 100644 --- a/samplecode/SampleAll.cpp +++ b/samplecode/SampleAll.cpp @@ -384,7 +384,7 @@ protected: SkMaskFilter* embossFilter = SkEmbossMaskFilter::Create(sigma, light); SkXfermode* xfermode = SkXfermode::Create(SkXfermode::kXor_Mode); - auto lightingFilter = SkColorMatrixFilter::MakeLightingFilter( + SkColorFilter* lightingFilter = SkColorMatrixFilter::CreateLightingFilter( 0xff89bc45, 0xff112233); canvas->save(); @@ -406,7 +406,7 @@ protected: paint.setStrokeWidth(SkIntToScalar(10)); paint.setStyle(SkPaint::kStroke_Style); paint.setXfermode(xfermode)->unref(); - paint.setColorFilter(lightingFilter); + paint.setColorFilter(lightingFilter)->unref(); canvas->drawLine(start.fX, start.fY, stop.fX, stop.fY, paint); // should not be green paint.setXfermode(nullptr); paint.setColorFilter(nullptr); @@ -543,9 +543,9 @@ protected: #if 01 int index = i % SK_ARRAY_COUNT(gLightingColors); - paint.setColorFilter(SkColorMatrixFilter::MakeLightingFilter( + paint.setColorFilter(SkColorMatrixFilter::CreateLightingFilter( gLightingColors[index].fMul, - gLightingColors[index].fAdd)); + gLightingColors[index].fAdd))->unref(); #endif canvas->drawText(str.c_str(), str.size(), x, y, paint); diff --git a/samplecode/SampleColorFilter.cpp b/samplecode/SampleColorFilter.cpp index 0b8acc32d7..4ee8949410 100644 --- a/samplecode/SampleColorFilter.cpp +++ b/samplecode/SampleColorFilter.cpp @@ -184,7 +184,8 @@ protected: for (size_t y = 0; y < SK_ARRAY_COUNT(gColors); y++) { for (size_t x = 0; x < SK_ARRAY_COUNT(gModes); x++) { - paint.setColorFilter(SkColorFilter::MakeModeFilter(gColors[y], gModes[x])); + SkColorFilter* cf = SkColorFilter::CreateModeFilter(gColors[y], gModes[x]); + SkSafeUnref(paint.setColorFilter(cf)); canvas->drawBitmap(fBitmap, x * N * 1.25f, y * N * scale, &paint); } } diff --git a/samplecode/SampleFilterFuzz.cpp b/samplecode/SampleFilterFuzz.cpp index 82934ea3cc..dd0fa4044e 100644 --- a/samplecode/SampleFilterFuzz.cpp +++ b/samplecode/SampleFilterFuzz.cpp @@ -298,9 +298,9 @@ static const SkBitmap& make_bitmap() { return bitmap[R(2)]; } -static sk_sp<SkData> make_3Dlut(int* cubeDimension, bool invR, bool invG, bool invB) { +static SkData* make_3Dlut(int* cubeDimension, bool invR, bool invG, bool invB) { int size = 4 << R(5); - auto data = SkData::MakeUninitialized(sizeof(SkColor) * size * size * size); + SkData* data = SkData::NewUninitialized(sizeof(SkColor) * size * size * size); SkColor* pixels = (SkColor*)(data->writable_data()); SkAutoTMalloc<uint8_t> lutMemory(size); SkAutoTMalloc<uint8_t> invLutMemory(size); @@ -350,17 +350,20 @@ static void rand_color_table(uint8_t* table) { } } -static sk_sp<SkColorFilter> make_color_filter() { +static SkColorFilter* make_color_filter() { + SkColorFilter* colorFilter; switch (R(6)) { case 0: { SkScalar array[20]; for (int i = 0; i < 20; ++i) { array[i] = make_scalar(); } - return SkColorFilter::MakeMatrixFilterRowMajor255(array); + colorFilter = SkColorMatrixFilter::Create(array); + break; } case 1: - return SkLumaColorFilter::Make(); + colorFilter = SkLumaColorFilter::Create(); + break; case 2: { uint8_t tableA[256]; uint8_t tableR[256]; @@ -370,17 +373,21 @@ static sk_sp<SkColorFilter> make_color_filter() { rand_color_table(tableR); rand_color_table(tableG); rand_color_table(tableB); - return SkTableColorFilter::MakeARGB(tableA, tableR, tableG, tableB); + colorFilter = SkTableColorFilter::CreateARGB(tableA, tableR, tableG, tableB); + break; } case 3: - return SkColorFilter::MakeModeFilter(make_color(), make_xfermode()); + colorFilter = SkColorFilter::CreateModeFilter(make_color(), make_xfermode()); + break; case 4: - return SkColorMatrixFilter::MakeLightingFilter(make_color(), make_color()); + colorFilter = SkColorMatrixFilter::CreateLightingFilter(make_color(), make_color()); + break; case 5: default: + colorFilter = nullptr; break; } - return nullptr; + return colorFilter; } static SkPath make_path() { @@ -531,7 +538,7 @@ static SkPaint make_paint() { rasterizerBuilder.addLayer(paintForRasterizer); paint.setRasterizer(rasterizerBuilder.detach()); paint.setImageFilter(make_image_filter()); - sk_sp<SkData> data(make_3Dlut(nullptr, make_bool(), make_bool(), make_bool())); + SkAutoDataUnref data(make_3Dlut(nullptr, make_bool(), make_bool(), make_bool())); paint.setTextAlign(make_paint_align()); paint.setTextSize(make_scalar()); paint.setTextScaleX(make_scalar()); @@ -560,16 +567,16 @@ static SkImageFilter* make_image_filter(bool canBeNull) { break; case COLOR: { - sk_sp<SkColorFilter> cf(make_color_filter()); - filter = cf ? SkColorFilterImageFilter::Create(cf.get(), make_image_filter()) : 0; + SkAutoTUnref<SkColorFilter> cf(make_color_filter()); + filter = cf.get() ? SkColorFilterImageFilter::Create(cf, make_image_filter()) : 0; } break; case LUT3D: { int cubeDimension; - sk_sp<SkData> lut3D(make_3Dlut(&cubeDimension, (R(2) == 1), (R(2) == 1), (R(2) == 1))); - sk_sp<SkColorFilter> cf(SkColorCubeFilter::Make(lut3D, cubeDimension)); - filter = cf ? SkColorFilterImageFilter::Create(cf.get(), make_image_filter()) : 0; + SkAutoDataUnref lut3D(make_3Dlut(&cubeDimension, (R(2) == 1), (R(2) == 1), (R(2) == 1))); + SkAutoTUnref<SkColorFilter> cf(SkColorCubeFilter::Create(lut3D, cubeDimension)); + filter = cf.get() ? SkColorFilterImageFilter::Create(cf, make_image_filter()) : 0; } break; case BLUR: diff --git a/src/core/SkBlitter.cpp b/src/core/SkBlitter.cpp index 15562168e9..04897e3828 100644 --- a/src/core/SkBlitter.cpp +++ b/src/core/SkBlitter.cpp @@ -844,8 +844,7 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device, if (SkXfermode::IsMode(mode, SkXfermode::kClear_Mode)) { SkPaint* p = paint.writable(); shader = p->setShader(nullptr); - p->setColorFilter(nullptr); - cf = nullptr; + cf = p->setColorFilter(nullptr); mode = p->setXfermodeMode(SkXfermode::kSrc_Mode); p->setColor(0); } @@ -868,7 +867,7 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device, if (cf) { SkASSERT(shader); - paint.writable()->setShader(shader->makeWithColorFilter(sk_ref_sp(cf))); + paint.writable()->setShader(shader->makeWithColorFilter(cf)); shader = paint->getShader(); // blitters should ignore the presence/absence of a filter, since // if there is one, the shader will take care of it. diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp index f7f870210d..3efb44cc54 100644 --- a/src/core/SkCanvas.cpp +++ b/src/core/SkCanvas.cpp @@ -391,17 +391,16 @@ static SkPaint* set_if_needed(SkLazyPaint* lazy, const SkPaint& orig) { * If the paint has an imagefilter, but it can be simplified to just a colorfilter, return that * colorfilter, else return nullptr. */ -static sk_sp<SkColorFilter> image_to_color_filter(const SkPaint& paint) { +static SkColorFilter* image_to_color_filter(const SkPaint& paint) { SkImageFilter* imgf = paint.getImageFilter(); if (!imgf) { return nullptr; } - SkColorFilter* imgCFPtr; - if (!imgf->asAColorFilter(&imgCFPtr)) { + SkColorFilter* imgCF; + if (!imgf->asAColorFilter(&imgCF)) { return nullptr; } - sk_sp<SkColorFilter> imgCF(imgCFPtr); SkColorFilter* paintCF = paint.getColorFilter(); if (nullptr == paintCF) { @@ -411,7 +410,8 @@ static sk_sp<SkColorFilter> image_to_color_filter(const SkPaint& paint) { // The paint has both a colorfilter(paintCF) and an imagefilter-which-is-a-colorfilter(imgCF) // and we need to combine them into a single colorfilter. - return SkColorFilter::MakeComposeFilter(std::move(imgCF), sk_ref_sp(paintCF)); + SkAutoTUnref<SkColorFilter> autoImgCF(imgCF); + return SkColorFilter::CreateComposeFilter(imgCF, paintCF); } /** @@ -455,10 +455,10 @@ public: fTempLayerForImageFilter = false; fDone = false; - auto simplifiedCF = image_to_color_filter(fOrigPaint); + SkColorFilter* simplifiedCF = image_to_color_filter(fOrigPaint); if (simplifiedCF) { SkPaint* paint = set_if_needed(&fLazyPaintInit, fOrigPaint); - paint->setColorFilter(std::move(simplifiedCF)); + paint->setColorFilter(simplifiedCF)->unref(); paint->setImageFilter(nullptr); fPaint = paint; } diff --git a/src/core/SkColorFilter.cpp b/src/core/SkColorFilter.cpp index 59a625d0b6..dab4ccf7b5 100644 --- a/src/core/SkColorFilter.cpp +++ b/src/core/SkColorFilter.cpp @@ -114,15 +114,14 @@ public: protected: void flatten(SkWriteBuffer& buffer) const override { - buffer.writeFlattenable(fOuter.get()); - buffer.writeFlattenable(fInner.get()); + buffer.writeFlattenable(fOuter); + buffer.writeFlattenable(fInner); } private: - SkComposeColorFilter(sk_sp<SkColorFilter> outer, sk_sp<SkColorFilter> inner, - int composedFilterCount) - : fOuter(std::move(outer)) - , fInner(std::move(inner)) + SkComposeColorFilter(SkColorFilter* outer, SkColorFilter* inner, int composedFilterCount) + : fOuter(SkRef(outer)) + , fInner(SkRef(inner)) , fComposedFilterCount(composedFilterCount) { SkASSERT(composedFilterCount >= 2); @@ -133,9 +132,9 @@ private: return fComposedFilterCount; } - sk_sp<SkColorFilter> fOuter; - sk_sp<SkColorFilter> fInner; - const int fComposedFilterCount; + SkAutoTUnref<SkColorFilter> fOuter; + SkAutoTUnref<SkColorFilter> fInner; + const int fComposedFilterCount; friend class SkColorFilter; @@ -143,24 +142,23 @@ private: }; SkFlattenable* SkComposeColorFilter::CreateProc(SkReadBuffer& buffer) { - sk_sp<SkColorFilter> outer(buffer.readColorFilter()); - sk_sp<SkColorFilter> inner(buffer.readColorFilter()); - return MakeComposeFilter(std::move(outer), std::move(inner)).release(); + SkAutoTUnref<SkColorFilter> outer(buffer.readColorFilter()); + SkAutoTUnref<SkColorFilter> inner(buffer.readColorFilter()); + return CreateComposeFilter(outer, inner); } /////////////////////////////////////////////////////////////////////////////////////////////////// -sk_sp<SkColorFilter> SkColorFilter::MakeComposeFilter(sk_sp<SkColorFilter> outer, - sk_sp<SkColorFilter> inner) { +SkColorFilter* SkColorFilter::CreateComposeFilter(SkColorFilter* outer, SkColorFilter* inner) { if (!outer) { - return inner; + return SkSafeRef(inner); } if (!inner) { - return outer; + return SkSafeRef(outer); } // Give the subclass a shot at a more optimal composition... - auto composition = outer->makeComposed(inner); + SkColorFilter* composition = outer->newComposed(inner); if (composition) { return composition; } @@ -169,7 +167,7 @@ sk_sp<SkColorFilter> SkColorFilter::MakeComposeFilter(sk_sp<SkColorFilter> outer if (count > SK_MAX_COMPOSE_COLORFILTER_COUNT) { return nullptr; } - return sk_sp<SkColorFilter>(new SkComposeColorFilter(std::move(outer), std::move(inner),count)); + return new SkComposeColorFilter(outer, inner, count); } #include "SkModeColorFilter.h" diff --git a/src/core/SkColorFilterShader.cpp b/src/core/SkColorFilterShader.cpp index 8a175024de..2e426a17ed 100644 --- a/src/core/SkColorFilterShader.cpp +++ b/src/core/SkColorFilterShader.cpp @@ -15,26 +15,26 @@ #include "GrFragmentProcessor.h" #endif -SkColorFilterShader::SkColorFilterShader(sk_sp<SkShader> shader, sk_sp<SkColorFilter> filter) - : fShader(std::move(shader)) - , fFilter(std::move(filter)) +SkColorFilterShader::SkColorFilterShader(SkShader* shader, SkColorFilter* filter) + : fShader(SkRef(shader)) + , fFilter(SkRef(filter)) { - SkASSERT(fShader); - SkASSERT(fFilter); + SkASSERT(shader); + SkASSERT(filter); } SkFlattenable* SkColorFilterShader::CreateProc(SkReadBuffer& buffer) { auto shader = buffer.readShader(); - auto filter = buffer.readColorFilter(); - if (!shader || !filter) { + SkAutoTUnref<SkColorFilter> filter(buffer.readColorFilter()); + if (!shader || !filter.get()) { return nullptr; } - return new SkColorFilterShader(shader, filter); + return new SkColorFilterShader(shader.get(), filter); } void SkColorFilterShader::flatten(SkWriteBuffer& buffer) const { - buffer.writeFlattenable(fShader.get()); - buffer.writeFlattenable(fFilter.get()); + buffer.writeFlattenable(fShader); + buffer.writeFlattenable(fFilter); } uint32_t SkColorFilterShader::FilterShaderContext::getFlags() const { @@ -137,10 +137,10 @@ void SkColorFilterShader::toString(SkString* str) const { /////////////////////////////////////////////////////////////////////////////////////////////////// -sk_sp<SkShader> SkShader::makeWithColorFilter(sk_sp<SkColorFilter> filter) const { +sk_sp<SkShader> SkShader::makeWithColorFilter(SkColorFilter* filter) const { SkShader* base = const_cast<SkShader*>(this); if (!filter) { return sk_ref_sp(base); } - return sk_make_sp<SkColorFilterShader>(sk_ref_sp(base), filter); + return sk_make_sp<SkColorFilterShader>(base, filter); } diff --git a/src/core/SkColorFilterShader.h b/src/core/SkColorFilterShader.h index 167a272fa4..0f41a43c49 100644 --- a/src/core/SkColorFilterShader.h +++ b/src/core/SkColorFilterShader.h @@ -13,7 +13,7 @@ class SkColorFilterShader : public SkShader { public: - SkColorFilterShader(sk_sp<SkShader> shader, sk_sp<SkColorFilter> filter); + SkColorFilterShader(SkShader* shader, SkColorFilter* filter); #if SK_SUPPORT_GPU const GrFragmentProcessor* asFragmentProcessor(GrContext*, @@ -53,8 +53,8 @@ protected: Context* onCreateContext(const ContextRec&, void* storage) const override; private: - sk_sp<SkShader> fShader; - sk_sp<SkColorFilter> fFilter; + SkAutoTUnref<SkShader> fShader; + SkAutoTUnref<SkColorFilter> fFilter; typedef SkShader INHERITED; }; diff --git a/src/core/SkColorMatrixFilterRowMajor255.cpp b/src/core/SkColorMatrixFilterRowMajor255.cpp index bd9a66a561..09df61699d 100644 --- a/src/core/SkColorMatrixFilterRowMajor255.cpp +++ b/src/core/SkColorMatrixFilterRowMajor255.cpp @@ -226,13 +226,12 @@ static void set_concat(SkScalar result[20], const SkScalar outer[20], const SkSc // End duplication ////// -sk_sp<SkColorFilter> -SkColorMatrixFilterRowMajor255::makeComposed(sk_sp<SkColorFilter> innerFilter) const { +SkColorFilter* SkColorMatrixFilterRowMajor255::newComposed(const SkColorFilter* innerFilter) const { SkScalar innerMatrix[20]; if (innerFilter->asColorMatrix(innerMatrix) && !needs_clamping(innerMatrix)) { SkScalar concat[20]; set_concat(concat, fMatrix, innerMatrix); - return sk_make_sp<SkColorMatrixFilterRowMajor255>(concat); + return new SkColorMatrixFilterRowMajor255(concat); } return nullptr; } @@ -418,16 +417,15 @@ void SkColorMatrixFilterRowMajor255::toString(SkString* str) const { /////////////////////////////////////////////////////////////////////////////// -sk_sp<SkColorFilter> SkColorFilter::MakeMatrixFilterRowMajor255(const SkScalar array[20]) { - return sk_sp<SkColorFilter>(new SkColorMatrixFilterRowMajor255(array)); +SkColorFilter* SkColorFilter::CreateMatrixFilterRowMajor255(const SkScalar array[20]) { + return new SkColorMatrixFilterRowMajor255(array); } /////////////////////////////////////////////////////////////////////////////// -sk_sp<SkColorFilter> -SkColorMatrixFilterRowMajor255::MakeSingleChannelOutput(const SkScalar row[5]) { +SkColorFilter* SkColorMatrixFilterRowMajor255::CreateSingleChannelOutput(const SkScalar row[5]) { SkASSERT(row); - auto cf = sk_make_sp<SkColorMatrixFilterRowMajor255>(); + SkColorMatrixFilterRowMajor255* cf = new SkColorMatrixFilterRowMajor255(); static_assert(sizeof(SkScalar) * 5 * 4 == sizeof(cf->fMatrix), "sizes don't match"); for (int i = 0; i < 4; ++i) { memcpy(cf->fMatrix + 5 * i, row, sizeof(SkScalar) * 5); diff --git a/src/core/SkColorMatrixFilterRowMajor255.h b/src/core/SkColorMatrixFilterRowMajor255.h index 0ad64fa2f0..106d2bd882 100644 --- a/src/core/SkColorMatrixFilterRowMajor255.h +++ b/src/core/SkColorMatrixFilterRowMajor255.h @@ -12,17 +12,16 @@ class SK_API SkColorMatrixFilterRowMajor255 : public SkColorFilter { public: - SkColorMatrixFilterRowMajor255() {}; explicit SkColorMatrixFilterRowMajor255(const SkScalar array[20]); /** Creates a color matrix filter that returns the same value in all four channels. */ - static sk_sp<SkColorFilter> MakeSingleChannelOutput(const SkScalar row[5]); + static SkColorFilter* CreateSingleChannelOutput(const SkScalar row[5]); void filterSpan(const SkPMColor src[], int count, SkPMColor[]) const override; void filterSpan4f(const SkPM4f src[], int count, SkPM4f[]) const override; uint32_t getFlags() const override; bool asColorMatrix(SkScalar matrix[20]) const override; - sk_sp<SkColorFilter> makeComposed(sk_sp<SkColorFilter>) const override; + SkColorFilter* newComposed(const SkColorFilter*) const override; #if SK_SUPPORT_GPU const GrFragmentProcessor* asFragmentProcessor(GrContext*) const override; @@ -36,6 +35,8 @@ protected: void flatten(SkWriteBuffer&) const override; private: + SkColorMatrixFilterRowMajor255() {}; + SkScalar fMatrix[20]; float fTranspose[20]; // for Sk4s uint32_t fFlags; diff --git a/src/core/SkDevice.cpp b/src/core/SkDevice.cpp index fb4b48fdbd..90be52b403 100644 --- a/src/core/SkDevice.cpp +++ b/src/core/SkDevice.cpp @@ -207,7 +207,8 @@ void SkBaseDevice::drawAtlas(const SkDraw& draw, const SkImage* atlas, const SkR pnt.setShader(std::move(shader)); if (colors) { - pnt.setColorFilter(SkColorFilter::MakeModeFilter(colors[i], mode)); + SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(colors[i], mode)); + pnt.setColorFilter(cf); } path.rewind(); diff --git a/src/core/SkModeColorFilter.cpp b/src/core/SkModeColorFilter.cpp index 3da51609a3..1e104d8dc7 100644 --- a/src/core/SkModeColorFilter.cpp +++ b/src/core/SkModeColorFilter.cpp @@ -80,7 +80,7 @@ void SkModeColorFilter::updateCache() { SkFlattenable* SkModeColorFilter::CreateProc(SkReadBuffer& buffer) { SkColor color = buffer.readColor(); SkXfermode::Mode mode = (SkXfermode::Mode)buffer.readUInt(); - return SkColorFilter::MakeModeFilter(color, mode).release(); + return SkColorFilter::CreateModeFilter(color, mode); } /////////////////////////////////////////////////////////////////////////////// @@ -148,7 +148,7 @@ private: /////////////////////////////////////////////////////////////////////////////// -sk_sp<SkColorFilter> SkColorFilter::MakeModeFilter(SkColor color, SkXfermode::Mode mode) { +SkColorFilter* SkColorFilter::CreateModeFilter(SkColor color, SkXfermode::Mode mode) { if (!SkIsValidMode(mode)) { return nullptr; } @@ -183,10 +183,10 @@ sk_sp<SkColorFilter> SkColorFilter::MakeModeFilter(SkColor color, SkXfermode::Mo switch (mode) { case SkXfermode::kSrc_Mode: - return sk_make_sp<Src_SkModeColorFilter>(color); + return new Src_SkModeColorFilter(color); case SkXfermode::kSrcOver_Mode: - return sk_make_sp<SrcOver_SkModeColorFilter>(color); + return new SrcOver_SkModeColorFilter(color); default: - return SkModeColorFilter::Make(color, mode); + return SkModeColorFilter::Create(color, mode); } } diff --git a/src/core/SkModeColorFilter.h b/src/core/SkModeColorFilter.h index d73cab7932..44e618a3ad 100644 --- a/src/core/SkModeColorFilter.h +++ b/src/core/SkModeColorFilter.h @@ -13,14 +13,9 @@ class SkModeColorFilter : public SkColorFilter { public: - static sk_sp<SkColorFilter> Make(SkColor color, SkXfermode::Mode mode) { - return sk_sp<SkColorFilter>(new SkModeColorFilter(color, mode)); - } -#ifdef SK_SUPPORT_LEGACY_COLORFILTER_PTR static SkColorFilter* Create(SkColor color, SkXfermode::Mode mode) { - return Make(color, mode).release(); + return new SkModeColorFilter(color, mode); } -#endif SkColor getColor() const { return fColor; } SkXfermode::Mode getMode() const { return fMode; } diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp index 6fe9d7599d..19bdcaf0aa 100644 --- a/src/core/SkPaint.cpp +++ b/src/core/SkPaint.cpp @@ -375,9 +375,7 @@ SET_PTR(Rasterizer) #endif SET_PTR(ImageFilter) SET_PTR(Shader) -#ifdef SK_SUPPORT_LEGACY_COLORFILTER_PTR SET_PTR(ColorFilter) -#endif SET_PTR(Xfermode) #ifdef SK_SUPPORT_LEGACY_PATHEFFECT_PTR SET_PTR(PathEffect) @@ -1942,7 +1940,7 @@ void SkPaint::unflatten(SkReadBuffer& buffer) { this->setShader(buffer.readShader()); SkSafeUnref(this->setXfermode(buffer.readXfermode())); SkSafeUnref(this->setMaskFilter(buffer.readMaskFilter())); - this->setColorFilter(buffer.readColorFilter()); + SkSafeUnref(this->setColorFilter(buffer.readColorFilter())); this->setRasterizer(buffer.readRasterizer()); this->setLooper(buffer.readDrawLooper()); SkSafeUnref(this->setImageFilter(buffer.readImageFilter())); diff --git a/src/core/SkReadBuffer.h b/src/core/SkReadBuffer.h index 46f6b818da..575375eded 100644 --- a/src/core/SkReadBuffer.h +++ b/src/core/SkReadBuffer.h @@ -130,9 +130,7 @@ public: template <typename T> T* readFlattenable() { return (T*) this->readFlattenable(T::GetFlattenableType()); } - sk_sp<SkColorFilter> readColorFilter() { - return sk_sp<SkColorFilter>(this->readFlattenable<SkColorFilter>()); - } + SkColorFilter* readColorFilter() { return this->readFlattenable<SkColorFilter>(); } sk_sp<SkDrawLooper> readDrawLooper() { return sk_sp<SkDrawLooper>(this->readFlattenable<SkDrawLooper>()); } diff --git a/src/effects/SkBlurDrawLooper.cpp b/src/effects/SkBlurDrawLooper.cpp index c8e20e1265..d8127eba4e 100644 --- a/src/effects/SkBlurDrawLooper.cpp +++ b/src/effects/SkBlurDrawLooper.cpp @@ -44,7 +44,8 @@ void SkBlurDrawLooper::initEffects() { // be baked into the blurred mask. SkColor opaqueColor = SkColorSetA(fBlurColor, 255); //The SrcIn xfer mode will multiply 'color' by the incoming alpha - fColorFilter = SkColorFilter::MakeModeFilter(opaqueColor, SkXfermode::kSrcIn_Mode); + fColorFilter = SkColorFilter::CreateModeFilter(opaqueColor, + SkXfermode::kSrcIn_Mode); } else { fColorFilter = nullptr; } @@ -80,6 +81,7 @@ void SkBlurDrawLooper::flatten(SkWriteBuffer& buffer) const { SkBlurDrawLooper::~SkBlurDrawLooper() { SkSafeUnref(fBlur); + SkSafeUnref(fColorFilter); } bool SkBlurDrawLooper::asABlurShadow(BlurShadowRec* rec) const { diff --git a/src/effects/SkColorCubeFilter.cpp b/src/effects/SkColorCubeFilter.cpp index d80a02fef2..d59f123a80 100644 --- a/src/effects/SkColorCubeFilter.cpp +++ b/src/effects/SkColorCubeFilter.cpp @@ -48,19 +48,19 @@ static bool is_valid_3D_lut(SkData* cubeData, int cubeDimension) { (nullptr != cubeData) && (cubeData->size() >= minMemorySize); } -sk_sp<SkColorFilter> SkColorCubeFilter::Make(sk_sp<SkData> cubeData, int cubeDimension) { - if (!is_valid_3D_lut(cubeData.get(), cubeDimension)) { +SkColorFilter* SkColorCubeFilter::Create(SkData* cubeData, int cubeDimension) { + if (!is_valid_3D_lut(cubeData, cubeDimension)) { return nullptr; } - return sk_sp<SkColorFilter>(new SkColorCubeFilter(std::move(cubeData), cubeDimension)); + return new SkColorCubeFilter(cubeData, cubeDimension); } -SkColorCubeFilter::SkColorCubeFilter(sk_sp<SkData> cubeData, int cubeDimension) - : fCubeData(std::move(cubeData)) - , fUniqueID(SkNextColorCubeUniqueID()) - , fCache(cubeDimension) -{} +SkColorCubeFilter::SkColorCubeFilter(SkData* cubeData, int cubeDimension) + : fCubeData(SkRef(cubeData)) + , fUniqueID(SkNextColorCubeUniqueID()) + , fCache(cubeDimension) { +} uint32_t SkColorCubeFilter::getFlags() const { return this->INHERITED::getFlags() | kAlphaUnchanged_Flag; @@ -142,7 +142,7 @@ SkFlattenable* SkColorCubeFilter::CreateProc(SkReadBuffer& buffer) { if (!buffer.validate(is_valid_3D_lut(cubeData.get(), cubeDimension))) { return nullptr; } - return Make(std::move(cubeData), cubeDimension).release(); + return Create(cubeData.get(), cubeDimension); } void SkColorCubeFilter::flatten(SkWriteBuffer& buffer) const { diff --git a/src/effects/SkColorFilterImageFilter.cpp b/src/effects/SkColorFilterImageFilter.cpp index 6eb66533d9..96ce5d9690 100644 --- a/src/effects/SkColorFilterImageFilter.cpp +++ b/src/effects/SkColorFilterImageFilter.cpp @@ -25,10 +25,10 @@ SkImageFilter* SkColorFilterImageFilter::Create(SkColorFilter* cf, SkImageFilter if (input && input->isColorFilterNode(&inputCF)) { // This is an optimization, as it collapses the hierarchy by just combining the two // colorfilters into a single one, which the new imagefilter will wrap. - sk_sp<SkColorFilter> newCF(SkColorFilter::MakeComposeFilter(sk_ref_sp(cf), - sk_sp<SkColorFilter>(inputCF))); + SkAutoUnref autoUnref(inputCF); + SkAutoTUnref<SkColorFilter> newCF(SkColorFilter::CreateComposeFilter(cf, inputCF)); if (newCF) { - return new SkColorFilterImageFilter(newCF.get(), input->getInput(0), cropRect); + return new SkColorFilterImageFilter(newCF, input->getInput(0), cropRect); } } @@ -42,13 +42,17 @@ SkColorFilterImageFilter::SkColorFilterImageFilter(SkColorFilter* cf, SkFlattenable* SkColorFilterImageFilter::CreateProc(SkReadBuffer& buffer) { SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1); - sk_sp<SkColorFilter> cf(buffer.readColorFilter()); - return Create(cf.get(), common.getInput(0), &common.cropRect()); + SkAutoTUnref<SkColorFilter> cf(buffer.readColorFilter()); + return Create(cf, common.getInput(0), &common.cropRect()); } void SkColorFilterImageFilter::flatten(SkWriteBuffer& buffer) const { this->INHERITED::flatten(buffer); - buffer.writeFlattenable(fColorFilter.get()); + buffer.writeFlattenable(fColorFilter); +} + +SkColorFilterImageFilter::~SkColorFilterImageFilter() { + fColorFilter->unref(); } bool SkColorFilterImageFilter::onFilterImageDeprecated(Proxy* proxy, const SkBitmap& source, @@ -90,7 +94,7 @@ bool SkColorFilterImageFilter::onIsColorFilterNode(SkColorFilter** filter) const SkASSERT(1 == this->countInputs()); if (!this->cropRectIsSet()) { if (filter) { - *filter = SkRef(fColorFilter.get()); + *filter = SkRef(fColorFilter); } return true; } diff --git a/src/effects/SkColorMatrixFilter.cpp b/src/effects/SkColorMatrixFilter.cpp index 82bd45b73d..e122b6ac8e 100644 --- a/src/effects/SkColorMatrixFilter.cpp +++ b/src/effects/SkColorMatrixFilter.cpp @@ -16,7 +16,7 @@ static SkScalar byte_to_scale(U8CPU byte) { } } -sk_sp<SkColorFilter> SkColorMatrixFilter::MakeLightingFilter(SkColor mul, SkColor add) { +SkColorFilter* SkColorMatrixFilter::CreateLightingFilter(SkColor mul, SkColor add) { SkColorMatrix matrix; matrix.setScale(byte_to_scale(SkColorGetR(mul)), byte_to_scale(SkColorGetG(mul)), @@ -26,5 +26,5 @@ sk_sp<SkColorFilter> SkColorMatrixFilter::MakeLightingFilter(SkColor mul, SkColo SkIntToScalar(SkColorGetG(add)), SkIntToScalar(SkColorGetB(add)), 0); - return SkColorFilter::MakeMatrixFilterRowMajor255(matrix.fMat); + return SkColorMatrixFilter::Create(matrix); } diff --git a/src/effects/SkDropShadowImageFilter.cpp b/src/effects/SkDropShadowImageFilter.cpp index e32b89ee6d..deece35b38 100644 --- a/src/effects/SkDropShadowImageFilter.cpp +++ b/src/effects/SkDropShadowImageFilter.cpp @@ -79,9 +79,11 @@ bool SkDropShadowImageFilter::onFilterImageDeprecated(Proxy* proxy, const SkBitm sigma.fX = SkMaxScalar(0, sigma.fX); sigma.fY = SkMaxScalar(0, sigma.fY); SkAutoTUnref<SkImageFilter> blurFilter(SkBlurImageFilter::Create(sigma.fX, sigma.fY)); + SkAutoTUnref<SkColorFilter> colorFilter( + SkColorFilter::CreateModeFilter(fColor, SkXfermode::kSrcIn_Mode)); SkPaint paint; paint.setImageFilter(blurFilter.get()); - paint.setColorFilter(SkColorFilter::MakeModeFilter(fColor, SkXfermode::kSrcIn_Mode)); + paint.setColorFilter(colorFilter.get()); paint.setXfermodeMode(SkXfermode::kSrcOver_Mode); SkVector offsetVec = SkVector::Make(fDx, fDy); ctx.ctm().mapVectors(&offsetVec, 1); diff --git a/src/effects/SkLayerDrawLooper.cpp b/src/effects/SkLayerDrawLooper.cpp index 8510767801..ae31482ae7 100644 --- a/src/effects/SkLayerDrawLooper.cpp +++ b/src/effects/SkLayerDrawLooper.cpp @@ -102,7 +102,7 @@ void SkLayerDrawLooper::LayerDrawLooperContext::ApplyInfo( dst->setShader(src.getShader()); } if (bits & kColorFilter_Bit) { - dst->setColorFilter(sk_ref_sp(src.getColorFilter())); + dst->setColorFilter(src.getColorFilter()); } if (bits & kXfermode_Bit) { dst->setXfermode(src.getXfermode()); diff --git a/src/effects/SkLumaColorFilter.cpp b/src/effects/SkLumaColorFilter.cpp index 18b2485a30..0ca6342d56 100644 --- a/src/effects/SkLumaColorFilter.cpp +++ b/src/effects/SkLumaColorFilter.cpp @@ -37,9 +37,7 @@ void SkLumaColorFilter::filterSpan(const SkPMColor src[], int count, } } -sk_sp<SkColorFilter> SkLumaColorFilter::Make() { - return sk_sp<SkColorFilter>(new SkLumaColorFilter); -} +SkColorFilter* SkLumaColorFilter::Create() { return new SkLumaColorFilter; } SkLumaColorFilter::SkLumaColorFilter() : INHERITED() {} diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp index 4ce0b4bb0e..5ae175ffca 100644 --- a/src/effects/SkTableColorFilter.cpp +++ b/src/effects/SkTableColorFilter.cpp @@ -46,7 +46,7 @@ public: virtual ~SkTable_ColorFilter() { delete fBitmap; } bool asComponentTable(SkBitmap* table) const override; - sk_sp<SkColorFilter> makeComposed(sk_sp<SkColorFilter> inner) const override; + SkColorFilter* newComposed(const SkColorFilter* inner) const override; #if SK_SUPPORT_GPU const GrFragmentProcessor* asFragmentProcessor(GrContext*) const override; @@ -251,7 +251,7 @@ SkFlattenable* SkTable_ColorFilter::CreateProc(SkReadBuffer& buffer) { b = ptr; ptr += 256; } - return SkTableColorFilter::MakeARGB(a, r, g, b).release(); + return SkTableColorFilter::CreateARGB(a, r, g, b); } bool SkTable_ColorFilter::asComponentTable(SkBitmap* table) const { @@ -287,7 +287,7 @@ static void combine_tables(uint8_t res[256], const uint8_t outer[256], const uin } } -sk_sp<SkColorFilter> SkTable_ColorFilter::makeComposed(sk_sp<SkColorFilter> innerFilter) const { +SkColorFilter* SkTable_ColorFilter::newComposed(const SkColorFilter* innerFilter) const { SkBitmap innerBM; if (!innerFilter->asComponentTable(&innerBM)) { return nullptr; @@ -326,7 +326,7 @@ sk_sp<SkColorFilter> SkTable_ColorFilter::makeComposed(sk_sp<SkColorFilter> inne combine_tables(concatG, tableG, innerBM.getAddr8(0, 2)); combine_tables(concatB, tableB, innerBM.getAddr8(0, 3)); - return SkTableColorFilter::MakeARGB(concatA, concatR, concatG, concatB); + return SkTableColorFilter::CreateARGB(concatA, concatR, concatG, concatB); } #if SK_SUPPORT_GPU @@ -554,7 +554,7 @@ const GrFragmentProcessor* ColorTableEffect::TestCreate(GrProcessorTestData* d) } } } - auto filter(SkTableColorFilter::MakeARGB( + SkAutoTUnref<SkColorFilter> filter(SkTableColorFilter::CreateARGB( (flags & (1 << 0)) ? luts[0] : nullptr, (flags & (1 << 1)) ? luts[1] : nullptr, (flags & (1 << 2)) ? luts[2] : nullptr, @@ -587,15 +587,15 @@ const GrFragmentProcessor* SkTable_ColorFilter::asFragmentProcessor(GrContext* c /////////////////////////////////////////////////////////////////////////////// -sk_sp<SkColorFilter> SkTableColorFilter::Make(const uint8_t table[256]) { - return sk_make_sp<SkTable_ColorFilter>(table, table, table, table); +SkColorFilter* SkTableColorFilter::Create(const uint8_t table[256]) { + return new SkTable_ColorFilter(table, table, table, table); } -sk_sp<SkColorFilter> SkTableColorFilter::MakeARGB(const uint8_t tableA[256], - const uint8_t tableR[256], - const uint8_t tableG[256], - const uint8_t tableB[256]) { - return sk_make_sp<SkTable_ColorFilter>(tableA, tableR, tableG, tableB); +SkColorFilter* SkTableColorFilter::CreateARGB(const uint8_t tableA[256], + const uint8_t tableR[256], + const uint8_t tableG[256], + const uint8_t tableB[256]) { + return new SkTable_ColorFilter(tableA, tableR, tableG, tableB); } SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkTableColorFilter) diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp index 66048ff751..514cd88408 100644 --- a/src/pdf/SkPDFDevice.cpp +++ b/src/pdf/SkPDFDevice.cpp @@ -2114,7 +2114,8 @@ static SkSize rect_to_size(const SkRect& r) { return SkSize::Make(r.width(), r.height()); } -static const SkImage* color_filter(const SkImage* image, SkColorFilter* colorFilter) { +static const SkImage* color_filter(const SkImage* image, + SkColorFilter* colorFilter) { sk_sp<SkSurface> surface(SkSurface::NewRaster( SkImageInfo::MakeN32Premul(image->dimensions()))); if (!surface) { @@ -2123,7 +2124,7 @@ static const SkImage* color_filter(const SkImage* image, SkColorFilter* colorFil SkCanvas* canvas = surface->getCanvas(); canvas->clear(SK_ColorTRANSPARENT); SkPaint paint; - paint.setColorFilter(sk_ref_sp(colorFilter)); + paint.setColorFilter(colorFilter); canvas->drawImage(image, 0, 0, &paint); canvas->flush(); return surface->makeImageSnapshot().release(); diff --git a/src/utils/SkLua.cpp b/src/utils/SkLua.cpp index d0b6a4b1ac..56e2b41a45 100644 --- a/src/utils/SkLua.cpp +++ b/src/utils/SkLua.cpp @@ -1114,7 +1114,7 @@ static int lpaint_getColorFilter(lua_State* L) { static int lpaint_setColorFilter(lua_State* L) { SkPaint* paint = get_obj<SkPaint>(L, 1); - paint->setColorFilter(sk_ref_sp(get_ref<SkColorFilter>(L, 2))); + paint->setColorFilter(get_ref<SkColorFilter>(L, 2)); return 0; } diff --git a/src/utils/SkRGBAToYUV.cpp b/src/utils/SkRGBAToYUV.cpp index eebbda4869..b7f78bac14 100644 --- a/src/utils/SkRGBAToYUV.cpp +++ b/src/utils/SkRGBAToYUV.cpp @@ -49,7 +49,7 @@ bool SkRGBAToYUV(const SkImage* image, const SkISize sizes[3], void* const plane int rowStartIdx = 5 * i; const SkScalar* row = kYUVColorSpaceInvMatrices[colorSpace] + rowStartIdx; paint.setColorFilter( - SkColorMatrixFilterRowMajor255::MakeSingleChannelOutput(row)); + SkColorMatrixFilterRowMajor255::CreateSingleChannelOutput(row))->unref(); surface->getCanvas()->drawImageRect(image, SkIRect::MakeWH(image->width(), image->height()), SkRect::MakeIWH(surface->width(), surface->height()), &paint); diff --git a/tests/ColorFilterTest.cpp b/tests/ColorFilterTest.cpp index 822fb0bd70..ee8f12b2fb 100644 --- a/tests/ColorFilterTest.cpp +++ b/tests/ColorFilterTest.cpp @@ -15,7 +15,7 @@ #include "SkXfermode.h" #include "Test.h" -static sk_sp<SkColorFilter> reincarnate_colorfilter(SkFlattenable* obj) { +static SkColorFilter* reincarnate_colorfilter(SkFlattenable* obj) { SkWriteBuffer wb; wb.writeFlattenable(obj); @@ -30,18 +30,18 @@ static sk_sp<SkColorFilter> reincarnate_colorfilter(SkFlattenable* obj) { /////////////////////////////////////////////////////////////////////////////// -static sk_sp<SkColorFilter> make_filter() { +static SkColorFilter* make_filter() { // pick a filter that cannot compose with itself via newComposed() - return SkColorFilter::MakeModeFilter(SK_ColorRED, SkXfermode::kColorBurn_Mode); + return SkColorFilter::CreateModeFilter(SK_ColorRED, SkXfermode::kColorBurn_Mode); } static void test_composecolorfilter_limit(skiatest::Reporter* reporter) { // Test that CreateComposeFilter() has some finite limit (i.e. that the factory can return null) const int way_too_many = 100; - auto parent(make_filter()); + SkAutoTUnref<SkColorFilter> parent(make_filter()); for (int i = 2; i < way_too_many; ++i) { - auto filter(make_filter()); - parent = SkColorFilter::MakeComposeFilter(parent, filter); + SkAutoTUnref<SkColorFilter> filter(make_filter()); + parent.reset(SkColorFilter::CreateComposeFilter(parent, filter)); if (nullptr == parent) { REPORTER_ASSERT(reporter, i > 2); // we need to have succeeded at least once! return; @@ -62,13 +62,15 @@ DEF_TEST(ColorFilter, reporter) { // special case that would return nullptr (if color's alpha is 0 or 0xFF) color = SkColorSetA(color, 0x7F); - auto cf = SkColorFilter::MakeModeFilter(color, (SkXfermode::Mode)mode); + SkColorFilter* cf = SkColorFilter::CreateModeFilter(color, + (SkXfermode::Mode)mode); // allow for no filter if we're in Dst mode (its a no op) if (SkXfermode::kDst_Mode == mode && nullptr == cf) { continue; } + SkAutoUnref aur(cf); REPORTER_ASSERT(reporter, cf); SkColor c = ~color; @@ -96,7 +98,8 @@ DEF_TEST(ColorFilter, reporter) { REPORTER_ASSERT(reporter, m == expectedMode); { - auto cf2 = reincarnate_colorfilter(cf.get()); + SkColorFilter* cf2 = reincarnate_colorfilter(cf); + SkAutoUnref aur2(cf2); REPORTER_ASSERT(reporter, cf2); SkColor c2 = ~color; @@ -114,7 +117,7 @@ DEF_TEST(ColorFilter, reporter) { DEF_TEST(LumaColorFilter, reporter) { SkPMColor in, out; - auto lf(SkLumaColorFilter::Make()); + SkAutoTUnref<SkColorFilter> lf(SkLumaColorFilter::Create()); // Applying luma to white produces black with the same transparency. for (unsigned i = 0; i < 256; ++i) { @@ -180,31 +183,31 @@ static void get_grayscale_matrix(float amount, float matrix[20]) { matrix[18] = 1.f; } -static sk_sp<SkColorFilter> make_cf0() { +static SkColorFilter* make_cf0() { SkScalar matrix[20]; get_brightness_matrix(0.5f, matrix); - return SkColorFilter::MakeMatrixFilterRowMajor255(matrix); + return SkColorMatrixFilter::Create(matrix); } -static sk_sp<SkColorFilter> make_cf1() { +static SkColorFilter* make_cf1() { SkScalar matrix[20]; get_grayscale_matrix(1, matrix); - return SkColorFilter::MakeMatrixFilterRowMajor255(matrix); + return SkColorMatrixFilter::Create(matrix); } -static sk_sp<SkColorFilter> make_cf2() { +static SkColorFilter* make_cf2() { SkColorMatrix m0, m1; get_brightness_matrix(0.5f, m0.fMat); get_grayscale_matrix(1, m1.fMat); m0.preConcat(m1); - return SkColorFilter::MakeMatrixFilterRowMajor255(m0.fMat); + return SkColorMatrixFilter::Create(m0); } -static sk_sp<SkColorFilter> make_cf3() { +static SkColorFilter* make_cf3() { SkColorMatrix m0, m1; get_brightness_matrix(0.5f, m0.fMat); get_grayscale_matrix(1, m1.fMat); m0.postConcat(m1); - return SkColorFilter::MakeMatrixFilterRowMajor255(m0.fMat); + return SkColorMatrixFilter::Create(m0); } -typedef sk_sp<SkColorFilter> (*CFProc)(); +typedef SkColorFilter* (*CFProc)(); // Test that a colormatrix that "should" preserve opaquness actually does. DEF_TEST(ColorMatrixFilter, reporter) { @@ -213,7 +216,7 @@ DEF_TEST(ColorMatrixFilter, reporter) { }; for (size_t i = 0; i < SK_ARRAY_COUNT(procs); ++i) { - auto cf(procs[i]()); + SkAutoTUnref<SkColorFilter> cf(procs[i]()); // generate all possible r,g,b triples for (int r = 0; r < 256; ++r) { diff --git a/tests/ColorMatrixTest.cpp b/tests/ColorMatrixTest.cpp index 7919b40242..1eea4f5a9d 100644 --- a/tests/ColorMatrixTest.cpp +++ b/tests/ColorMatrixTest.cpp @@ -45,7 +45,7 @@ static inline void test_colorMatrixCTS(skiatest::Reporter* reporter) { 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f }; - paint.setColorFilter(SkColorFilter::MakeMatrixFilterRowMajor255(blueToCyan)); + paint.setColorFilter(SkColorMatrixFilter::Create(blueToCyan))->unref(); paint.setColor(SK_ColorBLUE); canvas.drawPoint(0, 0, paint); @@ -70,7 +70,7 @@ static inline void test_colorMatrixCTS(skiatest::Reporter* reporter) { 0.0f, 0.0f, 1.0f, 0.0f, 64.0f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f }; - paint.setColorFilter(SkColorFilter::MakeMatrixFilterRowMajor255(transparentRedAddBlue)); + paint.setColorFilter(SkColorMatrixFilter::Create(transparentRedAddBlue))->unref(); bitmap.eraseColor(SK_ColorTRANSPARENT); paint.setColor(SK_ColorRED); @@ -91,7 +91,7 @@ static inline void test_colorMatrixCTS(skiatest::Reporter* reporter) { assert_color(reporter, SK_ColorCYAN, bitmap.getColor(0, 0)); // create a new filter with the changed matrix - paint.setColorFilter(SkColorFilter::MakeMatrixFilterRowMajor255(transparentRedAddBlue)); + paint.setColorFilter(SkColorMatrixFilter::Create(transparentRedAddBlue))->unref(); canvas.drawPoint(0, 0, paint); assert_color(reporter, SK_ColorBLUE, bitmap.getColor(0, 0)); } diff --git a/tests/GpuColorFilterTest.cpp b/tests/GpuColorFilterTest.cpp index 714555a626..830c7dfff3 100644 --- a/tests/GpuColorFilterTest.cpp +++ b/tests/GpuColorFilterTest.cpp @@ -99,7 +99,8 @@ DEF_GPUTEST_FOR_ALL_CONTEXTS(GpuColorFilter, reporter, context) { GrPaint paint; for (size_t i = 0; i < SK_ARRAY_COUNT(filterTests); ++i) { const GetConstantComponentTestCase& test = filterTests[i]; - auto cf(SkColorFilter::MakeModeFilter(test.filterColor, test.filterMode)); + SkAutoTUnref<SkColorFilter> cf( + SkColorFilter::CreateModeFilter(test.filterColor, test.filterMode)); SkAutoTUnref<const GrFragmentProcessor> fp( cf->asFragmentProcessor(context)); REPORTER_ASSERT(reporter, fp); GrInvariantOutput inout(test.inputColor, diff --git a/tests/ImageFilterTest.cpp b/tests/ImageFilterTest.cpp index c2230b7cdb..fd916cfeb3 100644 --- a/tests/ImageFilterTest.cpp +++ b/tests/ImageFilterTest.cpp @@ -137,8 +137,8 @@ static SkImageFilter* make_scale(float amount, SkImageFilter* input = nullptr) { 0, s, 0, 0, 0, 0, 0, s, 0, 0, 0, 0, 0, s, 0 }; - auto filter(SkColorFilter::MakeMatrixFilterRowMajor255(matrix)); - return SkColorFilterImageFilter::Create(filter.get(), input); + SkAutoTUnref<SkColorFilter> filter(SkColorMatrixFilter::Create(matrix)); + return SkColorFilterImageFilter::Create(filter, input); } static SkImageFilter* make_grayscale(SkImageFilter* input, const SkImageFilter::CropRect* cropRect) { @@ -148,13 +148,14 @@ static SkImageFilter* make_grayscale(SkImageFilter* input, const SkImageFilter:: 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, cropRect); + SkAutoTUnref<SkColorFilter> filter(SkColorMatrixFilter::Create(matrix)); + return SkColorFilterImageFilter::Create(filter, input, cropRect); } static SkImageFilter* make_blue(SkImageFilter* input, const SkImageFilter::CropRect* cropRect) { - auto filter(SkColorFilter::MakeModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode)); - return SkColorFilterImageFilter::Create(filter.get(), input, cropRect); + SkAutoTUnref<SkColorFilter> filter(SkColorFilter::CreateModeFilter(SK_ColorBLUE, + SkXfermode::kSrcIn_Mode)); + return SkColorFilterImageFilter::Create(filter, input, cropRect); } static sk_sp<SkSpecialSurface> create_empty_special_surface(GrContext* context, @@ -257,9 +258,9 @@ DEF_TEST(ImageFilter, reporter) { blueToRedMatrix[2] = blueToRedMatrix[18] = SK_Scalar1; SkScalar redToGreenMatrix[20] = { 0 }; redToGreenMatrix[5] = redToGreenMatrix[18] = SK_Scalar1; - auto blueToRed(SkColorFilter::MakeMatrixFilterRowMajor255(blueToRedMatrix)); + SkAutoTUnref<SkColorFilter> blueToRed(SkColorMatrixFilter::Create(blueToRedMatrix)); SkAutoTUnref<SkImageFilter> filter1(SkColorFilterImageFilter::Create(blueToRed.get())); - auto redToGreen(SkColorFilter::MakeMatrixFilterRowMajor255(redToGreenMatrix)); + SkAutoTUnref<SkColorFilter> redToGreen(SkColorMatrixFilter::Create(redToGreenMatrix)); SkAutoTUnref<SkImageFilter> filter2(SkColorFilterImageFilter::Create(redToGreen.get(), filter1.get())); SkBitmap result; @@ -319,7 +320,7 @@ static void test_crop_rects(SkImageFilter::Proxy* proxy, SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(20, 30, 60, 60)); SkAutoTUnref<SkImageFilter> input(make_grayscale(nullptr, &inputCropRect)); - auto cf(SkColorFilter::MakeModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode)); + SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode)); SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1); SkScalar kernel[9] = { SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1), @@ -563,7 +564,7 @@ DEF_TEST(ImageFilterDrawTiled, reporter) { // match the same filters drawn with a single full-canvas bitmap draw. // Tests pass by not asserting. - auto cf(SkColorFilter::MakeModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode)); + SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode)); SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1); SkScalar kernel[9] = { SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1), @@ -692,7 +693,7 @@ static void draw_saveLayer_picture(int width, int height, int tileSize, SkMatrix matrix; matrix.setTranslate(SkIntToScalar(50), 0); - auto cf(SkColorFilter::MakeModeFilter(SK_ColorWHITE, SkXfermode::kSrc_Mode)); + SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorWHITE, SkXfermode::kSrc_Mode)); SkAutoTUnref<SkImageFilter> cfif(SkColorFilterImageFilter::Create(cf.get())); SkAutoTUnref<SkImageFilter> imageFilter(SkImageFilter::CreateMatrixFilter(matrix, kNone_SkFilterQuality, cfif.get())); @@ -1121,13 +1122,14 @@ DEF_TEST(ImageFilterEmptySaveLayer, reporter) { SkRTreeFactory factory; SkPictureRecorder recorder; - auto green(SkColorFilter::MakeModeFilter(SK_ColorGREEN, SkXfermode::kSrc_Mode)); + SkAutoTUnref<SkColorFilter> green( + SkColorFilter::CreateModeFilter(SK_ColorGREEN, SkXfermode::kSrc_Mode)); SkAutoTUnref<SkImageFilter> imageFilter( SkColorFilterImageFilter::Create(green.get())); SkPaint imageFilterPaint; imageFilterPaint.setImageFilter(imageFilter.get()); SkPaint colorFilterPaint; - colorFilterPaint.setColorFilter(green); + colorFilterPaint.setColorFilter(green.get()); SkRect bounds = SkRect::MakeWH(10, 10); @@ -1243,7 +1245,8 @@ static void test_xfermode_cropped_input(SkCanvas* canvas, skiatest::Reporter* re bitmap.allocN32Pixels(1, 1); bitmap.eraseARGB(255, 255, 255, 255); - auto green(SkColorFilter::MakeModeFilter(SK_ColorGREEN, SkXfermode::kSrcIn_Mode)); + SkAutoTUnref<SkColorFilter> green( + SkColorFilter::CreateModeFilter(SK_ColorGREEN, SkXfermode::kSrcIn_Mode)); SkAutoTUnref<SkImageFilter> greenFilter(SkColorFilterImageFilter::Create(green.get())); SkImageFilter::CropRect cropRect(SkRect::MakeEmpty()); SkAutoTUnref<SkImageFilter> croppedOut( @@ -1464,8 +1467,8 @@ DEF_TEST(ImageFilterCanComputeFastBounds, reporter) { 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())); + SkAutoTUnref<SkColorFilter> greenCF(SkColorMatrixFilter::Create(greenMatrix)); + SkAutoTUnref<SkImageFilter> green(SkColorFilterImageFilter::Create(greenCF)); REPORTER_ASSERT(reporter, greenCF->affectsTransparentBlack()); REPORTER_ASSERT(reporter, !green->canComputeFastBounds()); @@ -1479,12 +1482,14 @@ DEF_TEST(ImageFilterCanComputeFastBounds, reporter) { allOne[i] = 255; } - auto identityCF(SkTableColorFilter::MakeARGB(identity, identity, identity, allOne)); + SkAutoTUnref<SkColorFilter> identityCF( + SkTableColorFilter::CreateARGB(identity, identity, identity, allOne)); SkAutoTUnref<SkImageFilter> identityFilter(SkColorFilterImageFilter::Create(identityCF.get())); REPORTER_ASSERT(reporter, !identityCF->affectsTransparentBlack()); REPORTER_ASSERT(reporter, identityFilter->canComputeFastBounds()); - auto forceOpaqueCF(SkTableColorFilter::MakeARGB(allOne, identity, identity, identity)); + SkAutoTUnref<SkColorFilter> forceOpaqueCF( + SkTableColorFilter::CreateARGB(allOne, identity, identity, identity)); SkAutoTUnref<SkImageFilter> forceOpaque(SkColorFilterImageFilter::Create(forceOpaqueCF.get())); REPORTER_ASSERT(reporter, forceOpaqueCF->affectsTransparentBlack()); REPORTER_ASSERT(reporter, !forceOpaque->canComputeFastBounds()); diff --git a/tests/PaintTest.cpp b/tests/PaintTest.cpp index 0e92e65ba3..a58bd864ec 100644 --- a/tests/PaintTest.cpp +++ b/tests/PaintTest.cpp @@ -360,11 +360,11 @@ DEF_TEST(Paint_nothingToDraw, r) { SkColorMatrix cm; cm.setIdentity(); // does not change alpha - paint.setColorFilter(SkColorFilter::MakeMatrixFilterRowMajor255(cm.fMat)); + paint.setColorFilter(SkColorMatrixFilter::Create(cm))->unref(); REPORTER_ASSERT(r, paint.nothingToDraw()); cm.postTranslate(0, 0, 0, 1); // wacks alpha - paint.setColorFilter(SkColorFilter::MakeMatrixFilterRowMajor255(cm.fMat)); + paint.setColorFilter(SkColorMatrixFilter::Create(cm))->unref(); REPORTER_ASSERT(r, !paint.nothingToDraw()); } diff --git a/tests/PictureTest.cpp b/tests/PictureTest.cpp index a57a1b2fb2..58a08ecc34 100644 --- a/tests/PictureTest.cpp +++ b/tests/PictureTest.cpp @@ -278,7 +278,7 @@ static void test_savelayer_extraction(skiatest::Reporter* reporter) { // optimize away SkScalar blueToRedMatrix[20] = { 0 }; blueToRedMatrix[2] = blueToRedMatrix[18] = SK_Scalar1; - auto blueToRed(SkColorFilter::MakeMatrixFilterRowMajor255(blueToRedMatrix)); + SkAutoTUnref<SkColorFilter> blueToRed(SkColorMatrixFilter::Create(blueToRedMatrix)); SkAutoTUnref<SkImageFilter> filter(SkColorFilterImageFilter::Create(blueToRed.get())); SkPaint complexPaint; diff --git a/tests/RecordOptsTest.cpp b/tests/RecordOptsTest.cpp index 77eb76bc02..597639e543 100644 --- a/tests/RecordOptsTest.cpp +++ b/tests/RecordOptsTest.cpp @@ -224,7 +224,7 @@ DEF_TEST(RecordOpts_MergeSvgOpacityAndFilterLayers, r) { xfermodePaint.setXfermodeMode(SkXfermode::kDstIn_Mode); SkPaint colorFilterPaint; colorFilterPaint.setColorFilter( - SkColorFilter::MakeModeFilter(SK_ColorLTGRAY, SkXfermode::kSrcIn_Mode)); + SkColorFilter::CreateModeFilter(SK_ColorLTGRAY, SkXfermode::kSrcIn_Mode))->unref(); SkPaint opaqueFilterLayerPaint; opaqueFilterLayerPaint.setColor(0xFF020202); // Opaque. diff --git a/tests/SerializationTest.cpp b/tests/SerializationTest.cpp index f8d6ea4297..c58020724d 100644 --- a/tests/SerializationTest.cpp +++ b/tests/SerializationTest.cpp @@ -286,7 +286,7 @@ static void TestColorFilterSerialization(skiatest::Reporter* reporter) { for (int i = 0; i < 256; ++i) { table[i] = (i * 41) % 256; } - auto colorFilter(SkTableColorFilter::Make(table)); + SkAutoTUnref<SkColorFilter> colorFilter(SkTableColorFilter::Create(table)); SkAutoTUnref<SkColorFilter> copy( TestFlattenableSerialization<SkColorFilter>(colorFilter.get(), true, reporter)); } diff --git a/tests/SkColor4fTest.cpp b/tests/SkColor4fTest.cpp index 239004aacb..94e1b68816 100644 --- a/tests/SkColor4fTest.cpp +++ b/tests/SkColor4fTest.cpp @@ -78,22 +78,24 @@ DEF_TEST(Color4f_premul, reporter) { ////////////////////////////////////////////////////////////////////////////////////////////////// -static sk_sp<SkColorFilter> make_mode_cf() { - return SkColorFilter::MakeModeFilter(0xFFBB8855, SkXfermode::kPlus_Mode); +static SkColorFilter* make_mode_cf() { + return SkColorFilter::CreateModeFilter(0xFFBB8855, SkXfermode::kPlus_Mode); } -static sk_sp<SkColorFilter> make_mx_cf() { +static SkColorFilter* make_mx_cf() { const float mx[] = { 0.5f, 0, 0, 0, 0.1f, 0, 0.5f, 0, 0, 0.2f, 0, 0, 1, 0, -0.1f, 0, 0, 0, 1, 0, }; - return SkColorFilter::MakeMatrixFilterRowMajor255(mx); + return SkColorMatrixFilter::Create(mx); } -static sk_sp<SkColorFilter> make_compose_cf() { - return SkColorFilter::MakeComposeFilter(make_mode_cf(), make_mx_cf()); +static SkColorFilter* make_compose_cf() { + SkAutoTUnref<SkColorFilter> cf0(make_mode_cf()); + SkAutoTUnref<SkColorFilter> cf1(make_mx_cf()); + return SkColorFilter::CreateComposeFilter(cf0, cf1); } static sk_sp<SkShader> make_color_sh() { return SkShader::MakeColorShader(0xFFBB8855); } @@ -122,7 +124,8 @@ static sk_sp<SkShader> make_grad_sh() { } static sk_sp<SkShader> make_cf_sh() { - return make_color_sh()->makeWithColorFilter(make_mx_cf()); + SkAutoTUnref<SkColorFilter> filter(make_mx_cf()); + return make_color_sh()->makeWithColorFilter(filter); } static bool compare_spans(const SkPM4f span4f[], const SkPMColor span4b[], int count, @@ -175,9 +178,9 @@ DEF_TEST(Color4f_shader, reporter) { DEF_TEST(Color4f_colorfilter, reporter) { struct { - sk_sp<SkColorFilter> (*fFact)(); - bool fSupports4f; - const char* fName; + SkColorFilter* (*fFact)(); + bool fSupports4f; + const char* fName; } recs[] = { { make_mode_cf, true, "mode" }, { make_mx_cf, true, "matrix" }, @@ -197,7 +200,7 @@ DEF_TEST(Color4f_colorfilter, reporter) { REPORTER_ASSERT(reporter, compare_spans(src4f, src4b, N)); for (const auto& rec : recs) { - auto filter(rec.fFact()); + SkAutoTUnref<SkColorFilter> filter(rec.fFact()); SkPMColor dst4b[N]; filter->filterSpan(src4b, N, dst4b); SkPM4f dst4f[N]; diff --git a/tools/android/SkAndroidSDKCanvas.cpp b/tools/android/SkAndroidSDKCanvas.cpp index d7a76ca215..35b1581fda 100644 --- a/tools/android/SkAndroidSDKCanvas.cpp +++ b/tools/android/SkAndroidSDKCanvas.cpp @@ -69,7 +69,7 @@ void Filter(SkPaint* paint) { bool isMode = cf->asColorMode(&color, &mode); if (isMode && mode > SkXfermode::kLighten_Mode) { paint->setColorFilter( - SkColorFilter::MakeModeFilter(color, SkXfermode::kSrcOver_Mode)); + SkColorFilter::CreateModeFilter(color, SkXfermode::kSrcOver_Mode)); } else if (!isMode && !cf->asColorMatrix(srcColorMatrix)) { paint->setColorFilter(nullptr); } diff --git a/tools/debugger/SkDrawCommand.cpp b/tools/debugger/SkDrawCommand.cpp index 5dc6079897..5bacf02b1a 100644 --- a/tools/debugger/SkDrawCommand.cpp +++ b/tools/debugger/SkDrawCommand.cpp @@ -1159,10 +1159,11 @@ static void extract_json_paint_colorfilter(Json::Value& jsonPaint, UrlDataManage SkPaint* target) { if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER)) { Json::Value jsonColorFilter = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER]; - sk_sp<SkColorFilter> colorFilter((SkColorFilter*)load_flattenable(jsonColorFilter, - urlDataManager)); + SkColorFilter* colorFilter = (SkColorFilter*) load_flattenable(jsonColorFilter, + urlDataManager); if (colorFilter != nullptr) { target->setColorFilter(colorFilter); + colorFilter->unref(); } } } |