use Make instead of Create to return a shared shader
Partially updated call sites. Undefine the flag in SkSHader.h to convert the remaining sites.
BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1772463002
Review URL: https://codereview.chromium.org/1772463002
diff --git a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
index 9e839f1..f688540 100644
--- a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
+++ b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
@@ -309,24 +309,27 @@
#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 @@
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 @@
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 @@
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 fac098a..8a51583 100644
--- a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.h
+++ b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.h
@@ -61,26 +61,26 @@
* 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 71ec27c..65fa0c4 100644
--- a/gm/alphagradients.cpp
+++ b/gm/alphagradients.cpp
@@ -28,9 +28,8 @@
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 eb2ecb8..bddd200 100644
--- a/gm/arithmode.cpp
+++ b/gm/arithmode.cpp
@@ -31,9 +31,8 @@
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 @@
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 7c51c74..85eaa1e 100644
--- a/gm/badpaint.cpp
+++ b/gm/badpaint.cpp
@@ -32,14 +32,13 @@
// 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 5d7b35c..491905a 100644
--- a/gm/bitmapshader.cpp
+++ b/gm/bitmapshader.cpp
@@ -35,11 +35,6 @@
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 @@
}
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 @@
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
diff --git a/gm/gm.cpp b/gm/gm.cpp
index dc882fd..ebdc4f1 100644
--- a/gm/gm.cpp
+++ b/gm/gm.cpp
@@ -85,10 +85,9 @@
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 a240534..d7a9024 100644
--- a/gm/lcdblendmodes.cpp
+++ b/gm/lcdblendmodes.cpp
@@ -48,9 +48,7 @@
}
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 @@
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 5f1a745..7791acb 100644
--- a/gm/pixelsnap.cpp
+++ b/gm/pixelsnap.cpp
@@ -37,7 +37,7 @@
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 828467f..3e40936 100644
--- a/include/core/SkShader.h
+++ b/include/core/SkShader.h
@@ -23,6 +23,8 @@
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 @@
/**
* 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 SkShader* CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode::Mode);
+ static sk_sp<SkShader> MakeComposeShader(sk_sp<SkShader> dst, sk_sp<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 @@
* @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 @@
* 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 ae11e2d..e474f38 100644
--- a/include/effects/SkGradientShader.h
+++ b/include/effects/SkGradientShader.h
@@ -42,15 +42,14 @@
@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 @@
@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 @@
* 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 @@
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 de4d451..ad2d6be 100644
--- a/samplecode/PerlinPatch.cpp
+++ b/samplecode/PerlinPatch.cpp
@@ -60,9 +60,9 @@
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 @@
};
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 @@
NULL);
}
- virtual ~PerlinPatchView() {
- SkSafeUnref(fShader0);
- }
protected:
// overrides from SkEventSink
bool onQuery(SkEvent* evt) override {
@@ -145,16 +142,14 @@
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 07efd0a..c32025e 100644
--- a/samplecode/Sample2PtRadial.cpp
+++ b/samplecode/Sample2PtRadial.cpp
@@ -33,12 +33,10 @@
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 ae28925..4339223 100644
--- a/samplecode/SampleAARectModes.cpp
+++ b/samplecode/SampleAARectModes.cpp
@@ -61,7 +61,7 @@
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 @@
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 f552df6..d0c1115 100644
--- a/samplecode/SampleAARects.cpp
+++ b/samplecode/SampleAARects.cpp
@@ -62,10 +62,8 @@
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 addca35..48ac24d 100644
--- a/samplecode/SampleAll.cpp
+++ b/samplecode/SampleAll.cpp
@@ -361,7 +361,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 0fa7969..8ae0990 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 @@
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 @@
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 d7eed02..490c6a4 100644
--- a/samplecode/SampleBitmapRect.cpp
+++ b/samplecode/SampleBitmapRect.cpp
@@ -37,8 +37,8 @@
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 991013a..b860917 100644
--- a/samplecode/SampleCamera.cpp
+++ b/samplecode/SampleCamera.cpp
@@ -39,10 +39,10 @@
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 af1cd93..4ee8949 100644
--- a/samplecode/SampleColorFilter.cpp
+++ b/samplecode/SampleColorFilter.cpp
@@ -111,7 +111,7 @@
class ColorFilterView : public SampleView {
SkBitmap fBitmap;
- SkShader* fShader;
+ sk_sp<SkShader> fShader;
enum {
N = 64
};
@@ -126,10 +126,6 @@
}
}
- virtual ~ColorFilterView() {
- fShader->unref();
- }
-
protected:
// overrides from SkEventSink
virtual bool onQuery(SkEvent* evt) {
diff --git a/samplecode/SampleDegenerateTwoPtRadials.cpp b/samplecode/SampleDegenerateTwoPtRadials.cpp
index 32b4537..f171202 100644
--- a/samplecode/SampleDegenerateTwoPtRadials.cpp
+++ b/samplecode/SampleDegenerateTwoPtRadials.cpp
@@ -27,12 +27,10 @@
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 8c14fb5..a599418 100644
--- a/samplecode/SampleDither.cpp
+++ b/samplecode/SampleDither.cpp
@@ -34,9 +34,8 @@
// 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 df72dd4..34241c5 100644
--- a/samplecode/SampleDitherBitmap.cpp
+++ b/samplecode/SampleDitherBitmap.cpp
@@ -26,11 +26,8 @@
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 b58d557..12ea4e2 100644
--- a/samplecode/SampleEffects.cpp
+++ b/samplecode/SampleEffects.cpp
@@ -40,8 +40,8 @@
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 f3a2f6c..4b15e37 100644
--- a/samplecode/SampleFatBits.cpp
+++ b/samplecode/SampleFatBits.cpp
@@ -88,8 +88,7 @@
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 @@
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 2d6f7d4..5e9450e 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 @@
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 @@
{ 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 @@
}
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 @@
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 @@
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 ae41aa9..085581c 100644
--- a/samplecode/SampleHairModes.cpp
+++ b/samplecode/SampleHairModes.cpp
@@ -60,7 +60,7 @@
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 @@
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 f8ebd7c..beb7e4a 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 5347b01..c9ecb70 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 @@
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 @@
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 eae683f..48f29f7 100644
--- a/samplecode/SampleQuadStroker.cpp
+++ b/samplecode/SampleQuadStroker.cpp
@@ -109,7 +109,7 @@
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 @@
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 eb3e134..639203b 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 @@
// 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 @@
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 9287439..598a088 100644
--- a/samplecode/SampleRepeatTile.cpp
+++ b/samplecode/SampleRepeatTile.cpp
@@ -37,8 +37,7 @@
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 f13fd4e..cf0cb0f 100644
--- a/samplecode/SampleShaderText.cpp
+++ b/samplecode/SampleShaderText.cpp
@@ -23,18 +23,18 @@
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 @@
{ 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 @@
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 @@
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 2c0a6ab..71ddc2e 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 @@
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 @@
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 @@
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 8b85336..c3cc2bb 100644
--- a/samplecode/SampleSlides.cpp
+++ b/samplecode/SampleSlides.cpp
@@ -178,38 +178,37 @@
{ 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 @@
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 @@
#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 @@
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 ed244eb..125155e 100644
--- a/samplecode/SampleTiling.cpp
+++ b/samplecode/SampleTiling.cpp
@@ -35,15 +35,14 @@
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 8b1bdf0..4fb508b 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 @@
}
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 @@
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 2f2dc02..a8dcd22 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 @@
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 @@
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 221ba58..58546e1 100644
--- a/samplecode/SampleXfer.cpp
+++ b/samplecode/SampleXfer.cpp
@@ -127,10 +127,9 @@
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 f995c6a..63c90fe 100644
--- a/samplecode/SampleXfermodesBlur.cpp
+++ b/samplecode/SampleXfermodesBlur.cpp
@@ -150,10 +150,8 @@
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 4aecbc3..2fa4502 100644
--- a/src/animator/SkDrawGradient.cpp
+++ b/src/animator/SkDrawGradient.cpp
@@ -126,14 +126,12 @@
#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 @@
#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 9e3becc..2868b9f 100644
--- a/src/animator/SkDrawShader.cpp
+++ b/src/animator/SkDrawShader.cpp
@@ -71,8 +71,8 @@
//
// 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 6618881..f7fa30f 100644
--- a/src/c/sk_surface.cpp
+++ b/src/c/sk_surface.cpp
@@ -551,10 +551,10 @@
} 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 @@
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 @@
} 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 @@
}
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 d5dfcc1..fc0e63e 100644
--- a/src/core/SkBitmapDevice.cpp
+++ b/src/core/SkBitmapDevice.cpp
@@ -314,17 +314,15 @@
}
// 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 f261942..4813e01 100644
--- a/src/core/SkBitmapProcShader.cpp
+++ b/src/core/SkBitmapProcShader.cpp
@@ -289,7 +289,7 @@
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 @@
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 @@
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 dc4d832..185a95d 100644
--- a/src/core/SkBitmapProcShader.h
+++ b/src/core/SkBitmapProcShader.h
@@ -59,7 +59,7 @@
// 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 bb5cfb7..9fcab9c 100644
--- a/src/core/SkBlitter.cpp
+++ b/src/core/SkBlitter.cpp
@@ -584,13 +584,7 @@
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 @@
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 @@
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 c7cf76b..f5a3b9c 100644
--- a/src/core/SkColorFilterShader.cpp
+++ b/src/core/SkColorFilterShader.cpp
@@ -24,12 +24,12 @@
}
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 b6ba372..4d3e4e5 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() {
SkSafeUnref(fMode);
- fShaderB->unref();
- fShaderA->unref();
}
size_t SkComposeShader::onContextSize(const ContextRec& rec) const {
@@ -54,18 +53,18 @@
#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 @@
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 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
-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 9220a0d..ee6e36a 100644
--- a/src/core/SkComposeShader.h
+++ b/src/core/SkComposeShader.h
@@ -31,7 +31,7 @@
@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 @@
};
#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 @@
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 c479221..409b652 100644
--- a/src/core/SkDraw.cpp
+++ b/src/core/SkDraw.cpp
@@ -81,10 +81,10 @@
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 @@
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 @@
}
// 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 @@
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 @@
}
}
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 336f1c4..42b378d 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 3d76807..678b1a1 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -1929,7 +1929,7 @@
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 3919471..a6644aa 100644
--- a/src/core/SkPictureShader.cpp
+++ b/src/core/SkPictureShader.cpp
@@ -93,21 +93,21 @@
} // 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 @@
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 @@
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 @@
}
}
-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 @@
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 @@
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 @@
tileInfo.getSafeSize(tileInfo.minRowBytes())));
}
- return tileShader.detach();
+ return tileShader;
}
size_t SkPictureShader::onContextSize(const ContextRec&) const {
@@ -246,8 +246,8 @@
}
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::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 @@
}
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 @@
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 8cccd25..eb9c38b 100644
--- a/src/core/SkPictureShader.h
+++ b/src/core/SkPictureShader.h
@@ -22,8 +22,8 @@
*/
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 @@
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 @@
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 b9b3094..5db9f46 100644
--- a/src/core/SkReadBuffer.h
+++ b/src/core/SkReadBuffer.h
@@ -136,7 +136,7 @@
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 75f527b..7b322fb 100644
--- a/src/core/SkShader.cpp
+++ b/src/core/SkShader.cpp
@@ -229,18 +229,18 @@
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 @@
///////////////////////////////////////////////////////////////////////////////
SkFlattenable* SkEmptyShader::CreateProc(SkReadBuffer&) {
- return SkShader::CreateEmptyShader();
+ return SkShader::MakeEmptyShader().release();
}
#ifndef SK_IGNORE_TO_STRING
@@ -376,3 +376,18 @@
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 66cad47..dff8e9b 100644
--- a/src/effects/SkTileImageFilter.cpp
+++ b/src/effects/SkTileImageFilter.cpp
@@ -96,10 +96,8 @@
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 985d459..9fe6c91 100644
--- a/src/effects/gradients/SkGradientShader.cpp
+++ b/src/effects/gradients/SkGradientShader.cpp
@@ -786,7 +786,7 @@
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 @@
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 @@
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 @@
}
if (startRadius == endRadius) {
if (start == end || startRadius == 0) {
- return SkShader::CreateEmptyShader();
+ return SkShader::MakeEmptyShader();
}
}
@@ -854,8 +854,8 @@
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 @@
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 @@
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 15d4619..8ad1209 100644
--- a/src/effects/gradients/SkLinearGradient.cpp
+++ b/src/effects/gradients/SkLinearGradient.cpp
@@ -78,8 +78,8 @@
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 @@
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 d175f23..1560cd2 100644
--- a/src/effects/gradients/SkRadialGradient.cpp
+++ b/src/effects/gradients/SkRadialGradient.cpp
@@ -68,8 +68,9 @@
}
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 @@
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 1bdf40e..3021e4b 100644
--- a/src/effects/gradients/SkSweepGradient.cpp
+++ b/src/effects/gradients/SkSweepGradient.cpp
@@ -36,8 +36,8 @@
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 @@
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 43d6f1f..d9fc39c 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient.cpp
+++ b/src/effects/gradients/SkTwoPointConicalGradient.cpp
@@ -338,9 +338,9 @@
}
}
- 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 5b0855a..5394369 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp
+++ b/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp
@@ -207,10 +207,8 @@
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 @@
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 @@
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 @@
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 @@
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 cf4e509..5d3eefc 100644
--- a/src/utils/SkMeshUtils.cpp
+++ b/src/utils/SkMeshUtils.cpp
@@ -92,9 +92,9 @@
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 5ee488e..aeb65b1 100644
--- a/src/utils/SkNinePatch.cpp
+++ b/src/utils/SkNinePatch.cpp
@@ -236,14 +236,13 @@
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 e2bc0fc..10e5c30 100644
--- a/tools/sk_tool_utils.cpp
+++ b/tools/sk_tool_utils.cpp
@@ -178,13 +178,13 @@
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 @@
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 dab42e3..1e67afb 100644
--- a/tools/sk_tool_utils.h
+++ b/tools/sk_tool_utils.h
@@ -92,7 +92,7 @@
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. */