diff options
68 files changed, 519 insertions, 549 deletions
diff --git a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp index 9e839f10a1..f6885408ad 100644 --- a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp +++ b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp @@ -309,24 +309,27 @@ public: #endif }; -SkShader* SkPerlinNoiseShader2::CreateFractalNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY, - int numOctaves, SkScalar seed, - const SkISize* tileSize) { - return new SkPerlinNoiseShader2(kFractalNoise_Type, baseFrequencyX, baseFrequencyY, numOctaves, - seed, tileSize); +sk_sp<SkShader> SkPerlinNoiseShader2::MakeFractalNoise(SkScalar baseFrequencyX, + SkScalar baseFrequencyY, + int numOctaves, SkScalar seed, + const SkISize* tileSize) { + return sk_sp<SkShader>(new SkPerlinNoiseShader2(kFractalNoise_Type, baseFrequencyX, + baseFrequencyY, numOctaves, seed, tileSize)); } -SkShader* SkPerlinNoiseShader2::CreateTurbulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY, - int numOctaves, SkScalar seed, - const SkISize* tileSize) { - return new SkPerlinNoiseShader2(kTurbulence_Type, baseFrequencyX, baseFrequencyY, numOctaves, - seed, tileSize); +sk_sp<SkShader> SkPerlinNoiseShader2::MakeTurbulence(SkScalar baseFrequencyX, + SkScalar baseFrequencyY, + int numOctaves, SkScalar seed, + const SkISize* tileSize) { + return sk_sp<SkShader>(new SkPerlinNoiseShader2(kTurbulence_Type, baseFrequencyX, + baseFrequencyY, numOctaves, seed, tileSize)); } -SkShader* SkPerlinNoiseShader2::CreateImprovedNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY, - int numOctaves, SkScalar z) { - return new SkPerlinNoiseShader2(kImprovedNoise_Type, baseFrequencyX, baseFrequencyY, numOctaves, - z, NULL); +sk_sp<SkShader> SkPerlinNoiseShader2::MakeImprovedNoise(SkScalar baseFrequencyX, + SkScalar baseFrequencyY, + int numOctaves, SkScalar z) { + return sk_sp<SkShader>(new SkPerlinNoiseShader2(kImprovedNoise_Type, baseFrequencyX, + baseFrequencyY, numOctaves, z, NULL)); } SkPerlinNoiseShader2::SkPerlinNoiseShader2(SkPerlinNoiseShader2::Type type, @@ -361,11 +364,13 @@ SkFlattenable* SkPerlinNoiseShader2::CreateProc(SkReadBuffer& buffer) { switch (type) { case kFractalNoise_Type: - return SkPerlinNoiseShader2::CreateFractalNoise(freqX, freqY, octaves, seed, &tileSize); + return SkPerlinNoiseShader2::MakeFractalNoise(freqX, freqY, octaves, seed, + &tileSize).release(); case kTurbulence_Type: - return SkPerlinNoiseShader2::CreateTubulence(freqX, freqY, octaves, seed, &tileSize); + return SkPerlinNoiseShader2::MakeTubulence(freqX, freqY, octaves, seed, + &tileSize).release(); case kImprovedNoise_Type: - return SkPerlinNoiseShader2::CreateImprovedNoise(freqX, freqY, octaves, seed); + return SkPerlinNoiseShader2::MakeImprovedNoise(freqX, freqY, octaves, seed).release(); default: return nullptr; } @@ -717,10 +722,10 @@ const GrFragmentProcessor* GrPerlinNoise2Effect::TestCreate(GrProcessorTestData* SkScalar baseFrequencyY = d->fRandom->nextRangeScalar(0.01f, 0.99f); - SkAutoTUnref<SkShader> shader(d->fRandom->nextBool() ? - SkPerlinNoiseShader2::CreateFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves, seed, - stitchTiles ? &tileSize : nullptr) : - SkPerlinNoiseShader2::CreateTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed, + sk_sp<SkShader> shader(d->fRandom->nextBool() ? + SkPerlinNoiseShader2::MakeFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves, seed, + stitchTiles ? &tileSize : nullptr) : + SkPerlinNoiseShader2::MakeTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed, stitchTiles ? &tileSize : nullptr)); GrPaint grPaint; @@ -1123,10 +1128,10 @@ const GrFragmentProcessor* GrImprovedPerlinNoiseEffect::TestCreate(GrProcessorTe int numOctaves = d->fRandom->nextRangeU(2, 10); SkScalar z = SkIntToScalar(d->fRandom->nextU()); - SkAutoTUnref<SkShader> shader(SkPerlinNoiseShader2::CreateImprovedNoise(baseFrequencyX, - baseFrequencyY, - numOctaves, - z)); + sk_sp<SkShader> shader(SkPerlinNoiseShader2::MakeImprovedNoise(baseFrequencyX, + baseFrequencyY, + numOctaves, + z)); GrPaint grPaint; return shader->asFragmentProcessor(d->fContext, diff --git a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.h b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.h index fac098ab52..8a51583673 100644 --- a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.h +++ b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.h @@ -61,26 +61,26 @@ public: * the frequencies so that the noise will be tileable for the given tile size. If tileSize * is NULL or an empty size, the frequencies will be used as is without modification. */ - static SkShader* CreateFractalNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY, - int numOctaves, SkScalar seed, - const SkISize* tileSize = NULL); - static SkShader* CreateTurbulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY, - int numOctaves, SkScalar seed, - const SkISize* tileSize = NULL); + static sk_sp<SkShader> MakeFractalNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY, + int numOctaves, SkScalar seed, + const SkISize* tileSize = NULL); + static sk_sp<SkShader> MakeTurbulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY, + int numOctaves, SkScalar seed, + const SkISize* tileSize = NULL); /** * Creates an Improved Perlin Noise shader. The z value is roughly equivalent to the seed of the * other two types, but minor variations to z will only slightly change the noise. */ - static SkShader* CreateImprovedNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY, - int numOctaves, SkScalar z); + static sk_sp<SkShader> MakeImprovedNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY, + int numOctaves, SkScalar z); /** * Create alias for CreateTurbulunce until all Skia users changed * its code to use the new naming */ - static SkShader* CreateTubulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY, - int numOctaves, SkScalar seed, - const SkISize* tileSize = NULL) { - return CreateTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed, tileSize); + static sk_sp<SkShader> MakeTubulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY, + int numOctaves, SkScalar seed, + const SkISize* tileSize = NULL) { + return MakeTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed, tileSize); } class PerlinNoiseShaderContext : public SkShader::Context { diff --git a/gm/alphagradients.cpp b/gm/alphagradients.cpp index 71ec27c975..65fa0c4082 100644 --- a/gm/alphagradients.cpp +++ b/gm/alphagradients.cpp @@ -28,9 +28,8 @@ protected: SkPoint pts[] = { { r.fLeft, r.fTop }, { r.fRight, r.fBottom } }; SkPaint paint; uint32_t flags = doPreMul ? SkGradientShader::kInterpolateColorsInPremul_Flag : 0; - SkShader* s = SkGradientShader::CreateLinear(pts, colors, nullptr, 2, - SkShader::kClamp_TileMode, flags, nullptr); - paint.setShader(s)->unref(); + paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, + SkShader::kClamp_TileMode, flags, nullptr)); canvas->drawRect(r, paint); paint.setShader(nullptr); diff --git a/gm/arithmode.cpp b/gm/arithmode.cpp index eb2ecb8abd..bddd2005f8 100644 --- a/gm/arithmode.cpp +++ b/gm/arithmode.cpp @@ -31,9 +31,8 @@ static SkBitmap make_src() { SK_ColorTRANSPARENT, SK_ColorGREEN, SK_ColorCYAN, SK_ColorRED, SK_ColorMAGENTA, SK_ColorWHITE, }; - SkShader* s = SkGradientShader::CreateLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors), - SkShader::kClamp_TileMode); - paint.setShader(s)->unref(); + paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors), + SkShader::kClamp_TileMode)); canvas.drawPaint(paint); return bm; } @@ -47,9 +46,8 @@ static SkBitmap make_dst() { SK_ColorBLUE, SK_ColorYELLOW, SK_ColorBLACK, SK_ColorGREEN, sk_tool_utils::color_to_565(SK_ColorGRAY) }; - SkShader* s = SkGradientShader::CreateLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors), - SkShader::kClamp_TileMode); - paint.setShader(s)->unref(); + paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors), + SkShader::kClamp_TileMode)); canvas.drawPaint(paint); return bm; } diff --git a/gm/badpaint.cpp b/gm/badpaint.cpp index 7c51c749ee..85eaa1ed10 100644 --- a/gm/badpaint.cpp +++ b/gm/badpaint.cpp @@ -32,14 +32,13 @@ protected: // Empty bitmap. fPaints.push_back().setColor(SK_ColorGREEN); - fPaints.back().setShader(SkShader::CreateBitmapShader(emptyBmp, SkShader::kClamp_TileMode, - SkShader::kClamp_TileMode))->unref(); + fPaints.back().setShader(SkShader::MakeBitmapShader(emptyBmp, SkShader::kClamp_TileMode, + SkShader::kClamp_TileMode)); // Non-invertible local matrix. fPaints.push_back().setColor(SK_ColorGREEN); - fPaints.back().setShader(SkShader::CreateBitmapShader(blueBmp, SkShader::kClamp_TileMode, - SkShader::kClamp_TileMode, - &badMatrix))->unref(); + fPaints.back().setShader(SkShader::MakeBitmapShader(blueBmp, SkShader::kClamp_TileMode, + SkShader::kClamp_TileMode, &badMatrix)); } void onDraw(SkCanvas* canvas) override { diff --git a/gm/bitmapshader.cpp b/gm/bitmapshader.cpp index 5d7b35c2cd..491905afb3 100644 --- a/gm/bitmapshader.cpp +++ b/gm/bitmapshader.cpp @@ -35,11 +35,6 @@ static void draw_mask(SkBitmap* bm) { canvas.drawCircle(10, 10, 10, circlePaint); } -static void adopt_shader(SkPaint* paint, SkShader* shader) { - paint->setShader(shader); - SkSafeUnref(shader); -} - class BitmapShaderGM : public GM { protected: @@ -69,8 +64,8 @@ protected: } canvas->save(); - adopt_shader(&paint, SkShader::CreateBitmapShader(fBitmap, SkShader::kClamp_TileMode, - SkShader::kClamp_TileMode, &s)); + paint.setShader(SkShader::MakeBitmapShader(fBitmap, SkShader::kClamp_TileMode, + SkShader::kClamp_TileMode, &s)); // draw the shader with a bitmap mask canvas->drawBitmap(fMask, 0, 0, &paint); @@ -91,8 +86,8 @@ protected: canvas->translate(0, 25); - adopt_shader(&paint, SkShader::CreateBitmapShader(fMask, SkShader::kRepeat_TileMode, - SkShader::kRepeat_TileMode, &s)); + paint.setShader(SkShader::MakeBitmapShader(fMask, SkShader::kRepeat_TileMode, + SkShader::kRepeat_TileMode, &s)); paint.setColor(SK_ColorRED); // draw the mask using the shader and a color @@ -85,10 +85,9 @@ void GM::DrawGpuOnlyMessage(SkCanvas* canvas) { SkMatrix localM; localM.setRotate(35.f); localM.postTranslate(10.f, 0.f); - SkAutoTUnref<SkShader> shader(SkShader::CreateBitmapShader(bmp, SkShader::kMirror_TileMode, - SkShader::kMirror_TileMode, - &localM)); - paint.setShader(shader); + paint.setShader(SkShader::MakeBitmapShader(bmp, SkShader::kMirror_TileMode, + SkShader::kMirror_TileMode, + &localM)); paint.setFilterQuality(kMedium_SkFilterQuality); canvas->drawPaint(paint); return; diff --git a/gm/lcdblendmodes.cpp b/gm/lcdblendmodes.cpp index a2405349eb..d7a9024204 100644 --- a/gm/lcdblendmodes.cpp +++ b/gm/lcdblendmodes.cpp @@ -48,9 +48,7 @@ protected: } void onOnceBeforeDraw() override { - fCheckerboard.reset(sk_tool_utils::create_checkerboard_shader(SK_ColorBLACK, - SK_ColorWHITE, - 4)); + fCheckerboard = sk_tool_utils::create_checkerboard_shader(SK_ColorBLACK, SK_ColorWHITE, 4); } SkISize onISize() override { return SkISize::Make(kWidth, kHeight); } @@ -148,7 +146,7 @@ protected: private: SkScalar fTextHeight; - SkAutoTUnref<SkShader> fCheckerboard; + sk_sp<SkShader> fCheckerboard; typedef skiagm::GM INHERITED; }; diff --git a/gm/pixelsnap.cpp b/gm/pixelsnap.cpp index 5f1a745b14..7791acb0d0 100644 --- a/gm/pixelsnap.cpp +++ b/gm/pixelsnap.cpp @@ -37,7 +37,7 @@ protected: bgPaint.setShader( sk_tool_utils::create_checkerboard_shader( sk_tool_utils::color_to_565(0xFFAAAAAA), - sk_tool_utils::color_to_565(0xFF777777), 1))->unref(); + sk_tool_utils::color_to_565(0xFF777777), 1)); canvas->drawPaint(bgPaint); SkString offset; diff --git a/include/core/SkShader.h b/include/core/SkShader.h index 828467fec2..3e4093645c 100644 --- a/include/core/SkShader.h +++ b/include/core/SkShader.h @@ -23,6 +23,8 @@ class SkXfermode; class GrContext; class GrFragmentProcessor; +#define SK_SUPPORT_LEGACY_CREATESHADER_PTR + /** \class SkShader * * Shaders specify the source color(s) for what is being drawn. If a paint @@ -335,25 +337,39 @@ public: /** * Call this to create a new "empty" shader, that will not draw anything. */ - static SkShader* CreateEmptyShader(); + static sk_sp<SkShader> MakeEmptyShader(); /** * Call this to create a new shader that just draws the specified color. This should always * draw the same as a paint with this color (and no shader). */ - static SkShader* CreateColorShader(SkColor); + static sk_sp<SkShader> MakeColorShader(SkColor); + + static sk_sp<SkShader> MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src, + SkXfermode::Mode); - static SkShader* CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode::Mode); +#ifdef SK_SUPPORT_LEGACY_CREATESHADER_PTR + static SkShader* CreateEmptyShader() { return MakeEmptyShader().release(); } + static SkShader* CreateColorShader(SkColor c) { return MakeColorShader(c).release(); } + static SkShader* CreateBitmapShader(const SkBitmap& src, TileMode tmx, TileMode tmy, + const SkMatrix* localMatrix = nullptr) { + return MakeBitmapShader(src, tmx, tmy, localMatrix).release(); + } + static SkShader* CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode::Mode mode); + static SkShader* CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode* xfer); + static SkShader* CreatePictureShader(const SkPicture* src, TileMode tmx, TileMode tmy, + const SkMatrix* localMatrix, const SkRect* tile); +#endif /** * Create a new compose shader, given shaders dst, src, and a combining xfermode mode. * The xfermode is called with the output of the two shaders, and its output is returned. * If xfer is null, SkXfermode::kSrcOver_Mode is assumed. * - * Ownership of the shaders, and the xfermode if not null, is not transfered, so the caller - * is still responsible for managing its reference-count for those objects. + * The caller is responsible for managing its reference-count for the xfer (if not null). */ - static SkShader* CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode* xfer); + static sk_sp<SkShader> MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src, + SkXfermode* xfer); /** Call this to create a new shader that will draw with the specified bitmap. * @@ -369,9 +385,8 @@ public: * @param tmy The tiling mode to use when sampling the bitmap in the y-direction. * @return Returns a new shader object. Note: this function never returns null. */ - static SkShader* CreateBitmapShader(const SkBitmap& src, - TileMode tmx, TileMode tmy, - const SkMatrix* localMatrix = NULL); + static sk_sp<SkShader> MakeBitmapShader(const SkBitmap& src, TileMode tmx, TileMode tmy, + const SkMatrix* localMatrix = nullptr); // NOTE: You can create an SkImage Shader with SkImage::newShader(). @@ -389,10 +404,8 @@ public: * bounds. * @return Returns a new shader object. Note: this function never returns null. */ - static SkShader* CreatePictureShader(const SkPicture* src, - TileMode tmx, TileMode tmy, - const SkMatrix* localMatrix, - const SkRect* tile); + static sk_sp<SkShader> MakePictureShader(sk_sp<const SkPicture> src, TileMode tmx, TileMode tmy, + const SkMatrix* localMatrix, const SkRect* tile); /** * If this shader can be represented by another shader + a localMatrix, return that shader diff --git a/include/effects/SkGradientShader.h b/include/effects/SkGradientShader.h index ae11e2dafd..e474f38a4e 100644 --- a/include/effects/SkGradientShader.h +++ b/include/effects/SkGradientShader.h @@ -42,15 +42,14 @@ public: @param count Must be >=2. The number of colors (and pos if not NULL) entries. @param mode The tiling mode */ - static SkShader* CreateLinear(const SkPoint pts[2], - const SkColor colors[], const SkScalar pos[], int count, - SkShader::TileMode mode, - uint32_t flags, const SkMatrix* localMatrix); - - static SkShader* CreateLinear(const SkPoint pts[2], - const SkColor colors[], const SkScalar pos[], int count, - SkShader::TileMode mode) { - return CreateLinear(pts, colors, pos, count, mode, 0, NULL); + static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], + const SkColor colors[], const SkScalar pos[], int count, + SkShader::TileMode mode, + uint32_t flags, const SkMatrix* localMatrix); + static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], + const SkColor colors[], const SkScalar pos[], int count, + SkShader::TileMode mode) { + return MakeLinear(pts, colors, pos, count, mode, 0, NULL); } /** Returns a shader that generates a radial gradient given the center and radius. @@ -69,15 +68,14 @@ public: @param count Must be >= 2. The number of colors (and pos if not NULL) entries @param mode The tiling mode */ - static SkShader* CreateRadial(const SkPoint& center, SkScalar radius, - const SkColor colors[], const SkScalar pos[], int count, - SkShader::TileMode mode, - uint32_t flags, const SkMatrix* localMatrix); - - static SkShader* CreateRadial(const SkPoint& center, SkScalar radius, - const SkColor colors[], const SkScalar pos[], int count, - SkShader::TileMode mode) { - return CreateRadial(center, radius, colors, pos, count, mode, 0, NULL); + static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius, + const SkColor colors[], const SkScalar pos[], int count, + SkShader::TileMode mode, + uint32_t flags, const SkMatrix* localMatrix); + static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius, + const SkColor colors[], const SkScalar pos[], int count, + SkShader::TileMode mode) { + return MakeRadial(center, radius, colors, pos, count, mode, 0, NULL); } /** @@ -86,18 +84,17 @@ public: * two circles according to the following HTML spec. * http://dev.w3.org/html5/2dcontext/#dom-context-2d-createradialgradient */ - static SkShader* CreateTwoPointConical(const SkPoint& start, SkScalar startRadius, - const SkPoint& end, SkScalar endRadius, - const SkColor colors[], const SkScalar pos[], int count, - SkShader::TileMode mode, - uint32_t flags, const SkMatrix* localMatrix); - - static SkShader* CreateTwoPointConical(const SkPoint& start, SkScalar startRadius, - const SkPoint& end, SkScalar endRadius, - const SkColor colors[], const SkScalar pos[], int count, - SkShader::TileMode mode) { - return CreateTwoPointConical(start, startRadius, end, endRadius, colors, pos, count, mode, - 0, NULL); + static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius, + const SkPoint& end, SkScalar endRadius, + const SkColor colors[], const SkScalar pos[], + int count, SkShader::TileMode mode, + uint32_t flags, const SkMatrix* localMatrix); + static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius, + const SkPoint& end, SkScalar endRadius, + const SkColor colors[], const SkScalar pos[], + int count, SkShader::TileMode mode) { + return MakeTwoPointConical(start, startRadius, end, endRadius, colors, pos, count, mode, + 0, NULL); } /** Returns a shader that generates a sweep gradient given a center. @@ -115,14 +112,67 @@ public: intermediate values must be strictly increasing. @param count Must be >= 2. The number of colors (and pos if not NULL) entries */ + static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy, + const SkColor colors[], const SkScalar pos[], int count, + uint32_t flags, const SkMatrix* localMatrix); + static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy, + const SkColor colors[], const SkScalar pos[], int count) { + return MakeSweep(cx, cy, colors, pos, count, 0, NULL); + } + +#ifdef SK_SUPPORT_LEGACY_CREATESHADER_PTR + static SkShader* CreateLinear(const SkPoint pts[2], + const SkColor colors[], const SkScalar pos[], int count, + SkShader::TileMode mode, + uint32_t flags, const SkMatrix* localMatrix) { + return MakeLinear(pts, colors, pos, count, mode, flags, localMatrix).release(); + } + static SkShader* CreateLinear(const SkPoint pts[2], + const SkColor colors[], const SkScalar pos[], int count, + SkShader::TileMode mode) { + return CreateLinear(pts, colors, pos, count, mode, 0, NULL); + } + + static SkShader* CreateRadial(const SkPoint& center, SkScalar radius, + const SkColor colors[], const SkScalar pos[], int count, + SkShader::TileMode mode, + uint32_t flags, const SkMatrix* localMatrix) { + return MakeRadial(center, radius, colors, pos, count, mode, flags, localMatrix).release(); + } + + static SkShader* CreateRadial(const SkPoint& center, SkScalar radius, + const SkColor colors[], const SkScalar pos[], int count, + SkShader::TileMode mode) { + return CreateRadial(center, radius, colors, pos, count, mode, 0, NULL); + } + + static SkShader* CreateTwoPointConical(const SkPoint& start, SkScalar startRadius, + const SkPoint& end, SkScalar endRadius, + const SkColor colors[], const SkScalar pos[], int count, + SkShader::TileMode mode, + uint32_t flags, const SkMatrix* localMatrix) { + return MakeTwoPointConical(start, startRadius, end, endRadius, colors, pos, count, mode, + flags, localMatrix).release(); + } + static SkShader* CreateTwoPointConical(const SkPoint& start, SkScalar startRadius, + const SkPoint& end, SkScalar endRadius, + const SkColor colors[], const SkScalar pos[], int count, + SkShader::TileMode mode) { + return CreateTwoPointConical(start, startRadius, end, endRadius, colors, pos, count, mode, + 0, NULL); + } + static SkShader* CreateSweep(SkScalar cx, SkScalar cy, const SkColor colors[], const SkScalar pos[], int count, - uint32_t flags, const SkMatrix* localMatrix); - + uint32_t flags, const SkMatrix* localMatrix) { + return MakeSweep(cx, cy, colors, pos, count, flags, localMatrix).release(); + } static SkShader* CreateSweep(SkScalar cx, SkScalar cy, const SkColor colors[], const SkScalar pos[], int count) { return CreateSweep(cx, cy, colors, pos, count, 0, NULL); } +#endif + SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP() }; diff --git a/samplecode/PerlinPatch.cpp b/samplecode/PerlinPatch.cpp index de4d451648..ad2d6bede0 100644 --- a/samplecode/PerlinPatch.cpp +++ b/samplecode/PerlinPatch.cpp @@ -60,9 +60,9 @@ const SkScalar TexWidth = 100.0f; const SkScalar TexHeight = 100.0f; class PerlinPatchView : public SampleView { - SkShader* fShader0; - SkShader* fShader1; - SkShader* fShaderCompose; + sk_sp<SkShader> fShader0; + sk_sp<SkShader> fShader1; + sk_sp<SkShader> fShaderCompose; SkScalar fXFreq; SkScalar fYFreq; SkScalar fSeed; @@ -98,7 +98,7 @@ public: }; const SkPoint points[2] = { SkPoint::Make(0.0f, 0.0f), SkPoint::Make(100.0f, 100.0f) }; - fShader0 = SkGradientShader::CreateLinear(points, + fShader0 = SkGradientShader::MakeLinear(points, colors, NULL, 3, @@ -107,9 +107,6 @@ public: NULL); } - virtual ~PerlinPatchView() { - SkSafeUnref(fShader0); - } protected: // overrides from SkEventSink bool onQuery(SkEvent* evt) override { @@ -145,16 +142,14 @@ protected: SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(SkXfermode::kSrc_Mode)); SkScalar scaleFreq = 2.0; - fShader1 = SkPerlinNoiseShader2::CreateImprovedNoise(fXFreq/scaleFreq, fYFreq/scaleFreq, 4, + fShader1 = SkPerlinNoiseShader2::MakeImprovedNoise(fXFreq/scaleFreq, fYFreq/scaleFreq, 4, fSeed); - fShaderCompose = SkShader::CreateComposeShader(fShader0, fShader1, nullptr); + fShaderCompose = SkShader::MakeComposeShader(fShader0, fShader1, nullptr); paint.setShader(fShaderCompose); canvas->drawPatch(fPts, nullptr, texCoords, xfer, paint); draw_control_points(canvas, fPts); - SkSafeUnref(fShader1); - SkSafeUnref(fShaderCompose); } class PtClick : public Click { diff --git a/samplecode/Sample2PtRadial.cpp b/samplecode/Sample2PtRadial.cpp index 07efd0a41c..c32025e9cb 100644 --- a/samplecode/Sample2PtRadial.cpp +++ b/samplecode/Sample2PtRadial.cpp @@ -33,12 +33,10 @@ protected: SkScalar r0 = 100; SkPoint c1 = { 100, 100 }; SkScalar r1 = 100; - SkShader* s = SkGradientShader::CreateTwoPointConical(c0, r0, c1, r1, colors, - nullptr, 2, - SkShader::kClamp_TileMode); - SkPaint paint; - paint.setShader(s)->unref(); + paint.setShader(SkGradientShader::MakeTwoPointConical(c0, r0, c1, r1, colors, + nullptr, 2, + SkShader::kClamp_TileMode)); canvas->drawPaint(paint); } diff --git a/samplecode/SampleAARectModes.cpp b/samplecode/SampleAARectModes.cpp index ae28925a42..43392235c9 100644 --- a/samplecode/SampleAARectModes.cpp +++ b/samplecode/SampleAARectModes.cpp @@ -61,7 +61,7 @@ static SkScalar drawCell(SkCanvas* canvas, SkXfermode* mode, return H; } -static SkShader* make_bg_shader() { +static sk_sp<SkShader> make_bg_shader() { SkBitmap bm; bm.allocN32Pixels(2, 2); *bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF; @@ -71,17 +71,17 @@ static SkShader* make_bg_shader() { SkMatrix m; m.setScale(SkIntToScalar(6), SkIntToScalar(6)); - return SkShader::CreateBitmapShader(bm, - SkShader::kRepeat_TileMode, - SkShader::kRepeat_TileMode, - &m); + return SkShader::MakeBitmapShader(bm, + SkShader::kRepeat_TileMode, + SkShader::kRepeat_TileMode, + &m); } class AARectsModesView : public SampleView { SkPaint fBGPaint; public: AARectsModesView () { - fBGPaint.setShader(make_bg_shader())->unref(); + fBGPaint.setShader(make_bg_shader()); } protected: diff --git a/samplecode/SampleAARects.cpp b/samplecode/SampleAARects.cpp index f552df6f15..d0c1115a1e 100644 --- a/samplecode/SampleAARects.cpp +++ b/samplecode/SampleAARects.cpp @@ -62,10 +62,8 @@ protected: SkPaint bluePaint; bluePaint.setARGB(0xff, 0x0, 0x0, 0xff); SkPaint bmpPaint; - SkShader* bmpShader = SkShader::CreateBitmapShader(fBitmap, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode); - bmpPaint.setShader(bmpShader); - bmpShader->unref(); - + bmpPaint.setShader(SkShader::MakeBitmapShader(fBitmap, SkShader::kRepeat_TileMode, + SkShader::kRepeat_TileMode)); bluePaint.setStrokeWidth(3); bmpPaint.setStrokeWidth(3); diff --git a/samplecode/SampleAll.cpp b/samplecode/SampleAll.cpp index addca35fdc..48ac24da1c 100644 --- a/samplecode/SampleAll.cpp +++ b/samplecode/SampleAll.cpp @@ -361,7 +361,7 @@ protected: SkScalar* linearPos = nullptr; int linearCount = 2; SkShader::TileMode linearMode = SkShader::kMirror_TileMode; - SkShader* linear = SkGradientShader::CreateLinear(linearPoints, + auto linear = SkGradientShader::MakeLinear(linearPoints, linearColors, linearPos, linearCount, linearMode); SkPoint radialCenter = { SkIntToScalar(25), SkIntToScalar(25) }; @@ -370,7 +370,7 @@ protected: SkScalar radialPos[] = { 0, SkIntToScalar(3) / 5, SkIntToScalar(1)}; int radialCount = 3; SkShader::TileMode radialMode = SkShader::kRepeat_TileMode; - SkShader* radial = SkGradientShader::CreateRadial(radialCenter, + auto radial = SkGradientShader::MakeRadial(radialCenter, radialRadius, radialColors, radialPos, radialCount, radialMode); @@ -396,8 +396,8 @@ protected: paint.setStyle(SkPaint::kFill_Style); SkRect clip = {0, 0, SkIntToScalar(320), SkIntToScalar(120)}; canvas->clipRect(clip); - paint.setShader(SkShader::CreateBitmapShader(fTx, - SkShader::kMirror_TileMode, SkShader::kRepeat_TileMode))->unref(); + paint.setShader(SkShader::MakeBitmapShader(fTx, + SkShader::kMirror_TileMode, SkShader::kRepeat_TileMode)); canvas->drawPaint(paint); canvas->save(); @@ -415,7 +415,7 @@ protected: paint.setStyle(SkPaint::kFill_Style); canvas->translate(SkIntToScalar(50), 0); paint.setColor(SK_ColorYELLOW); - paint.setShader(linear)->unref(); + paint.setShader(linear); paint.setPathEffect(pathEffectTest())->unref(); canvas->drawRect(rect, paint); paint.setPathEffect(nullptr); @@ -434,7 +434,7 @@ protected: paint.setColor(SK_ColorRED); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(SkIntToScalar(5)); - paint.setShader(radial)->unref(); + paint.setShader(radial); paint.setMaskFilter(nullptr); canvas->drawPath(path, paint); @@ -445,7 +445,7 @@ protected: canvas->drawBitmap(fBug, left, top, &paint); canvas->translate(-SkIntToScalar(30), SkIntToScalar(30)); - paint.setShader(shaderTest())->unref(); // test compose shader + paint.setShader(shaderTest()); // test compose shader canvas->drawRect(rect2, paint); paint.setShader(nullptr); @@ -500,21 +500,17 @@ protected: return result; } - SkShader* shaderTest() { + sk_sp<SkShader> shaderTest() { SkPoint pts[] = { { 0, 0, }, { SkIntToScalar(100), 0 } }; SkColor colors[] = { SK_ColorRED, SK_ColorBLUE }; - SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, nullptr, + auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode); pts[1].set(0, SkIntToScalar(100)); SkColor colors2[] = {SK_ColorBLACK, SkColorSetARGB(0x80, 0, 0, 0)}; - SkShader* shaderB = SkGradientShader::CreateLinear(pts, colors2, nullptr, + auto shaderB = SkGradientShader::MakeLinear(pts, colors2, nullptr, 2, SkShader::kClamp_TileMode); - SkXfermode* mode = SkXfermode::Create(SkXfermode::kDstIn_Mode); - SkShader* result = SkShader::CreateComposeShader(shaderA, shaderB, mode); - shaderA->unref(); - shaderB->unref(); - mode->unref(); - return result; + SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kDstIn_Mode)); + return SkShader::MakeComposeShader(shaderA, shaderB, mode); } virtual void startTest() { diff --git a/samplecode/SampleBigGradient.cpp b/samplecode/SampleBigGradient.cpp index 0fa7969c7a..8ae099051b 100644 --- a/samplecode/SampleBigGradient.cpp +++ b/samplecode/SampleBigGradient.cpp @@ -1,20 +1,19 @@ - /* * Copyright 2011 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ + #include "SampleCode.h" #include "SkView.h" #include "SkCanvas.h" #include "SkGradientShader.h" -static SkShader* make_grad(SkScalar w, SkScalar h) { +static sk_sp<SkShader> make_grad(SkScalar w, SkScalar h) { SkColor colors[] = { 0xFF000000, 0xFF333333 }; SkPoint pts[] = { { 0, 0 }, { w, h } }; - return SkGradientShader::CreateLinear(pts, colors, nullptr, 2, - SkShader::kClamp_TileMode); + return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode); } class BigGradientView : public SampleView { @@ -22,8 +21,7 @@ public: BigGradientView() {} protected: - // overrides from SkEventSink - virtual bool onQuery(SkEvent* evt) { + bool onQuery(SkEvent* evt) override { if (SampleCode::TitleQ(*evt)) { SampleCode::TitleR(evt, "BigGradient"); return true; @@ -31,11 +29,11 @@ protected: return this->INHERITED::onQuery(evt); } - virtual void onDrawContent(SkCanvas* canvas) { + void onDrawContent(SkCanvas* canvas) override { SkRect r; r.set(0, 0, this->width(), this->height()); SkPaint p; - p.setShader(make_grad(this->width(), this->height()))->unref(); + p.setShader(make_grad(this->width(), this->height())); canvas->drawRect(r, p); } diff --git a/samplecode/SampleBitmapRect.cpp b/samplecode/SampleBitmapRect.cpp index d7eed02ef9..490c6a45c3 100644 --- a/samplecode/SampleBitmapRect.cpp +++ b/samplecode/SampleBitmapRect.cpp @@ -37,8 +37,8 @@ static void make_bitmap(SkBitmap* bitmap) { paint.setAntiAlias(true); const SkPoint pts[] = { { 0, 0 }, { SCALAR_SIZE, SCALAR_SIZE } }; const SkColor colors[] = { SK_ColorWHITE, SK_ColorBLUE }; - paint.setShader(SkGradientShader::CreateLinear(pts, colors, nullptr, 2, - SkShader::kClamp_TileMode))->unref(); + paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, + SkShader::kClamp_TileMode)); canvas.drawCircle(SCALAR_SIZE/2, SCALAR_SIZE/2, SCALAR_SIZE/2, paint); } diff --git a/samplecode/SampleCamera.cpp b/samplecode/SampleCamera.cpp index 991013a850..b860917f3f 100644 --- a/samplecode/SampleCamera.cpp +++ b/samplecode/SampleCamera.cpp @@ -39,10 +39,10 @@ public: SkMatrix matrix; matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit); - SkShader* s = SkShader::CreateBitmapShader(bm, + SkShader* s = SkShader::MakeBitmapShader(bm, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, - &matrix); + &matrix).release(); *fShaders.append() = s; } else { break; diff --git a/samplecode/SampleColorFilter.cpp b/samplecode/SampleColorFilter.cpp index af1cd935a2..4ee8949410 100644 --- a/samplecode/SampleColorFilter.cpp +++ b/samplecode/SampleColorFilter.cpp @@ -111,7 +111,7 @@ static SkBitmap createBitmap(int n) { class ColorFilterView : public SampleView { SkBitmap fBitmap; - SkShader* fShader; + sk_sp<SkShader> fShader; enum { N = 64 }; @@ -126,10 +126,6 @@ public: } } - virtual ~ColorFilterView() { - fShader->unref(); - } - protected: // overrides from SkEventSink virtual bool onQuery(SkEvent* evt) { diff --git a/samplecode/SampleDegenerateTwoPtRadials.cpp b/samplecode/SampleDegenerateTwoPtRadials.cpp index 32b45374e6..f171202249 100644 --- a/samplecode/SampleDegenerateTwoPtRadials.cpp +++ b/samplecode/SampleDegenerateTwoPtRadials.cpp @@ -27,12 +27,10 @@ static void draw_gradient2(SkCanvas* canvas, const SkRect& rect, SkScalar delta) SkPoint c1 = { l + 3 * w / 5, t + h / 2 }; SkScalar r0 = w / 5; SkScalar r1 = 2 * w / 5; - SkShader* s = SkGradientShader::CreateTwoPointConical(c0, r0, c1, r1, colors, - pos, SK_ARRAY_COUNT(pos), - SkShader::kClamp_TileMode); SkPaint paint; - paint.setShader(s)->unref(); - + paint.setShader(SkGradientShader::MakeTwoPointConical(c0, r0, c1, r1, colors, + pos, SK_ARRAY_COUNT(pos), + SkShader::kClamp_TileMode)); canvas->drawRect(rect, paint); } diff --git a/samplecode/SampleDither.cpp b/samplecode/SampleDither.cpp index 8c14fb5110..a599418723 100644 --- a/samplecode/SampleDither.cpp +++ b/samplecode/SampleDither.cpp @@ -34,9 +34,8 @@ static void draw_sweep(SkCanvas* c, int width, int height, SkScalar angle) { // SkColor colors[] = { SK_ColorRED, SK_ColorBLUE, SK_ColorGREEN, SK_ColorCYAN }; SkColor colors[] = { 0x4c737373, 0x4c737373, 0xffffd300 }; - SkShader* s = SkGradientShader::CreateSweep(r.centerX(), r.centerY(), - colors, nullptr, SK_ARRAY_COUNT(colors)); - p.setShader(s)->unref(); + p.setShader(SkGradientShader::MakeSweep(r.centerX(), r.centerY(), + colors, nullptr, SK_ARRAY_COUNT(colors))); SkAutoCanvasRestore acr(c, true); diff --git a/samplecode/SampleDitherBitmap.cpp b/samplecode/SampleDitherBitmap.cpp index df72dd4ffe..34241c5e02 100644 --- a/samplecode/SampleDitherBitmap.cpp +++ b/samplecode/SampleDitherBitmap.cpp @@ -26,11 +26,8 @@ static void draw_gradient(SkCanvas* canvas) { SkRect r = { 0, 0, SkIntToScalar(256), SkIntToScalar(32) }; SkPoint pts[] = { { r.fLeft, r.fTop }, { r.fRight, r.fTop } }; SkColor colors[] = { 0xFF000000, 0xFFFF0000 }; - SkShader* s = SkGradientShader::CreateLinear(pts, colors, nullptr, 2, - SkShader::kClamp_TileMode); - SkPaint p; - p.setShader(s)->unref(); + p.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode)); draw_rect(canvas, r, p); canvas->translate(0, SkIntToScalar(40)); diff --git a/samplecode/SampleEffects.cpp b/samplecode/SampleEffects.cpp index b58d5573ad..12ea4e2392 100644 --- a/samplecode/SampleEffects.cpp +++ b/samplecode/SampleEffects.cpp @@ -40,8 +40,8 @@ static void paint_proc2(SkPaint* paint) { static void paint_proc3(SkPaint* paint) { SkColor colors[] = { SK_ColorRED, COLOR, SK_ColorBLUE }; SkPoint pts[] = { { 3, 0 }, { 7, 5 } }; - paint->setShader(SkGradientShader::CreateLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors), - SkShader::kMirror_TileMode))->unref(); + paint->setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors), + SkShader::kMirror_TileMode)); } static void paint_proc5(SkPaint* paint) { diff --git a/samplecode/SampleFatBits.cpp b/samplecode/SampleFatBits.cpp index f3a2f6c54a..4b15e370e4 100644 --- a/samplecode/SampleFatBits.cpp +++ b/samplecode/SampleFatBits.cpp @@ -88,8 +88,7 @@ public: fBounds.set(0, 0, SkIntToScalar(width * zoom), SkIntToScalar(height * zoom)); fMatrix.setScale(SkIntToScalar(zoom), SkIntToScalar(zoom)); fInverse.setScale(SK_Scalar1 / zoom, SK_Scalar1 / zoom); - fShader.reset(sk_tool_utils::create_checkerboard_shader( - 0xFFCCCCCC, 0xFFFFFFFF, zoom)); + fShader = sk_tool_utils::create_checkerboard_shader(0xFFCCCCCC, 0xFFFFFFFF, zoom); SkImageInfo info = SkImageInfo::MakeN32Premul(width, height); fMinSurface.reset(SkSurface::NewRaster(info)); @@ -111,7 +110,7 @@ private: int fW, fH, fZoom; SkMatrix fMatrix, fInverse; SkRect fBounds, fClipRect; - SkAutoTUnref<SkShader> fShader; + sk_sp<SkShader> fShader; SkAutoTUnref<SkSurface> fMinSurface; SkAutoTUnref<SkSurface> fMaxSurface; diff --git a/samplecode/SampleGradients.cpp b/samplecode/SampleGradients.cpp index 2d6f7d4bb1..5e9450e84d 100644 --- a/samplecode/SampleGradients.cpp +++ b/samplecode/SampleGradients.cpp @@ -10,10 +10,10 @@ #include "SkCanvas.h" #include "SkGradientShader.h" -static SkShader* setgrad(const SkRect& r, SkColor c0, SkColor c1) { +static sk_sp<SkShader> setgrad(const SkRect& r, SkColor c0, SkColor c1) { SkColor colors[] = { c0, c1 }; SkPoint pts[] = { { r.fLeft, r.fTop }, { r.fRight, r.fTop } }; - return SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode); + return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode); } static void test_alphagradients(SkCanvas* canvas) { @@ -23,17 +23,17 @@ static void test_alphagradients(SkCanvas* canvas) { SkPaint p, p2; p2.setStyle(SkPaint::kStroke_Style); - p.setShader(setgrad(r, 0xFF00FF00, 0x0000FF00))->unref(); + p.setShader(setgrad(r, 0xFF00FF00, 0x0000FF00)); canvas->drawRect(r, p); canvas->drawRect(r, p2); r.offset(0, r.height() + SkIntToScalar(4)); - p.setShader(setgrad(r, 0xFF00FF00, 0x00000000))->unref(); + p.setShader(setgrad(r, 0xFF00FF00, 0x00000000)); canvas->drawRect(r, p); canvas->drawRect(r, p2); r.offset(0, r.height() + SkIntToScalar(4)); - p.setShader(setgrad(r, 0xFF00FF00, 0x00FF0000))->unref(); + p.setShader(setgrad(r, 0xFF00FF00, 0x00FF0000)); canvas->drawRect(r, p); canvas->drawRect(r, p2); } @@ -63,49 +63,49 @@ static const GradData gGradData[] = { { 5, gColors, gPos2 } }; -static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { - return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos, data.fCount, tm); +static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { + return SkGradientShader::MakeLinear(pts, data.fColors, data.fPos, data.fCount, tm); } -static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { +static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { SkPoint center; center.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); - return SkGradientShader::CreateRadial(center, center.fX, data.fColors, - data.fPos, data.fCount, tm); + return SkGradientShader::MakeRadial(center, center.fX, data.fColors, + data.fPos, data.fCount, tm); } -static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { +static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { SkPoint center; center.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); - return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount); + return SkGradientShader::MakeSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount); } -static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { +static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { SkPoint center0, center1; center0.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5), SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4)); - return SkGradientShader::CreateTwoPointConical( + return SkGradientShader::MakeTwoPointConical( center1, (pts[1].fX - pts[0].fX) / 7, center0, (pts[1].fX - pts[0].fX) / 2, data.fColors, data.fPos, data.fCount, tm); } -static SkShader* Make2ConicalConcentric(const SkPoint pts[2], const GradData& data, +static sk_sp<SkShader> Make2ConicalConcentric(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { SkPoint center; center.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); - return SkGradientShader::CreateTwoPointConical( + return SkGradientShader::MakeTwoPointConical( center, (pts[1].fX - pts[0].fX) / 7, center, (pts[1].fX - pts[0].fX) / 2, data.fColors, data.fPos, data.fCount, tm); } -typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm); +typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm); static const GradMaker gGradMakers[] = { MakeLinear, MakeRadial, MakeSweep, Make2Conical, Make2ConicalConcentric @@ -120,8 +120,7 @@ public: } protected: - // overrides from SkEventSink - virtual bool onQuery(SkEvent* evt) { + bool onQuery(SkEvent* evt) override { if (SampleCode::TitleQ(*evt)) { SampleCode::TitleR(evt, "Gradients"); return true; @@ -129,7 +128,7 @@ protected: return this->INHERITED::onQuery(evt); } - virtual void onDrawContent(SkCanvas* canvas) { + void onDrawContent(SkCanvas* canvas) override { SkPoint pts[2] = { { 0, 0 }, { SkIntToScalar(100), SkIntToScalar(100) } @@ -146,9 +145,7 @@ protected: for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) { canvas->save(); for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) { - SkShader* shader; - shader = gGradMakers[j](pts, gGradData[i], (SkShader::TileMode)tm); - paint.setShader(shader)->unref(); + paint.setShader(gGradMakers[j](pts, gGradData[i], (SkShader::TileMode)tm)); canvas->drawRect(r, paint); canvas->translate(0, SkIntToScalar(120)); } diff --git a/samplecode/SampleHairModes.cpp b/samplecode/SampleHairModes.cpp index ae41aa9c9d..085581cfc9 100644 --- a/samplecode/SampleHairModes.cpp +++ b/samplecode/SampleHairModes.cpp @@ -60,7 +60,7 @@ static SkScalar drawCell(SkCanvas* canvas, SkXfermode* mode, SkAlpha a0, SkAlpha return H; } -static SkShader* make_bg_shader() { +static sk_sp<SkShader> make_bg_shader() { SkBitmap bm; bm.allocN32Pixels(2, 2); *bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF; @@ -69,17 +69,15 @@ static SkShader* make_bg_shader() { SkMatrix m; m.setScale(SkIntToScalar(6), SkIntToScalar(6)); - return SkShader::CreateBitmapShader(bm, - SkShader::kRepeat_TileMode, - SkShader::kRepeat_TileMode, - &m); + return SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode, + SkShader::kRepeat_TileMode, &m); } class HairModesView : public SampleView { SkPaint fBGPaint; public: HairModesView() { - fBGPaint.setShader(make_bg_shader())->unref(); + fBGPaint.setShader(make_bg_shader()); } protected: diff --git a/samplecode/SampleLayers.cpp b/samplecode/SampleLayers.cpp index f8ebd7c94f..beb7e4ae1a 100644 --- a/samplecode/SampleLayers.cpp +++ b/samplecode/SampleLayers.cpp @@ -1,10 +1,10 @@ - /* * Copyright 2011 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ + #include "SampleCode.h" #include "SkView.h" #include "SkCanvas.h" @@ -30,10 +30,8 @@ static void make_paint(SkPaint* paint, const SkMatrix& localMatrix) { SkColor colors[] = { 0, SK_ColorWHITE }; SkPoint pts[] = { { 0, 0 }, { 0, SK_Scalar1*20 } }; - SkShader* s = SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode, - 0, &localMatrix); - - paint->setShader(s)->unref(); + paint->setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, + SkShader::kClamp_TileMode, 0, &localMatrix)); paint->setXfermodeMode(SkXfermode::kDstIn_Mode); } diff --git a/samplecode/SamplePatch.cpp b/samplecode/SamplePatch.cpp index 5347b0182a..c9ecb70990 100644 --- a/samplecode/SamplePatch.cpp +++ b/samplecode/SamplePatch.cpp @@ -28,21 +28,21 @@ #include "SkGeometry.h" // private include :( -static SkShader* make_shader0(SkIPoint* size) { +static sk_sp<SkShader> make_shader0(SkIPoint* size) { SkBitmap bm; // SkImageDecoder::DecodeFile("/skimages/progressivejpg.jpg", &bm); SkImageDecoder::DecodeFile("/skimages/logo.png", &bm); size->set(bm.width(), bm.height()); - return SkShader::CreateBitmapShader(bm, SkShader::kClamp_TileMode, - SkShader::kClamp_TileMode); + return SkShader::MakeBitmapShader(bm, SkShader::kClamp_TileMode, + SkShader::kClamp_TileMode); } -static SkShader* make_shader1(const SkIPoint& size) { +static sk_sp<SkShader> make_shader1(const SkIPoint& size) { SkPoint pts[] = { { 0, 0, }, { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } }; SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED }; - return SkGradientShader::CreateLinear(pts, colors, nullptr, + return SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode); } @@ -211,8 +211,8 @@ const SkScalar DY = 0; class PatchView : public SampleView { SkScalar fAngle; - SkShader* fShader0; - SkShader* fShader1; + sk_sp<SkShader> fShader0; + sk_sp<SkShader> fShader1; SkIPoint fSize0, fSize1; SkPoint fPts[12]; @@ -243,11 +243,6 @@ public: this->setBGColor(SK_ColorGRAY); } - virtual ~PatchView() { - SkSafeUnref(fShader0); - SkSafeUnref(fShader1); - } - protected: // overrides from SkEventSink bool onQuery(SkEvent* evt) override { diff --git a/samplecode/SampleQuadStroker.cpp b/samplecode/SampleQuadStroker.cpp index eae683f82e..48f29f7f50 100644 --- a/samplecode/SampleQuadStroker.cpp +++ b/samplecode/SampleQuadStroker.cpp @@ -109,7 +109,7 @@ class QuadStrokerView : public SampleView { SkRect fWidthControl; SkRect fBounds; SkMatrix fMatrix, fInverse; - SkAutoTUnref<SkShader> fShader; + sk_sp<SkShader> fShader; SkAutoTUnref<SkSurface> fMinSurface; SkAutoTUnref<SkSurface> fMaxSurface; StrokeTypeButton fCubicButton; @@ -264,8 +264,7 @@ protected: fBounds.set(0, 0, SkIntToScalar(width * zoom), SkIntToScalar(height * zoom)); fMatrix.setScale(SkIntToScalar(zoom), SkIntToScalar(zoom)); fInverse.setScale(SK_Scalar1 / zoom, SK_Scalar1 / zoom); - fShader.reset(sk_tool_utils::create_checkerboard_shader( - 0xFFCCCCCC, 0xFFFFFFFF, zoom)); + fShader = sk_tool_utils::create_checkerboard_shader(0xFFCCCCCC, 0xFFFFFFFF, zoom); SkImageInfo info = SkImageInfo::MakeN32Premul(width, height); fMinSurface.reset(SkSurface::NewRaster(info)); diff --git a/samplecode/SampleRegion.cpp b/samplecode/SampleRegion.cpp index eb3e134af9..639203b8bc 100644 --- a/samplecode/SampleRegion.cpp +++ b/samplecode/SampleRegion.cpp @@ -4,6 +4,7 @@ * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ + #include "SampleCode.h" #include "SkView.h" #include "SkCanvas.h" @@ -78,10 +79,8 @@ static void drawFadingText(SkCanvas* canvas, // of our pts[] array. const SkScalar pos[] = { 0, 0.9f, SK_Scalar1 }; - SkShader* s = SkGradientShader::CreateLinear(pts, colors, pos, 3, - SkShader::kClamp_TileMode); SkPaint p; - p.setShader(s)->unref(); + p.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 3, SkShader::kClamp_TileMode)); p.setXfermodeMode(SkXfermode::kDstIn_Mode); canvas->drawRect(bounds, p); @@ -105,10 +104,9 @@ static void test_text(SkCanvas* canvas) { const SkPoint pts[] = { { x, y }, { x + paint.measureText(str, len), y } }; const SkColor colors[] = { SK_ColorBLACK, SK_ColorBLACK, 0 }; const SkScalar pos[] = { 0, 0.9f, 1 }; - SkShader* s = SkGradientShader::CreateLinear(pts, colors, pos, + paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, SK_ARRAY_COUNT(colors), - SkShader::kClamp_TileMode); - paint.setShader(s)->unref(); + SkShader::kClamp_TileMode)); canvas->drawText(str, len, x, y, paint); y += 20; diff --git a/samplecode/SampleRepeatTile.cpp b/samplecode/SampleRepeatTile.cpp index 9287439613..598a088373 100644 --- a/samplecode/SampleRepeatTile.cpp +++ b/samplecode/SampleRepeatTile.cpp @@ -37,8 +37,7 @@ static void make_paint(SkPaint* paint, SkShader::TileMode tm) { SkBitmap bm; make_bitmap(&bm); - SkShader* shader = SkShader::CreateBitmapShader(bm, tm, tm); - paint->setShader(shader)->unref(); + paint->setShader(SkShader::MakeBitmapShader(bm, tm, tm)); } class RepeatTileView : public SampleView { diff --git a/samplecode/SampleShaderText.cpp b/samplecode/SampleShaderText.cpp index f13fd4edc7..cf0cb0fe75 100644 --- a/samplecode/SampleShaderText.cpp +++ b/samplecode/SampleShaderText.cpp @@ -23,18 +23,18 @@ static void makebm(SkBitmap* bm, int w, int h) { SkPaint paint; paint.setDither(true); - paint.setShader(SkGradientShader::CreateLinear(pts, colors, pos, - SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode))->unref(); + paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, + SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode)); canvas.drawPaint(paint); } -static SkShader* MakeBitmapShader(SkShader::TileMode tx, SkShader::TileMode ty, - int w, int h) { +static sk_sp<SkShader> MakeBitmapShader(SkShader::TileMode tx, SkShader::TileMode ty, + int w, int h) { static SkBitmap bmp; if (bmp.isNull()) { makebm(&bmp, w/2, h/4); } - return SkShader::CreateBitmapShader(bmp, tx, ty); + return SkShader::MakeBitmapShader(bmp, tx, ty); } /////////////////////////////////////////////////////////////////////////////// @@ -54,38 +54,38 @@ static const GradData gGradData[] = { { 5, gColors, nullptr }, }; -static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { - return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos, data.fCount, tm); +static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { + return SkGradientShader::MakeLinear(pts, data.fColors, data.fPos, data.fCount, tm); } -static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { +static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { SkPoint center; center.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); - return SkGradientShader::CreateRadial(center, center.fX, data.fColors, - data.fPos, data.fCount, tm); + return SkGradientShader::MakeRadial(center, center.fX, data.fColors, + data.fPos, data.fCount, tm); } -static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { +static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { SkPoint center; center.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); - return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount); + return SkGradientShader::MakeSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount); } -static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { +static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { SkPoint center0, center1; center0.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5), SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4)); - return SkGradientShader::CreateTwoPointConical( + return SkGradientShader::MakeTwoPointConical( center1, (pts[1].fX - pts[0].fX) / 7, center0, (pts[1].fX - pts[0].fX) / 2, data.fColors, data.fPos, data.fCount, tm); } -typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm); +typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm); static const GradMaker gGradMakers[] = { MakeLinear, MakeRadial, MakeSweep, Make2Conical @@ -133,7 +133,7 @@ protected: SK_ARRAY_COUNT(gGradMakers); static const int bmpCount = SK_ARRAY_COUNT(tileModes) * SK_ARRAY_COUNT(tileModes); - SkShader* shaders[gradCount + bmpCount]; + sk_sp<SkShader> shaders[gradCount + bmpCount]; int shdIdx = 0; for (size_t d = 0; d < SK_ARRAY_COUNT(gGradData); ++d) { @@ -175,7 +175,7 @@ protected: size_t i = 2*s; canvas->translate(SkIntToScalar((i / testsPerCol) * colWidth), SkIntToScalar((i % testsPerCol) * rowHeight)); - paint.setShader(shaders[s])->unref(); + paint.setShader(shaders[s]); canvas->drawText(text, textLen, 0, textBase, paint); canvas->restore(); canvas->save(); diff --git a/samplecode/SampleShaders.cpp b/samplecode/SampleShaders.cpp index 2c0a6ab749..71ddc2ec69 100644 --- a/samplecode/SampleShaders.cpp +++ b/samplecode/SampleShaders.cpp @@ -1,10 +1,10 @@ - /* * Copyright 2011 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ + #include "SampleCode.h" #include "SkView.h" #include "SkCanvas.h" @@ -21,8 +21,7 @@ #include "SkTime.h" #include "SkTypeface.h" -static SkShader* make_bitmapfade(const SkBitmap& bm) -{ +static sk_sp<SkShader> make_bitmapfade(const SkBitmap& bm) { SkPoint pts[2]; SkColor colors[2]; @@ -30,25 +29,20 @@ static SkShader* make_bitmapfade(const SkBitmap& bm) pts[1].set(0, SkIntToScalar(bm.height())); colors[0] = SK_ColorBLACK; colors[1] = SkColorSetARGB(0, 0, 0, 0); - SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode); + auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode); - SkShader* shaderB = SkShader::CreateBitmapShader(bm, + auto shaderB = SkShader::MakeBitmapShader(bm, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode); - SkXfermode* mode = SkXfermode::Create(SkXfermode::kDstIn_Mode); + SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kDstIn_Mode)); - SkShader* shader = SkShader::CreateComposeShader(shaderB, shaderA, mode); - shaderA->unref(); - shaderB->unref(); - mode->unref(); - - return shader; + return SkShader::MakeComposeShader(std::move(shaderB), std::move(shaderA), mode); } class ShaderView : public SampleView { public: - SkShader* fShader; - SkBitmap fBitmap; + sk_sp<SkShader> fShader; + SkBitmap fBitmap; ShaderView() { SkImageDecoder::DecodeFile("/skimages/logo.gif", &fBitmap); @@ -60,23 +54,17 @@ public: pts[1].set(SkIntToScalar(100), 0); colors[0] = SK_ColorRED; colors[1] = SK_ColorBLUE; - SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode); + auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode); pts[0].set(0, 0); pts[1].set(0, SkIntToScalar(100)); colors[0] = SK_ColorBLACK; colors[1] = SkColorSetARGB(0x80, 0, 0, 0); - SkShader* shaderB = SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode); + auto shaderB = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode); - SkXfermode* mode = SkXfermode::Create(SkXfermode::kDstIn_Mode); + SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kDstIn_Mode)); - fShader = SkShader::CreateComposeShader(shaderA, shaderB, mode); - shaderA->unref(); - shaderB->unref(); - mode->unref(); - } - virtual ~ShaderView() { - SkSafeUnref(fShader); + fShader = SkShader::MakeComposeShader(std::move(shaderA), std::move(shaderB), mode); } protected: @@ -112,7 +100,7 @@ protected: paint.setShader(nullptr); canvas->drawRect(r, paint); - paint.setShader(make_bitmapfade(fBitmap))->unref(); + paint.setShader(make_bitmapfade(fBitmap)); canvas->drawRect(r, paint); } diff --git a/samplecode/SampleSlides.cpp b/samplecode/SampleSlides.cpp index 8b853365fe..c3cc2bbd6f 100644 --- a/samplecode/SampleSlides.cpp +++ b/samplecode/SampleSlides.cpp @@ -178,38 +178,37 @@ static const GradData gGradData[] = { { 5, gColors, gPos2 } }; -static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { - return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos, data.fCount, tm); +static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { + return SkGradientShader::MakeLinear(pts, data.fColors, data.fPos, data.fCount, tm); } -static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { +static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { SkPoint center; center.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); - return SkGradientShader::CreateRadial(center, center.fX, data.fColors, + return SkGradientShader::MakeRadial(center, center.fX, data.fColors, data.fPos, data.fCount, tm); } -static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { +static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { SkPoint center; center.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); - return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount); + return SkGradientShader::MakeSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount); } -static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { +static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) { SkPoint center0, center1; center0.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5), SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4)); - return SkGradientShader::CreateTwoPointConical( - center1, (pts[1].fX - pts[0].fX) / 7, + return SkGradientShader::MakeTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 7, center0, (pts[1].fX - pts[0].fX) / 2, data.fColors, data.fPos, data.fCount, tm); } -typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm); +typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData&, SkShader::TileMode); static const GradMaker gGradMakers[] = { MakeLinear, MakeRadial, MakeSweep, Make2Conical }; @@ -229,10 +228,8 @@ static void gradient_slide(SkCanvas* canvas) { for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) { canvas->save(); for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) { - SkShader* shader = gGradMakers[j](pts, gGradData[i], tm); - paint.setShader(shader); + paint.setShader(gGradMakers[j](pts, gGradData[i], tm)); canvas->drawRect(r, paint); - shader->unref(); canvas->translate(0, SkIntToScalar(120)); } canvas->restore(); @@ -314,20 +311,20 @@ static void textonpath_slide(SkCanvas* canvas) { #include "SkRandom.h" #include "SkStream.h" -static SkShader* make_shader0(SkIPoint* size) { +static sk_sp<SkShader> make_shader0(SkIPoint* size) { SkBitmap bm; SkImageDecoder::DecodeFile("/skimages/logo.gif", &bm); size->set(bm.width(), bm.height()); - return SkShader::CreateBitmapShader(bm, SkShader::kClamp_TileMode, + return SkShader::MakeBitmapShader(bm, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode); } -static SkShader* make_shader1(const SkIPoint& size) { +static sk_sp<SkShader> make_shader1(const SkIPoint& size) { SkPoint pts[] = { { 0, 0 }, { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } }; SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED }; - return SkGradientShader::CreateLinear(pts, colors, nullptr, + return SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode); } @@ -426,11 +423,8 @@ static void mesh_slide(SkCanvas* canvas) { Rec fRecs[3]; SkIPoint size; - SkShader* fShader0 = make_shader0(&size); - SkShader* fShader1 = make_shader1(size); - - SkAutoUnref aur0(fShader0); - SkAutoUnref aur1(fShader1); + auto fShader0 = make_shader0(&size); + auto fShader1 = make_shader1(size); make_strip(&fRecs[0], size.fX, size.fY); make_fan(&fRecs[1], size.fX, size.fY); diff --git a/samplecode/SampleTiling.cpp b/samplecode/SampleTiling.cpp index ed244eb3d2..125155e8d0 100644 --- a/samplecode/SampleTiling.cpp +++ b/samplecode/SampleTiling.cpp @@ -35,15 +35,14 @@ static void makebm(SkBitmap* bm, SkColorType ct, int w, int h) { SkPaint paint; paint.setDither(true); - paint.setShader(SkGradientShader::CreateLinear(pts, colors, pos, - SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode))->unref(); + paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, + SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode)); canvas.drawPaint(paint); } static void setup(SkPaint* paint, const SkBitmap& bm, bool filter, SkShader::TileMode tmx, SkShader::TileMode tmy) { - SkShader* shader = SkShader::CreateBitmapShader(bm, tmx, tmy); - paint->setShader(shader)->unref(); + paint->setShader(SkShader::MakeBitmapShader(bm, tmx, tmy)); paint->setFilterQuality(filter ? kLow_SkFilterQuality : kNone_SkFilterQuality); } diff --git a/samplecode/SampleTinyBitmap.cpp b/samplecode/SampleTinyBitmap.cpp index 8b1bdf0d18..4fb508b898 100644 --- a/samplecode/SampleTinyBitmap.cpp +++ b/samplecode/SampleTinyBitmap.cpp @@ -1,10 +1,10 @@ - /* * Copyright 2011 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ + #include "SampleCode.h" #include "SkColorPriv.h" #include "SkShader.h" @@ -47,8 +47,7 @@ public: } protected: - // overrides from SkEventSink - virtual bool onQuery(SkEvent* evt) { + bool onQuery(SkEvent* evt) override { if (SampleCode::TitleQ(*evt)) { SampleCode::TitleR(evt, "TinyBitmap"); return true; @@ -61,11 +60,10 @@ protected: bm->setAlphaType(isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType); } - virtual void onDrawContent(SkCanvas* canvas) { - SkShader* s = SkShader::CreateBitmapShader(fBM, SkShader::kRepeat_TileMode, - SkShader::kMirror_TileMode); + void onDrawContent(SkCanvas* canvas) override { SkPaint paint; - paint.setShader(s)->unref(); + paint.setShader(SkShader::MakeBitmapShader(fBM, SkShader::kRepeat_TileMode, + SkShader::kMirror_TileMode)); canvas->drawPaint(paint); } diff --git a/samplecode/SampleVertices.cpp b/samplecode/SampleVertices.cpp index 2f2dc024d0..a8dcd22bb3 100644 --- a/samplecode/SampleVertices.cpp +++ b/samplecode/SampleVertices.cpp @@ -25,7 +25,7 @@ #include "SkOSFile.h" #include "SkStream.h" -static SkShader* make_shader0(SkIPoint* size) { +static sk_sp<SkShader> make_shader0(SkIPoint* size) { SkBitmap bm; size->set(2, 2); SkPMColor color0 = SkPreMultiplyARGB(0x80, 0x80, 0xff, 0x80); @@ -38,21 +38,20 @@ static SkShader* make_shader0(SkIPoint* size) { pixels[1] = pixels[3] = color1; bm.unlockPixels(); - return SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode, - SkShader::kRepeat_TileMode); + return SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode); } -static SkShader* make_shader1(const SkIPoint& size) { +static sk_sp<SkShader> make_shader1(const SkIPoint& size) { SkPoint pts[] = { { 0, 0 }, { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } }; SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED }; - return SkGradientShader::CreateLinear(pts, colors, nullptr, + return SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode); } class VerticesView : public SampleView { - SkShader* fShader0; - SkShader* fShader1; + sk_sp<SkShader> fShader0; + sk_sp<SkShader> fShader1; public: VerticesView() { @@ -70,11 +69,6 @@ public: this->setBGColor(SK_ColorGRAY); } - virtual ~VerticesView() { - SkSafeUnref(fShader0); - SkSafeUnref(fShader1); - } - protected: // overrides from SkEventSink bool onQuery(SkEvent* evt) override { diff --git a/samplecode/SampleXfer.cpp b/samplecode/SampleXfer.cpp index 221ba5815e..58546e19cd 100644 --- a/samplecode/SampleXfer.cpp +++ b/samplecode/SampleXfer.cpp @@ -127,10 +127,9 @@ class CircDrawable : public ModeDrawable { public: CircDrawable(SkScalar size, SkColor c) { const SkColor colors[] = { 0, c }; - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateRadial(SkPoint::Make(size/2, size/2), size/2, + fPaint.setShader(SkGradientShader::MakeRadial(SkPoint::Make(size/2, size/2), size/2, colors, nullptr, 2, SkShader::kClamp_TileMode)); - fPaint.setShader(shader); fBounds = SkRect::MakeWH(size, size); } diff --git a/samplecode/SampleXfermodesBlur.cpp b/samplecode/SampleXfermodesBlur.cpp index f995c6aa7e..63c90fea15 100644 --- a/samplecode/SampleXfermodesBlur.cpp +++ b/samplecode/SampleXfermodesBlur.cpp @@ -150,10 +150,8 @@ protected: const SkScalar h = SkIntToScalar(H); SkMatrix m; m.setScale(SkIntToScalar(6), SkIntToScalar(6)); - SkShader* s = SkShader::CreateBitmapShader(fBG, - SkShader::kRepeat_TileMode, - SkShader::kRepeat_TileMode, - &m); + auto s = SkShader::MakeBitmapShader(fBG, SkShader::kRepeat_TileMode, + SkShader::kRepeat_TileMode, &m); SkPaint labelP; labelP.setAntiAlias(true); diff --git a/src/animator/SkDrawGradient.cpp b/src/animator/SkDrawGradient.cpp index 4aecbc3936..2fa4502f6b 100644 --- a/src/animator/SkDrawGradient.cpp +++ b/src/animator/SkDrawGradient.cpp @@ -126,14 +126,12 @@ void SkDrawLinearGradient::dump(SkAnimateMaker* maker) { #endif SkShader* SkDrawLinearGradient::getShader() { - if (addPrelude() == 0 || points.count() != 4) + if (addPrelude() == 0 || points.count() != 4) { return nullptr; - SkShader* shader = SkGradientShader::CreateLinear((SkPoint*)points.begin(), + } + return SkGradientShader::MakeLinear((SkPoint*)points.begin(), fColors.begin(), offsets.begin(), fColors.count(), (SkShader::TileMode) tileMode, - 0, getMatrix()); - SkAutoTDelete<SkShader> autoDel(shader); - (void)autoDel.detach(); - return shader; + 0, getMatrix()).release(); } @@ -161,12 +159,10 @@ void SkDrawRadialGradient::dump(SkAnimateMaker* maker) { #endif SkShader* SkDrawRadialGradient::getShader() { - if (addPrelude() == 0) + if (addPrelude() == 0) { return nullptr; - SkShader* shader = SkGradientShader::CreateRadial(center, + } + return SkGradientShader::MakeRadial(center, radius, fColors.begin(), offsets.begin(), fColors.count(), (SkShader::TileMode) tileMode, - 0, getMatrix()); - SkAutoTDelete<SkShader> autoDel(shader); - (void)autoDel.detach(); - return shader; + 0, getMatrix()).release(); } diff --git a/src/animator/SkDrawShader.cpp b/src/animator/SkDrawShader.cpp index 9e3becc48b..2868b9f4ef 100644 --- a/src/animator/SkDrawShader.cpp +++ b/src/animator/SkDrawShader.cpp @@ -71,8 +71,8 @@ SkShader* SkDrawBitmapShader::getShader() { // // oops, bitmapshader no longer takes filterBitmap, but deduces it at // draw-time from the paint - return SkShader::CreateBitmapShader(image->fBitmap, + return SkShader::MakeBitmapShader(image->fBitmap, (SkShader::TileMode) tileMode, (SkShader::TileMode) tileMode, - getMatrix()); + getMatrix()).release(); } diff --git a/src/c/sk_surface.cpp b/src/c/sk_surface.cpp index 6618881bc1..f7fa30f28a 100644 --- a/src/c/sk_surface.cpp +++ b/src/c/sk_surface.cpp @@ -551,10 +551,10 @@ sk_shader_t* sk_shader_new_linear_gradient(const sk_point_t pts[2], } else { matrix.setIdentity(); } - SkShader* s = SkGradientShader::CreateLinear(reinterpret_cast<const SkPoint*>(pts), - reinterpret_cast<const SkColor*>(colors), - colorPos, colorCount, mode, 0, &matrix); - return (sk_shader_t*)s; + return (sk_shader_t*)SkGradientShader::MakeLinear(reinterpret_cast<const SkPoint*>(pts), + reinterpret_cast<const SkColor*>(colors), + colorPos, colorCount, + mode, 0, &matrix).release(); } static const SkPoint& to_skpoint(const sk_point_t& p) { @@ -579,12 +579,10 @@ sk_shader_t* sk_shader_new_radial_gradient(const sk_point_t* ccenter, matrix.setIdentity(); } SkPoint center = to_skpoint(*ccenter); - SkShader* s = SkGradientShader::CreateRadial( - center, (SkScalar)radius, - reinterpret_cast<const SkColor*>(colors), - reinterpret_cast<const SkScalar*>(colorPos), - colorCount, mode, 0, &matrix); - return (sk_shader_t*)s; + return (sk_shader_t*)SkGradientShader::MakeRadial(center, (SkScalar)radius, + reinterpret_cast<const SkColor*>(colors), + reinterpret_cast<const SkScalar*>(colorPos), + colorCount, mode, 0, &matrix).release(); } sk_shader_t* sk_shader_new_sweep_gradient(const sk_point_t* ccenter, @@ -598,13 +596,11 @@ sk_shader_t* sk_shader_new_sweep_gradient(const sk_point_t* ccenter, } else { matrix.setIdentity(); } - SkShader* s = SkGradientShader::CreateSweep( - (SkScalar)(ccenter->x), - (SkScalar)(ccenter->y), - reinterpret_cast<const SkColor*>(colors), - reinterpret_cast<const SkScalar*>(colorPos), - colorCount, 0, &matrix); - return (sk_shader_t*)s; + return (sk_shader_t*)SkGradientShader::MakeSweep((SkScalar)(ccenter->x), + (SkScalar)(ccenter->y), + reinterpret_cast<const SkColor*>(colors), + reinterpret_cast<const SkScalar*>(colorPos), + colorCount, 0, &matrix).release(); } sk_shader_t* sk_shader_new_two_point_conical_gradient(const sk_point_t* start, @@ -628,13 +624,11 @@ sk_shader_t* sk_shader_new_two_point_conical_gradient(const sk_point_t* start, } SkPoint skstart = to_skpoint(*start); SkPoint skend = to_skpoint(*end); - SkShader* s = SkGradientShader::CreateTwoPointConical( - skstart, (SkScalar)startRadius, - skend, (SkScalar)endRadius, - reinterpret_cast<const SkColor*>(colors), - reinterpret_cast<const SkScalar*>(colorPos), - colorCount, mode, 0, &matrix); - return (sk_shader_t*)s; + return (sk_shader_t*)SkGradientShader::MakeTwoPointConical(skstart, (SkScalar)startRadius, + skend, (SkScalar)endRadius, + reinterpret_cast<const SkColor*>(colors), + reinterpret_cast<const SkScalar*>(colorPos), + colorCount, mode, 0, &matrix).release(); } /////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/core/SkBitmapDevice.cpp b/src/core/SkBitmapDevice.cpp index d5dfcc1733..fc0e63e9ae 100644 --- a/src/core/SkBitmapDevice.cpp +++ b/src/core/SkBitmapDevice.cpp @@ -314,17 +314,15 @@ void SkBitmapDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap, } // construct a shader, so we can call drawRect with the dst - SkShader* s = SkShader::CreateBitmapShader(*bitmapPtr, - SkShader::kClamp_TileMode, - SkShader::kClamp_TileMode, - &matrix); - if (nullptr == s) { + auto s = SkShader::MakeBitmapShader(*bitmapPtr, SkShader::kClamp_TileMode, + SkShader::kClamp_TileMode, &matrix); + if (!s) { return; } SkPaint paintWithShader(paint); paintWithShader.setStyle(SkPaint::kFill_Style); - paintWithShader.setShader(s)->unref(); + paintWithShader.setShader(std::move(s)); // Call ourself, in case the subclass wanted to share this setup code // but handle the drawRect code themselves. diff --git a/src/core/SkBitmapProcShader.cpp b/src/core/SkBitmapProcShader.cpp index f26194280c..4813e01d54 100644 --- a/src/core/SkBitmapProcShader.cpp +++ b/src/core/SkBitmapProcShader.cpp @@ -289,7 +289,7 @@ SkFlattenable* SkBitmapProcShader::CreateProc(SkReadBuffer& buffer) { bm.setImmutable(); TileMode mx = (TileMode)buffer.readUInt(); TileMode my = (TileMode)buffer.readUInt(); - return SkShader::CreateBitmapShader(bm, mx, my, &lm); + return SkShader::MakeBitmapShader(bm, mx, my, &lm).release(); } void SkBitmapProcShader::flatten(SkWriteBuffer& buffer) const { @@ -352,9 +352,9 @@ static bool bitmap_is_too_big(const SkBitmap& bm) { return bm.width() > kMaxSize || bm.height() > kMaxSize; } -SkShader* SkCreateBitmapShader(const SkBitmap& src, SkShader::TileMode tmx, - SkShader::TileMode tmy, const SkMatrix* localMatrix, - SkTBlitterAllocator* allocator) { +sk_sp<SkShader> SkMakeBitmapShader(const SkBitmap& src, SkShader::TileMode tmx, + SkShader::TileMode tmy, const SkMatrix* localMatrix, + SkTBlitterAllocator* allocator) { SkShader* shader; SkColor color; if (src.isNull() || bitmap_is_too_big(src)) { @@ -376,7 +376,7 @@ SkShader* SkCreateBitmapShader(const SkBitmap& src, SkShader::TileMode tmx, shader = allocator->createT<SkBitmapProcShader>(src, tmx, tmy, localMatrix); } } - return shader; + return sk_sp<SkShader>(shader); } /////////////////////////////////////////////////////////////////////////////// diff --git a/src/core/SkBitmapProcShader.h b/src/core/SkBitmapProcShader.h index dc4d832ca3..185a95de66 100644 --- a/src/core/SkBitmapProcShader.h +++ b/src/core/SkBitmapProcShader.h @@ -59,7 +59,7 @@ typedef SkSmallAllocator<3, 2100> SkTBlitterAllocator; // If alloc is non-nullptr, it will be used to allocate the returned SkShader, and MUST outlive // the SkShader. -SkShader* SkCreateBitmapShader(const SkBitmap& src, SkShader::TileMode, SkShader::TileMode, - const SkMatrix* localMatrix, SkTBlitterAllocator* alloc); +sk_sp<SkShader> SkMakeBitmapShader(const SkBitmap& src, SkShader::TileMode, SkShader::TileMode, + const SkMatrix* localMatrix, SkTBlitterAllocator* alloc); #endif diff --git a/src/core/SkBlitter.cpp b/src/core/SkBlitter.cpp index bb5cfb72e3..9fcab9c982 100644 --- a/src/core/SkBlitter.cpp +++ b/src/core/SkBlitter.cpp @@ -584,13 +584,7 @@ SkBlitter* SkBlitterClipper::apply(SkBlitter* blitter, const SkRegion* clip, class Sk3DShader : public SkShader { public: - Sk3DShader(SkShader* proxy) : fProxy(proxy) { - SkSafeRef(proxy); - } - - virtual ~Sk3DShader() { - SkSafeUnref(fProxy); - } + Sk3DShader(sk_sp<SkShader> proxy) : fProxy(std::move(proxy)) {} size_t onContextSize(const ContextRec& rec) const override { size_t size = sizeof(Sk3DShaderContext); @@ -727,18 +721,17 @@ public: protected: void flatten(SkWriteBuffer& buffer) const override { - buffer.writeFlattenable(fProxy); + buffer.writeFlattenable(fProxy.get()); } private: - SkShader* fProxy; + sk_sp<SkShader> fProxy; typedef SkShader INHERITED; }; SkFlattenable* Sk3DShader::CreateProc(SkReadBuffer& buffer) { - SkAutoTUnref<SkShader> shader(buffer.readShader()); - return new Sk3DShader(shader); + return new Sk3DShader(buffer.readShader()); } class Sk3DBlitter : public SkBlitter { @@ -822,7 +815,7 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device, if (origPaint.getMaskFilter() != nullptr && origPaint.getMaskFilter()->getFormat() == SkMask::k3D_Format) { - shader3D = new Sk3DShader(shader); + shader3D = new Sk3DShader(sk_sp<SkShader>(SkSafeRef(shader))); // we know we haven't initialized lazyPaint yet, so just do it paint.writable()->setShader(shader3D)->unref(); shader = shader3D; diff --git a/src/core/SkColorFilterShader.cpp b/src/core/SkColorFilterShader.cpp index c7cf76b53e..f5a3b9c9e1 100644 --- a/src/core/SkColorFilterShader.cpp +++ b/src/core/SkColorFilterShader.cpp @@ -24,12 +24,12 @@ SkColorFilterShader::SkColorFilterShader(SkShader* shader, SkColorFilter* filter } SkFlattenable* SkColorFilterShader::CreateProc(SkReadBuffer& buffer) { - SkAutoTUnref<SkShader> shader(buffer.readShader()); + auto shader = buffer.readShader(); SkAutoTUnref<SkColorFilter> filter(buffer.readColorFilter()); - if (!shader.get() || !filter.get()) { + if (!shader || !filter.get()) { return nullptr; } - return new SkColorFilterShader(shader, filter); + return new SkColorFilterShader(shader.get(), filter); } void SkColorFilterShader::flatten(SkWriteBuffer& buffer) const { diff --git a/src/core/SkComposeShader.cpp b/src/core/SkComposeShader.cpp index b6ba3729d1..4d3e4e57ba 100644 --- a/src/core/SkComposeShader.cpp +++ b/src/core/SkComposeShader.cpp @@ -16,9 +16,10 @@ /////////////////////////////////////////////////////////////////////////////// -SkComposeShader::SkComposeShader(SkShader* sA, SkShader* sB, SkXfermode* mode) { - fShaderA = sA; sA->ref(); - fShaderB = sB; sB->ref(); +SkComposeShader::SkComposeShader(sk_sp<SkShader> sA, sk_sp<SkShader> sB, SkXfermode* mode) + : fShaderA(std::move(sA)) + , fShaderB(std::move(sB)) +{ // mode may be null fMode = mode; SkSafeRef(mode); @@ -26,8 +27,6 @@ SkComposeShader::SkComposeShader(SkShader* sA, SkShader* sB, SkXfermode* mode) { SkComposeShader::~SkComposeShader() { SkSafeUnref(fMode); - fShaderB->unref(); - fShaderA->unref(); } size_t SkComposeShader::onContextSize(const ContextRec& rec) const { @@ -54,18 +53,18 @@ private: #define SkAutoAlphaRestore(...) SK_REQUIRE_LOCAL_VAR(SkAutoAlphaRestore) SkFlattenable* SkComposeShader::CreateProc(SkReadBuffer& buffer) { - SkAutoTUnref<SkShader> shaderA(buffer.readShader()); - SkAutoTUnref<SkShader> shaderB(buffer.readShader()); + sk_sp<SkShader> shaderA(buffer.readShader()); + sk_sp<SkShader> shaderB(buffer.readShader()); SkAutoTUnref<SkXfermode> mode(buffer.readXfermode()); - if (!shaderA.get() || !shaderB.get()) { + if (!shaderA || !shaderB) { return nullptr; } - return new SkComposeShader(shaderA, shaderB, mode); + return new SkComposeShader(std::move(shaderA), std::move(shaderB), mode); } void SkComposeShader::flatten(SkWriteBuffer& buffer) const { - buffer.writeFlattenable(fShaderA); - buffer.writeFlattenable(fShaderB); + buffer.writeFlattenable(fShaderA.get()); + buffer.writeFlattenable(fShaderB.get()); buffer.writeFlattenable(fMode); } @@ -119,8 +118,8 @@ SkComposeShader::ComposeShaderContext::~ComposeShaderContext() { bool SkComposeShader::asACompose(ComposeRec* rec) const { if (rec) { - rec->fShaderA = fShaderA; - rec->fShaderB = fShaderB; + rec->fShaderA = fShaderA.get(); + rec->fShaderB = fShaderB.get(); rec->fMode = fMode; } return true; @@ -255,14 +254,16 @@ void SkComposeShader::toString(SkString* str) const { /////////////////////////////////////////////////////////////////////////////////////////////////// -SkShader* SkShader::CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode* xfer) { +sk_sp<SkShader> SkShader::MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src, + SkXfermode* xfer) { if (!dst || !src) { return nullptr; } - return new SkComposeShader(dst, src, xfer); + return sk_make_sp<SkComposeShader>(std::move(dst), std::move(src), xfer); } -SkShader* SkShader::CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode::Mode mode) { +sk_sp<SkShader> SkShader::MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src, + SkXfermode::Mode mode) { SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(mode)); - return CreateComposeShader(dst, src, xfer); + return MakeComposeShader(std::move(dst), std::move(src), xfer); } diff --git a/src/core/SkComposeShader.h b/src/core/SkComposeShader.h index 9220a0de97..ee6e36a222 100644 --- a/src/core/SkComposeShader.h +++ b/src/core/SkComposeShader.h @@ -31,7 +31,7 @@ public: @param mode The xfermode that combines the colors from the two shaders. If mode is null, then SRC_OVER is assumed. */ - SkComposeShader(SkShader* sA, SkShader* sB, SkXfermode* mode = NULL); + SkComposeShader(sk_sp<SkShader> sA, sk_sp<SkShader> sB, SkXfermode* mode = NULL); virtual ~SkComposeShader(); #if SK_SUPPORT_GPU @@ -63,8 +63,8 @@ public: }; #ifdef SK_DEBUG - SkShader* getShaderA() { return fShaderA; } - SkShader* getShaderB() { return fShaderB; } + SkShader* getShaderA() { return fShaderA.get(); } + SkShader* getShaderB() { return fShaderB.get(); } #endif bool asACompose(ComposeRec* rec) const override; @@ -79,9 +79,9 @@ protected: Context* onCreateContext(const ContextRec&, void*) const override; private: - SkShader* fShaderA; - SkShader* fShaderB; - SkXfermode* fMode; + sk_sp<SkShader> fShaderA; + sk_sp<SkShader> fShaderB; + SkXfermode* fMode; typedef SkShader INHERITED; }; diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp index c479221369..409b652e93 100644 --- a/src/core/SkDraw.cpp +++ b/src/core/SkDraw.cpp @@ -81,10 +81,10 @@ public: SkAutoBitmapShaderInstall(const SkBitmap& src, const SkPaint& paint, const SkMatrix* localMatrix = nullptr) : fPaint(paint) /* makes a copy of the paint */ { - fPaint.setShader(SkCreateBitmapShader(src, SkShader::kClamp_TileMode, - SkShader::kClamp_TileMode, - localMatrix, &fAllocator)); + fPaint.setShader(SkMakeBitmapShader(src, SkShader::kClamp_TileMode, + SkShader::kClamp_TileMode, localMatrix, &fAllocator)); // we deliberately left the shader with an owner-count of 2 + fPaint.getShader()->ref(); SkASSERT(2 == fPaint.getShader()->getRefCnt()); } @@ -1880,7 +1880,7 @@ void SkDraw::drawVertices(SkCanvas::VertexMode vmode, int count, Thus for texture drawing, we need both texture[] and a shader. */ - SkTriColorShader triShader; // must be above declaration of p + auto triShader = sk_make_sp<SkTriColorShader>(); SkPaint p(paint); SkShader* shader = p.getShader(); @@ -1894,11 +1894,12 @@ void SkDraw::drawVertices(SkCanvas::VertexMode vmode, int count, } // setup the custom shader (if needed) - SkAutoTUnref<SkComposeShader> composeShader; + sk_sp<SkShader> composeShader; if (colors) { if (nullptr == textures) { // just colors (no texture) - shader = p.setShader(&triShader); + p.setShader(triShader); + shader = p.getShader(); } else { // colors * texture SkASSERT(shader); @@ -1907,7 +1908,7 @@ void SkDraw::drawVertices(SkCanvas::VertexMode vmode, int count, xmode = SkXfermode::Create(SkXfermode::kModulate_Mode); releaseMode = true; } - composeShader.reset(new SkComposeShader(&triShader, shader, xmode)); + composeShader = sk_make_sp<SkComposeShader>(triShader, sk_ref_sp(shader), xmode); p.setShader(composeShader); if (releaseMode) { xmode->unref(); @@ -1940,14 +1941,14 @@ void SkDraw::drawVertices(SkCanvas::VertexMode vmode, int count, } } if (colors) { - triShader.bindSetupData(&verticesSetup); + triShader->bindSetupData(&verticesSetup); } SkPoint tmp[] = { devVerts[state.f0], devVerts[state.f1], devVerts[state.f2] }; SkScan::FillTriangle(tmp, *fRC, blitter.get()); - triShader.bindSetupData(NULL); + triShader->bindSetupData(NULL); } } else { // no colors[] and no texture, stroke hairlines with paint's color. diff --git a/src/core/SkLocalMatrixShader.cpp b/src/core/SkLocalMatrixShader.cpp index 336f1c49cf..42b378d61a 100644 --- a/src/core/SkLocalMatrixShader.cpp +++ b/src/core/SkLocalMatrixShader.cpp @@ -10,7 +10,7 @@ SkFlattenable* SkLocalMatrixShader::CreateProc(SkReadBuffer& buffer) { SkMatrix lm; buffer.readMatrix(&lm); - SkAutoTUnref<SkShader> baseShader(buffer.readShader()); + auto baseShader(buffer.readShader()); if (!baseShader) { return nullptr; } diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp index 3d768074ca..678b1a1102 100644 --- a/src/core/SkPaint.cpp +++ b/src/core/SkPaint.cpp @@ -1929,7 +1929,7 @@ void SkPaint::unflatten(SkReadBuffer& buffer) { if (flatFlags & kHasEffects_FlatFlag) { SkSafeUnref(this->setPathEffect(buffer.readPathEffect())); - SkSafeUnref(this->setShader(buffer.readShader())); + this->setShader(buffer.readShader()); SkSafeUnref(this->setXfermode(buffer.readXfermode())); SkSafeUnref(this->setMaskFilter(buffer.readMaskFilter())); SkSafeUnref(this->setColorFilter(buffer.readColorFilter())); diff --git a/src/core/SkPictureShader.cpp b/src/core/SkPictureShader.cpp index 3919471b1b..a6644aacba 100644 --- a/src/core/SkPictureShader.cpp +++ b/src/core/SkPictureShader.cpp @@ -93,21 +93,21 @@ struct BitmapShaderRec : public SkResourceCache::Rec { } // namespace -SkPictureShader::SkPictureShader(const SkPicture* picture, TileMode tmx, TileMode tmy, +SkPictureShader::SkPictureShader(sk_sp<const SkPicture> picture, TileMode tmx, TileMode tmy, const SkMatrix* localMatrix, const SkRect* tile) : INHERITED(localMatrix) - , fPicture(SkRef(picture)) - , fTile(tile ? *tile : picture->cullRect()) + , fPicture(std::move(picture)) + , fTile(tile ? *tile : fPicture->cullRect()) , fTmx(tmx) , fTmy(tmy) { } -SkShader* SkPictureShader::Create(const SkPicture* picture, TileMode tmx, TileMode tmy, - const SkMatrix* localMatrix, const SkRect* tile) { +sk_sp<SkShader> SkPictureShader::Make(sk_sp<const SkPicture> picture, TileMode tmx, TileMode tmy, + const SkMatrix* localMatrix, const SkRect* tile) { if (!picture || picture->cullRect().isEmpty() || (tile && tile->isEmpty())) { - return SkShader::CreateEmptyShader(); + return SkShader::MakeEmptyShader(); } - return new SkPictureShader(picture, tmx, tmy, localMatrix, tile); + return sk_sp<SkShader>(new SkPictureShader(std::move(picture), tmx, tmy, localMatrix, tile)); } SkFlattenable* SkPictureShader::CreateProc(SkReadBuffer& buffer) { @@ -118,7 +118,7 @@ SkFlattenable* SkPictureShader::CreateProc(SkReadBuffer& buffer) { SkRect tile; buffer.readRect(&tile); - SkAutoTUnref<SkPicture> picture; + sk_sp<SkPicture> picture; if (buffer.isCrossProcess() && SkPicture::PictureIOSecurityPrecautionsEnabled()) { if (buffer.isVersionLT(SkReadBuffer::kPictureShaderHasPictureBool_Version)) { @@ -136,7 +136,7 @@ SkFlattenable* SkPictureShader::CreateProc(SkReadBuffer& buffer) { picture.reset(SkPicture::CreateFromBuffer(buffer)); } } - return SkPictureShader::Create(picture, mx, my, &lm, &tile); + return SkPictureShader::Make(picture, mx, my, &lm, &tile).release(); } void SkPictureShader::flatten(SkWriteBuffer& buffer) const { @@ -155,8 +155,8 @@ void SkPictureShader::flatten(SkWriteBuffer& buffer) const { } } -SkShader* SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, const SkMatrix* localM, - const int maxTextureSize) const { +sk_sp<SkShader> SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, const SkMatrix* localM, + const int maxTextureSize) const { SkASSERT(fPicture && !fPicture->cullRect().isEmpty()); SkMatrix m; @@ -203,14 +203,14 @@ SkShader* SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, const SkM const SkISize tileSize = scaledSize.toCeil(); #endif if (tileSize.isEmpty()) { - return SkShader::CreateEmptyShader(); + return SkShader::MakeEmptyShader(); } // The actual scale, compensating for rounding & clamping. const SkSize tileScale = SkSize::Make(SkIntToScalar(tileSize.width()) / fTile.width(), SkIntToScalar(tileSize.height()) / fTile.height()); - SkAutoTUnref<SkShader> tileShader; + sk_sp<SkShader> tileShader; BitmapShaderKey key(fPicture->uniqueID(), fTile, fTmx, @@ -224,7 +224,7 @@ SkShader* SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, const SkM SkMatrix::kFill_ScaleToFit); SkAutoTUnref<SkImage> tileImage( - SkImage::NewFromPicture(fPicture, tileSize, &tileMatrix, nullptr)); + SkImage::NewFromPicture(fPicture.get(), tileSize, &tileMatrix, nullptr)); if (!tileImage) { return nullptr; } @@ -238,7 +238,7 @@ SkShader* SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, const SkM tileInfo.getSafeSize(tileInfo.minRowBytes()))); } - return tileShader.detach(); + return tileShader; } size_t SkPictureShader::onContextSize(const ContextRec&) const { @@ -246,8 +246,8 @@ size_t SkPictureShader::onContextSize(const ContextRec&) const { } SkShader::Context* SkPictureShader::onCreateContext(const ContextRec& rec, void* storage) const { - SkAutoTUnref<SkShader> bitmapShader(this->refBitmapShader(*rec.fMatrix, rec.fLocalMatrix)); - if (nullptr == bitmapShader.get()) { + sk_sp<SkShader> bitmapShader(this->refBitmapShader(*rec.fMatrix, rec.fLocalMatrix)); + if (!bitmapShader) { return nullptr; } return PictureShaderContext::Create(storage, *this, rec, bitmapShader); @@ -256,8 +256,10 @@ SkShader::Context* SkPictureShader::onCreateContext(const ContextRec& rec, void* ///////////////////////////////////////////////////////////////////////////////////////// SkShader::Context* SkPictureShader::PictureShaderContext::Create(void* storage, - const SkPictureShader& shader, const ContextRec& rec, SkShader* bitmapShader) { - PictureShaderContext* ctx = new (storage) PictureShaderContext(shader, rec, bitmapShader); + const SkPictureShader& shader, const ContextRec& rec, + sk_sp<SkShader> bitmapShader) { + PictureShaderContext* ctx = new (storage) PictureShaderContext(shader, rec, + std::move(bitmapShader)); if (nullptr == ctx->fBitmapShaderContext) { ctx->~PictureShaderContext(); ctx = nullptr; @@ -266,12 +268,12 @@ SkShader::Context* SkPictureShader::PictureShaderContext::Create(void* storage, } SkPictureShader::PictureShaderContext::PictureShaderContext( - const SkPictureShader& shader, const ContextRec& rec, SkShader* bitmapShader) + const SkPictureShader& shader, const ContextRec& rec, sk_sp<SkShader> bitmapShader) : INHERITED(shader, rec) - , fBitmapShader(SkRef(bitmapShader)) + , fBitmapShader(std::move(bitmapShader)) { - fBitmapShaderContextStorage = sk_malloc_throw(bitmapShader->contextSize(rec)); - fBitmapShaderContext = bitmapShader->createContext(rec, fBitmapShaderContextStorage); + fBitmapShaderContextStorage = sk_malloc_throw(fBitmapShader->contextSize(rec)); + fBitmapShaderContext = fBitmapShader->createContext(rec, fBitmapShaderContextStorage); //if fBitmapShaderContext is null, we are invalid } @@ -325,7 +327,7 @@ const GrFragmentProcessor* SkPictureShader::asFragmentProcessor( if (context) { maxTextureSize = context->caps()->maxTextureSize(); } - SkAutoTUnref<SkShader> bitmapShader(this->refBitmapShader(viewM, localMatrix, maxTextureSize)); + sk_sp<SkShader> bitmapShader(this->refBitmapShader(viewM, localMatrix, maxTextureSize)); if (!bitmapShader) { return nullptr; } diff --git a/src/core/SkPictureShader.h b/src/core/SkPictureShader.h index 8cccd251d5..eb9c38b95b 100644 --- a/src/core/SkPictureShader.h +++ b/src/core/SkPictureShader.h @@ -22,8 +22,8 @@ class SkPicture; */ class SkPictureShader : public SkShader { public: - static SkShader* Create(const SkPicture*, TileMode, TileMode, const SkMatrix*, - const SkRect*); + static sk_sp<SkShader> Make(sk_sp<const SkPicture>, TileMode, TileMode, const SkMatrix*, + const SkRect*); SK_TO_STRING_OVERRIDE() SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPictureShader) @@ -42,18 +42,19 @@ protected: Context* onCreateContext(const ContextRec&, void* storage) const override; private: - SkPictureShader(const SkPicture*, TileMode, TileMode, const SkMatrix*, const SkRect*); + SkPictureShader(sk_sp<const SkPicture>, TileMode, TileMode, const SkMatrix*, const SkRect*); - SkShader* refBitmapShader(const SkMatrix&, const SkMatrix* localMatrix, const int maxTextureSize = 0) const; + sk_sp<SkShader> refBitmapShader(const SkMatrix&, const SkMatrix* localMatrix, + const int maxTextureSize = 0) const; - SkAutoTUnref<const SkPicture> fPicture; - SkRect fTile; - TileMode fTmx, fTmy; + sk_sp<const SkPicture> fPicture; + SkRect fTile; + TileMode fTmx, fTmy; class PictureShaderContext : public SkShader::Context { public: static Context* Create(void* storage, const SkPictureShader&, const ContextRec&, - SkShader* bitmapShader); + sk_sp<SkShader> bitmapShader); virtual ~PictureShaderContext(); @@ -63,11 +64,12 @@ private: void shadeSpan(int x, int y, SkPMColor dstC[], int count) override; private: - PictureShaderContext(const SkPictureShader&, const ContextRec&, SkShader* bitmapShader); + PictureShaderContext(const SkPictureShader&, const ContextRec&, + sk_sp<SkShader> bitmapShader); - SkAutoTUnref<SkShader> fBitmapShader; - SkShader::Context* fBitmapShaderContext; - void* fBitmapShaderContextStorage; + sk_sp<SkShader> fBitmapShader; + SkShader::Context* fBitmapShaderContext; + void* fBitmapShaderContextStorage; typedef SkShader::Context INHERITED; }; diff --git a/src/core/SkReadBuffer.h b/src/core/SkReadBuffer.h index b9b30944ff..5db9f4644d 100644 --- a/src/core/SkReadBuffer.h +++ b/src/core/SkReadBuffer.h @@ -136,7 +136,7 @@ public: SkMaskFilter* readMaskFilter() { return this->readFlattenable<SkMaskFilter>(); } SkPathEffect* readPathEffect() { return this->readFlattenable<SkPathEffect>(); } SkRasterizer* readRasterizer() { return this->readFlattenable<SkRasterizer>(); } - SkShader* readShader() { return this->readFlattenable<SkShader>(); } + sk_sp<SkShader> readShader() { return sk_sp<SkShader>(this->readFlattenable<SkShader>()); } SkXfermode* readXfermode() { return this->readFlattenable<SkXfermode>(); } /** diff --git a/src/core/SkShader.cpp b/src/core/SkShader.cpp index 75f527bff3..7b322fb627 100644 --- a/src/core/SkShader.cpp +++ b/src/core/SkShader.cpp @@ -229,18 +229,18 @@ SkShader* SkShader::refAsALocalMatrixShader(SkMatrix*) const { return nullptr; } -SkShader* SkShader::CreateEmptyShader() { return new SkEmptyShader; } +sk_sp<SkShader> SkShader::MakeEmptyShader() { return sk_make_sp<SkEmptyShader>(); } -SkShader* SkShader::CreateColorShader(SkColor color) { return new SkColorShader(color); } +sk_sp<SkShader> SkShader::MakeColorShader(SkColor color) { return sk_make_sp<SkColorShader>(color); } -SkShader* SkShader::CreateBitmapShader(const SkBitmap& src, TileMode tmx, TileMode tmy, - const SkMatrix* localMatrix) { - return SkCreateBitmapShader(src, tmx, tmy, localMatrix, nullptr); +sk_sp<SkShader> SkShader::MakeBitmapShader(const SkBitmap& src, TileMode tmx, TileMode tmy, + const SkMatrix* localMatrix) { + return SkMakeBitmapShader(src, tmx, tmy, localMatrix, nullptr); } -SkShader* SkShader::CreatePictureShader(const SkPicture* src, TileMode tmx, TileMode tmy, - const SkMatrix* localMatrix, const SkRect* tile) { - return SkPictureShader::Create(src, tmx, tmy, localMatrix, tile); +sk_sp<SkShader> SkShader::MakePictureShader(sk_sp<const SkPicture> src, TileMode tmx, TileMode tmy, + const SkMatrix* localMatrix, const SkRect* tile) { + return SkPictureShader::Make(std::move(src), tmx, tmy, localMatrix, tile); } #ifndef SK_IGNORE_TO_STRING @@ -362,7 +362,7 @@ void SkColorShader::toString(SkString* str) const { /////////////////////////////////////////////////////////////////////////////// SkFlattenable* SkEmptyShader::CreateProc(SkReadBuffer&) { - return SkShader::CreateEmptyShader(); + return SkShader::MakeEmptyShader().release(); } #ifndef SK_IGNORE_TO_STRING @@ -376,3 +376,18 @@ void SkEmptyShader::toString(SkString* str) const { str->append(")"); } #endif + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef SK_SUPPORT_LEGACY_CREATESHADER_PTR +SkShader* SkShader::CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode::Mode mode) { + return MakeComposeShader(sk_ref_sp(dst), sk_ref_sp(src), mode).release(); +} +SkShader* SkShader::CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode* xfer) { + return MakeComposeShader(sk_ref_sp(dst), sk_ref_sp(src), xfer).release(); +} +SkShader* SkShader::CreatePictureShader(const SkPicture* src, TileMode tmx, TileMode tmy, + const SkMatrix* localMatrix, const SkRect* tile) { + return MakePictureShader(sk_ref_sp(src), tmx, tmy, localMatrix, tile).release(); +} +#endif diff --git a/src/effects/SkTileImageFilter.cpp b/src/effects/SkTileImageFilter.cpp index 66cad47ad0..dff8e9bbfc 100644 --- a/src/effects/SkTileImageFilter.cpp +++ b/src/effects/SkTileImageFilter.cpp @@ -96,10 +96,8 @@ bool SkTileImageFilter::onFilterImageDeprecated(Proxy* proxy, const SkBitmap& sr SkCanvas canvas(device); SkPaint paint; paint.setXfermodeMode(SkXfermode::kSrc_Mode); - - SkAutoTUnref<SkShader> shader(SkShader::CreateBitmapShader(subset, - SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode)); - paint.setShader(shader); + paint.setShader(SkShader::MakeBitmapShader(subset, SkShader::kRepeat_TileMode, + SkShader::kRepeat_TileMode)); canvas.translate(-dstRect.fLeft, -dstRect.fTop); canvas.drawRect(dstRect, paint); *dst = device->accessBitmap(false); diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp index 985d45966b..9fe6c91a01 100644 --- a/src/effects/gradients/SkGradientShader.cpp +++ b/src/effects/gradients/SkGradientShader.cpp @@ -786,7 +786,7 @@ static void desc_init(SkGradientShaderBase::Descriptor* desc, desc->fLocalMatrix = localMatrix; } -SkShader* SkGradientShader::CreateLinear(const SkPoint pts[2], +sk_sp<SkShader> SkGradientShader::MakeLinear(const SkPoint pts[2], const SkColor colors[], const SkScalar pos[], int colorCount, SkShader::TileMode mode, @@ -802,10 +802,10 @@ SkShader* SkGradientShader::CreateLinear(const SkPoint pts[2], SkGradientShaderBase::Descriptor desc; desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix); - return new SkLinearGradient(pts, desc); + return sk_make_sp<SkLinearGradient>(pts, desc); } -SkShader* SkGradientShader::CreateRadial(const SkPoint& center, SkScalar radius, +sk_sp<SkShader> SkGradientShader::MakeRadial(const SkPoint& center, SkScalar radius, const SkColor colors[], const SkScalar pos[], int colorCount, SkShader::TileMode mode, @@ -821,10 +821,10 @@ SkShader* SkGradientShader::CreateRadial(const SkPoint& center, SkScalar radius, SkGradientShaderBase::Descriptor desc; desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix); - return new SkRadialGradient(center, radius, desc); + return sk_make_sp<SkRadialGradient>(center, radius, desc); } -SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start, +sk_sp<SkShader> SkGradientShader::MakeTwoPointConical(const SkPoint& start, SkScalar startRadius, const SkPoint& end, SkScalar endRadius, @@ -842,7 +842,7 @@ SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start, } if (startRadius == endRadius) { if (start == end || startRadius == 0) { - return SkShader::CreateEmptyShader(); + return SkShader::MakeEmptyShader(); } } @@ -854,8 +854,8 @@ SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start, if (!flipGradient) { desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix); - return new SkTwoPointConicalGradient(start, startRadius, end, endRadius, flipGradient, - desc); + return sk_make_sp<SkTwoPointConicalGradient>(start, startRadius, end, endRadius, + flipGradient, desc); } else { SkAutoSTArray<8, SkColor> colorsNew(colorCount); SkAutoSTArray<8, SkScalar> posNew(colorCount); @@ -872,12 +872,12 @@ SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start, desc_init(&desc, colorsNew.get(), nullptr, colorCount, mode, flags, localMatrix); } - return new SkTwoPointConicalGradient(end, endRadius, start, startRadius, flipGradient, - desc); + return sk_make_sp<SkTwoPointConicalGradient>(end, endRadius, start, startRadius, + flipGradient, desc); } } -SkShader* SkGradientShader::CreateSweep(SkScalar cx, SkScalar cy, +sk_sp<SkShader> SkGradientShader::MakeSweep(SkScalar cx, SkScalar cy, const SkColor colors[], const SkScalar pos[], int colorCount, @@ -890,7 +890,7 @@ SkShader* SkGradientShader::CreateSweep(SkScalar cx, SkScalar cy, SkGradientShaderBase::Descriptor desc; desc_init(&desc, colors, pos, colorCount, SkShader::kClamp_TileMode, flags, localMatrix); - return new SkSweepGradient(cx, cy, desc); + return sk_make_sp<SkSweepGradient>(cx, cy, desc); } SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkGradientShader) diff --git a/src/effects/gradients/SkLinearGradient.cpp b/src/effects/gradients/SkLinearGradient.cpp index 15d461960d..8ad120991d 100644 --- a/src/effects/gradients/SkLinearGradient.cpp +++ b/src/effects/gradients/SkLinearGradient.cpp @@ -78,8 +78,8 @@ SkFlattenable* SkLinearGradient::CreateProc(SkReadBuffer& buffer) { SkPoint pts[2]; pts[0] = buffer.readPoint(); pts[1] = buffer.readPoint(); - return SkGradientShader::CreateLinear(pts, desc.fColors, desc.fPos, desc.fCount, - desc.fTileMode, desc.fGradFlags, desc.fLocalMatrix); + return SkGradientShader::MakeLinear(pts, desc.fColors, desc.fPos, desc.fCount, desc.fTileMode, + desc.fGradFlags, desc.fLocalMatrix).release(); } void SkLinearGradient::flatten(SkWriteBuffer& buffer) const { @@ -430,9 +430,7 @@ const GrFragmentProcessor* GrLinearGradient::TestCreate(GrProcessorTestData* d) SkScalar* stops = stopsArray; SkShader::TileMode tm; int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm); - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateLinear(points, - colors, stops, colorCount, - tm)); + auto shader = SkGradientShader::MakeLinear(points, colors, stops, colorCount, tm); const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext, GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality); GrAlwaysAssert(fp); diff --git a/src/effects/gradients/SkRadialGradient.cpp b/src/effects/gradients/SkRadialGradient.cpp index d175f238cd..1560cd2f39 100644 --- a/src/effects/gradients/SkRadialGradient.cpp +++ b/src/effects/gradients/SkRadialGradient.cpp @@ -68,8 +68,9 @@ SkFlattenable* SkRadialGradient::CreateProc(SkReadBuffer& buffer) { } const SkPoint center = buffer.readPoint(); const SkScalar radius = buffer.readScalar(); - return SkGradientShader::CreateRadial(center, radius, desc.fColors, desc.fPos, desc.fCount, - desc.fTileMode, desc.fGradFlags, desc.fLocalMatrix); + return SkGradientShader::MakeRadial(center, radius, desc.fColors, desc.fPos, desc.fCount, + desc.fTileMode, desc.fGradFlags, + desc.fLocalMatrix).release(); } void SkRadialGradient::flatten(SkWriteBuffer& buffer) const { @@ -313,9 +314,7 @@ const GrFragmentProcessor* GrRadialGradient::TestCreate(GrProcessorTestData* d) SkScalar* stops = stopsArray; SkShader::TileMode tm; int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm); - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateRadial(center, radius, - colors, stops, colorCount, - tm)); + auto shader = SkGradientShader::MakeRadial(center, radius, colors, stops, colorCount, tm); const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext, GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality); GrAlwaysAssert(fp); diff --git a/src/effects/gradients/SkSweepGradient.cpp b/src/effects/gradients/SkSweepGradient.cpp index 1bdf40e115..3021e4bc08 100644 --- a/src/effects/gradients/SkSweepGradient.cpp +++ b/src/effects/gradients/SkSweepGradient.cpp @@ -36,8 +36,8 @@ SkFlattenable* SkSweepGradient::CreateProc(SkReadBuffer& buffer) { return nullptr; } const SkPoint center = buffer.readPoint(); - return SkGradientShader::CreateSweep(center.x(), center.y(), desc.fColors, desc.fPos, - desc.fCount, desc.fGradFlags, desc.fLocalMatrix); + return SkGradientShader::MakeSweep(center.x(), center.y(), desc.fColors, desc.fPos, + desc.fCount, desc.fGradFlags, desc.fLocalMatrix).release(); } void SkSweepGradient::flatten(SkWriteBuffer& buffer) const { @@ -190,8 +190,8 @@ const GrFragmentProcessor* GrSweepGradient::TestCreate(GrProcessorTestData* d) { SkScalar* stops = stopsArray; SkShader::TileMode tmIgnored; int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tmIgnored); - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateSweep(center.fX, center.fY, - colors, stops, colorCount)); + sk_sp<SkShader> shader(SkGradientShader::MakeSweep(center.fX, center.fY, colors, stops, + colorCount)); const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext, GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality); diff --git a/src/effects/gradients/SkTwoPointConicalGradient.cpp b/src/effects/gradients/SkTwoPointConicalGradient.cpp index 43d6f1f7c9..d9fc39c3bc 100644 --- a/src/effects/gradients/SkTwoPointConicalGradient.cpp +++ b/src/effects/gradients/SkTwoPointConicalGradient.cpp @@ -338,9 +338,9 @@ SkFlattenable* SkTwoPointConicalGradient::CreateProc(SkReadBuffer& buffer) { } } - return SkGradientShader::CreateTwoPointConical(c1, r1, c2, r2, desc.fColors, desc.fPos, - desc.fCount, desc.fTileMode, desc.fGradFlags, - desc.fLocalMatrix); + return SkGradientShader::MakeTwoPointConical(c1, r1, c2, r2, desc.fColors, desc.fPos, + desc.fCount, desc.fTileMode, desc.fGradFlags, + desc.fLocalMatrix).release(); } void SkTwoPointConicalGradient::flatten(SkWriteBuffer& buffer) const { diff --git a/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp b/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp index 5b0855ab7c..539436928c 100644 --- a/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp +++ b/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp @@ -207,10 +207,8 @@ const GrFragmentProcessor* Edge2PtConicalEffect::TestCreate(GrProcessorTestData* SkScalar* stops = stopsArray; SkShader::TileMode tm; int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm); - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1, - center2, radius2, - colors, stops, colorCount, - tm)); + auto shader = SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2, + colors, stops, colorCount, tm); const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext, GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality); GrAlwaysAssert(fp); @@ -484,10 +482,8 @@ const GrFragmentProcessor* FocalOutside2PtConicalEffect::TestCreate(GrProcessorT SkScalar* stops = stopsArray; SkShader::TileMode tm; int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm); - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1, - center2, radius2, - colors, stops, colorCount, - tm)); + auto shader = SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2, + colors, stops, colorCount, tm); const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext, GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality); GrAlwaysAssert(fp); @@ -692,10 +688,8 @@ const GrFragmentProcessor* FocalInside2PtConicalEffect::TestCreate(GrProcessorTe SkScalar* stops = stopsArray; SkShader::TileMode tm; int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm); - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1, - center2, radius2, - colors, stops, colorCount, - tm)); + auto shader = SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2, + colors, stops, colorCount, tm); const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext, GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality); GrAlwaysAssert(fp); @@ -940,10 +934,8 @@ const GrFragmentProcessor* CircleInside2PtConicalEffect::TestCreate(GrProcessorT SkScalar* stops = stopsArray; SkShader::TileMode tm; int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm); - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1, - center2, radius2, - colors, stops, colorCount, - tm)); + auto shader = SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2, + colors, stops, colorCount, tm); const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext, GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality); GrAlwaysAssert(fp); @@ -1173,10 +1165,8 @@ const GrFragmentProcessor* CircleOutside2PtConicalEffect::TestCreate(GrProcessor SkScalar* stops = stopsArray; SkShader::TileMode tm; int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm); - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1, - center2, radius2, - colors, stops, colorCount, - tm)); + auto shader = SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2, + colors, stops, colorCount, tm); const GrFragmentProcessor* fp = shader->asFragmentProcessor( d->fContext,GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality); GrAlwaysAssert(fp); diff --git a/src/utils/SkMeshUtils.cpp b/src/utils/SkMeshUtils.cpp index cf4e5099b3..5d3eefc54f 100644 --- a/src/utils/SkMeshUtils.cpp +++ b/src/utils/SkMeshUtils.cpp @@ -92,9 +92,9 @@ void SkMeshUtils::Draw(SkCanvas* canvas, const SkBitmap& bitmap, if (idx.init(bitmap.width(), bitmap.height(), rows, cols)) { SkPaint p(paint); - p.setShader(SkShader::CreateBitmapShader(bitmap, + p.setShader(SkShader::MakeBitmapShader(bitmap, SkShader::kClamp_TileMode, - SkShader::kClamp_TileMode))->unref(); + SkShader::kClamp_TileMode)); canvas->drawVertices(SkCanvas::kTriangles_VertexMode, rows * cols, verts, idx.tex(), colors, nullptr, idx.indices(), idx.indexCount(), p); diff --git a/src/utils/SkNinePatch.cpp b/src/utils/SkNinePatch.cpp index 5ee488e44b..aeb65b1e28 100644 --- a/src/utils/SkNinePatch.cpp +++ b/src/utils/SkNinePatch.cpp @@ -236,14 +236,13 @@ void SkNinePatch::DrawMesh(SkCanvas* canvas, const SkRect& bounds, fillRow(verts, texs, bounds.fBottom, SkIntToScalar(bitmap.height()), bounds, xDivs, numXDivs, stretchX, bitmap.width()); - SkShader* shader = SkShader::CreateBitmapShader(bitmap, - SkShader::kClamp_TileMode, - SkShader::kClamp_TileMode); SkPaint p; if (paint) { p = *paint; } - p.setShader(shader)->unref(); + p.setShader(SkShader::MakeBitmapShader(bitmap, + SkShader::kClamp_TileMode, + SkShader::kClamp_TileMode)); canvas->drawVertices(SkCanvas::kTriangles_VertexMode, vCount, mesh.fVerts, mesh.fTexs, mesh.fColors, nullptr, mesh.fIndices, indexCount, p); diff --git a/tools/sk_tool_utils.cpp b/tools/sk_tool_utils.cpp index e2bc0fc42c..10e5c305c3 100644 --- a/tools/sk_tool_utils.cpp +++ b/tools/sk_tool_utils.cpp @@ -178,13 +178,13 @@ void write_pixels(SkCanvas* canvas, const SkBitmap& bitmap, int x, int y, canvas->writePixels(info, tmp.getPixels(), tmp.rowBytes(), x, y); } -SkShader* create_checkerboard_shader(SkColor c1, SkColor c2, int size) { +sk_sp<SkShader> create_checkerboard_shader(SkColor c1, SkColor c2, int size) { SkBitmap bm; bm.allocN32Pixels(2 * size, 2 * size); bm.eraseColor(c1); bm.eraseArea(SkIRect::MakeLTRB(0, 0, size, size), c2); bm.eraseArea(SkIRect::MakeLTRB(size, size, 2 * size, 2 * size), c2); - return SkShader::CreateBitmapShader( + return SkShader::MakeBitmapShader( bm, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode); } @@ -199,7 +199,7 @@ SkBitmap create_checkerboard_bitmap(int w, int h, SkColor c1, SkColor c2, int ch void draw_checkerboard(SkCanvas* canvas, SkColor c1, SkColor c2, int size) { SkPaint paint; - paint.setShader(create_checkerboard_shader(c1, c2, size))->unref(); + paint.setShader(create_checkerboard_shader(c1, c2, size)); paint.setXfermodeMode(SkXfermode::kSrc_Mode); canvas->drawPaint(paint); } diff --git a/tools/sk_tool_utils.h b/tools/sk_tool_utils.h index dab42e31fd..1e67afb6d2 100644 --- a/tools/sk_tool_utils.h +++ b/tools/sk_tool_utils.h @@ -92,7 +92,7 @@ namespace sk_tool_utils { SkTypeface* create_font(const char* name, SkTypeface::Style); /** Returns a newly created CheckerboardShader. */ - SkShader* create_checkerboard_shader(SkColor c1, SkColor c2, int size); + sk_sp<SkShader> create_checkerboard_shader(SkColor c1, SkColor c2, int size); /** Draw a checkerboard pattern in the current canvas, restricted to the current clip, using SkXfermode::kSrc_Mode. */ |