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/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);