diff options
Diffstat (limited to 'src')
26 files changed, 191 insertions, 205 deletions
diff --git a/src/animator/SkDrawGradient.cpp b/src/animator/SkDrawGradient.cpp index 4aecbc3936..2fa4502f6b 100644 --- a/src/animator/SkDrawGradient.cpp +++ b/src/animator/SkDrawGradient.cpp @@ -126,14 +126,12 @@ void SkDrawLinearGradient::dump(SkAnimateMaker* maker) { #endif SkShader* SkDrawLinearGradient::getShader() { - if (addPrelude() == 0 || points.count() != 4) + if (addPrelude() == 0 || points.count() != 4) { return nullptr; - SkShader* shader = SkGradientShader::CreateLinear((SkPoint*)points.begin(), + } + return SkGradientShader::MakeLinear((SkPoint*)points.begin(), fColors.begin(), offsets.begin(), fColors.count(), (SkShader::TileMode) tileMode, - 0, getMatrix()); - SkAutoTDelete<SkShader> autoDel(shader); - (void)autoDel.detach(); - return shader; + 0, getMatrix()).release(); } @@ -161,12 +159,10 @@ void SkDrawRadialGradient::dump(SkAnimateMaker* maker) { #endif SkShader* SkDrawRadialGradient::getShader() { - if (addPrelude() == 0) + if (addPrelude() == 0) { return nullptr; - SkShader* shader = SkGradientShader::CreateRadial(center, + } + return SkGradientShader::MakeRadial(center, radius, fColors.begin(), offsets.begin(), fColors.count(), (SkShader::TileMode) tileMode, - 0, getMatrix()); - SkAutoTDelete<SkShader> autoDel(shader); - (void)autoDel.detach(); - return shader; + 0, getMatrix()).release(); } diff --git a/src/animator/SkDrawShader.cpp b/src/animator/SkDrawShader.cpp index 9e3becc48b..2868b9f4ef 100644 --- a/src/animator/SkDrawShader.cpp +++ b/src/animator/SkDrawShader.cpp @@ -71,8 +71,8 @@ SkShader* SkDrawBitmapShader::getShader() { // // oops, bitmapshader no longer takes filterBitmap, but deduces it at // draw-time from the paint - return SkShader::CreateBitmapShader(image->fBitmap, + return SkShader::MakeBitmapShader(image->fBitmap, (SkShader::TileMode) tileMode, (SkShader::TileMode) tileMode, - getMatrix()); + getMatrix()).release(); } diff --git a/src/c/sk_surface.cpp b/src/c/sk_surface.cpp index 6618881bc1..f7fa30f28a 100644 --- a/src/c/sk_surface.cpp +++ b/src/c/sk_surface.cpp @@ -551,10 +551,10 @@ sk_shader_t* sk_shader_new_linear_gradient(const sk_point_t pts[2], } else { matrix.setIdentity(); } - SkShader* s = SkGradientShader::CreateLinear(reinterpret_cast<const SkPoint*>(pts), - reinterpret_cast<const SkColor*>(colors), - colorPos, colorCount, mode, 0, &matrix); - return (sk_shader_t*)s; + return (sk_shader_t*)SkGradientShader::MakeLinear(reinterpret_cast<const SkPoint*>(pts), + reinterpret_cast<const SkColor*>(colors), + colorPos, colorCount, + mode, 0, &matrix).release(); } static const SkPoint& to_skpoint(const sk_point_t& p) { @@ -579,12 +579,10 @@ sk_shader_t* sk_shader_new_radial_gradient(const sk_point_t* ccenter, matrix.setIdentity(); } SkPoint center = to_skpoint(*ccenter); - SkShader* s = SkGradientShader::CreateRadial( - center, (SkScalar)radius, - reinterpret_cast<const SkColor*>(colors), - reinterpret_cast<const SkScalar*>(colorPos), - colorCount, mode, 0, &matrix); - return (sk_shader_t*)s; + return (sk_shader_t*)SkGradientShader::MakeRadial(center, (SkScalar)radius, + reinterpret_cast<const SkColor*>(colors), + reinterpret_cast<const SkScalar*>(colorPos), + colorCount, mode, 0, &matrix).release(); } sk_shader_t* sk_shader_new_sweep_gradient(const sk_point_t* ccenter, @@ -598,13 +596,11 @@ sk_shader_t* sk_shader_new_sweep_gradient(const sk_point_t* ccenter, } else { matrix.setIdentity(); } - SkShader* s = SkGradientShader::CreateSweep( - (SkScalar)(ccenter->x), - (SkScalar)(ccenter->y), - reinterpret_cast<const SkColor*>(colors), - reinterpret_cast<const SkScalar*>(colorPos), - colorCount, 0, &matrix); - return (sk_shader_t*)s; + return (sk_shader_t*)SkGradientShader::MakeSweep((SkScalar)(ccenter->x), + (SkScalar)(ccenter->y), + reinterpret_cast<const SkColor*>(colors), + reinterpret_cast<const SkScalar*>(colorPos), + colorCount, 0, &matrix).release(); } sk_shader_t* sk_shader_new_two_point_conical_gradient(const sk_point_t* start, @@ -628,13 +624,11 @@ sk_shader_t* sk_shader_new_two_point_conical_gradient(const sk_point_t* start, } SkPoint skstart = to_skpoint(*start); SkPoint skend = to_skpoint(*end); - SkShader* s = SkGradientShader::CreateTwoPointConical( - skstart, (SkScalar)startRadius, - skend, (SkScalar)endRadius, - reinterpret_cast<const SkColor*>(colors), - reinterpret_cast<const SkScalar*>(colorPos), - colorCount, mode, 0, &matrix); - return (sk_shader_t*)s; + return (sk_shader_t*)SkGradientShader::MakeTwoPointConical(skstart, (SkScalar)startRadius, + skend, (SkScalar)endRadius, + reinterpret_cast<const SkColor*>(colors), + reinterpret_cast<const SkScalar*>(colorPos), + colorCount, mode, 0, &matrix).release(); } /////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/core/SkBitmapDevice.cpp b/src/core/SkBitmapDevice.cpp index d5dfcc1733..fc0e63e9ae 100644 --- a/src/core/SkBitmapDevice.cpp +++ b/src/core/SkBitmapDevice.cpp @@ -314,17 +314,15 @@ void SkBitmapDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap, } // construct a shader, so we can call drawRect with the dst - SkShader* s = SkShader::CreateBitmapShader(*bitmapPtr, - SkShader::kClamp_TileMode, - SkShader::kClamp_TileMode, - &matrix); - if (nullptr == s) { + auto s = SkShader::MakeBitmapShader(*bitmapPtr, SkShader::kClamp_TileMode, + SkShader::kClamp_TileMode, &matrix); + if (!s) { return; } SkPaint paintWithShader(paint); paintWithShader.setStyle(SkPaint::kFill_Style); - paintWithShader.setShader(s)->unref(); + paintWithShader.setShader(std::move(s)); // Call ourself, in case the subclass wanted to share this setup code // but handle the drawRect code themselves. diff --git a/src/core/SkBitmapProcShader.cpp b/src/core/SkBitmapProcShader.cpp index f26194280c..4813e01d54 100644 --- a/src/core/SkBitmapProcShader.cpp +++ b/src/core/SkBitmapProcShader.cpp @@ -289,7 +289,7 @@ SkFlattenable* SkBitmapProcShader::CreateProc(SkReadBuffer& buffer) { bm.setImmutable(); TileMode mx = (TileMode)buffer.readUInt(); TileMode my = (TileMode)buffer.readUInt(); - return SkShader::CreateBitmapShader(bm, mx, my, &lm); + return SkShader::MakeBitmapShader(bm, mx, my, &lm).release(); } void SkBitmapProcShader::flatten(SkWriteBuffer& buffer) const { @@ -352,9 +352,9 @@ static bool bitmap_is_too_big(const SkBitmap& bm) { return bm.width() > kMaxSize || bm.height() > kMaxSize; } -SkShader* SkCreateBitmapShader(const SkBitmap& src, SkShader::TileMode tmx, - SkShader::TileMode tmy, const SkMatrix* localMatrix, - SkTBlitterAllocator* allocator) { +sk_sp<SkShader> SkMakeBitmapShader(const SkBitmap& src, SkShader::TileMode tmx, + SkShader::TileMode tmy, const SkMatrix* localMatrix, + SkTBlitterAllocator* allocator) { SkShader* shader; SkColor color; if (src.isNull() || bitmap_is_too_big(src)) { @@ -376,7 +376,7 @@ SkShader* SkCreateBitmapShader(const SkBitmap& src, SkShader::TileMode tmx, shader = allocator->createT<SkBitmapProcShader>(src, tmx, tmy, localMatrix); } } - return shader; + return sk_sp<SkShader>(shader); } /////////////////////////////////////////////////////////////////////////////// diff --git a/src/core/SkBitmapProcShader.h b/src/core/SkBitmapProcShader.h index dc4d832ca3..185a95de66 100644 --- a/src/core/SkBitmapProcShader.h +++ b/src/core/SkBitmapProcShader.h @@ -59,7 +59,7 @@ typedef SkSmallAllocator<3, 2100> SkTBlitterAllocator; // If alloc is non-nullptr, it will be used to allocate the returned SkShader, and MUST outlive // the SkShader. -SkShader* SkCreateBitmapShader(const SkBitmap& src, SkShader::TileMode, SkShader::TileMode, - const SkMatrix* localMatrix, SkTBlitterAllocator* alloc); +sk_sp<SkShader> SkMakeBitmapShader(const SkBitmap& src, SkShader::TileMode, SkShader::TileMode, + const SkMatrix* localMatrix, SkTBlitterAllocator* alloc); #endif diff --git a/src/core/SkBlitter.cpp b/src/core/SkBlitter.cpp index bb5cfb72e3..9fcab9c982 100644 --- a/src/core/SkBlitter.cpp +++ b/src/core/SkBlitter.cpp @@ -584,13 +584,7 @@ SkBlitter* SkBlitterClipper::apply(SkBlitter* blitter, const SkRegion* clip, class Sk3DShader : public SkShader { public: - Sk3DShader(SkShader* proxy) : fProxy(proxy) { - SkSafeRef(proxy); - } - - virtual ~Sk3DShader() { - SkSafeUnref(fProxy); - } + Sk3DShader(sk_sp<SkShader> proxy) : fProxy(std::move(proxy)) {} size_t onContextSize(const ContextRec& rec) const override { size_t size = sizeof(Sk3DShaderContext); @@ -727,18 +721,17 @@ public: protected: void flatten(SkWriteBuffer& buffer) const override { - buffer.writeFlattenable(fProxy); + buffer.writeFlattenable(fProxy.get()); } private: - SkShader* fProxy; + sk_sp<SkShader> fProxy; typedef SkShader INHERITED; }; SkFlattenable* Sk3DShader::CreateProc(SkReadBuffer& buffer) { - SkAutoTUnref<SkShader> shader(buffer.readShader()); - return new Sk3DShader(shader); + return new Sk3DShader(buffer.readShader()); } class Sk3DBlitter : public SkBlitter { @@ -822,7 +815,7 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device, if (origPaint.getMaskFilter() != nullptr && origPaint.getMaskFilter()->getFormat() == SkMask::k3D_Format) { - shader3D = new Sk3DShader(shader); + shader3D = new Sk3DShader(sk_sp<SkShader>(SkSafeRef(shader))); // we know we haven't initialized lazyPaint yet, so just do it paint.writable()->setShader(shader3D)->unref(); shader = shader3D; diff --git a/src/core/SkColorFilterShader.cpp b/src/core/SkColorFilterShader.cpp index c7cf76b53e..f5a3b9c9e1 100644 --- a/src/core/SkColorFilterShader.cpp +++ b/src/core/SkColorFilterShader.cpp @@ -24,12 +24,12 @@ SkColorFilterShader::SkColorFilterShader(SkShader* shader, SkColorFilter* filter } SkFlattenable* SkColorFilterShader::CreateProc(SkReadBuffer& buffer) { - SkAutoTUnref<SkShader> shader(buffer.readShader()); + auto shader = buffer.readShader(); SkAutoTUnref<SkColorFilter> filter(buffer.readColorFilter()); - if (!shader.get() || !filter.get()) { + if (!shader || !filter.get()) { return nullptr; } - return new SkColorFilterShader(shader, filter); + return new SkColorFilterShader(shader.get(), filter); } void SkColorFilterShader::flatten(SkWriteBuffer& buffer) const { diff --git a/src/core/SkComposeShader.cpp b/src/core/SkComposeShader.cpp index b6ba3729d1..4d3e4e57ba 100644 --- a/src/core/SkComposeShader.cpp +++ b/src/core/SkComposeShader.cpp @@ -16,9 +16,10 @@ /////////////////////////////////////////////////////////////////////////////// -SkComposeShader::SkComposeShader(SkShader* sA, SkShader* sB, SkXfermode* mode) { - fShaderA = sA; sA->ref(); - fShaderB = sB; sB->ref(); +SkComposeShader::SkComposeShader(sk_sp<SkShader> sA, sk_sp<SkShader> sB, SkXfermode* mode) + : fShaderA(std::move(sA)) + , fShaderB(std::move(sB)) +{ // mode may be null fMode = mode; SkSafeRef(mode); @@ -26,8 +27,6 @@ SkComposeShader::SkComposeShader(SkShader* sA, SkShader* sB, SkXfermode* mode) { SkComposeShader::~SkComposeShader() { SkSafeUnref(fMode); - fShaderB->unref(); - fShaderA->unref(); } size_t SkComposeShader::onContextSize(const ContextRec& rec) const { @@ -54,18 +53,18 @@ private: #define SkAutoAlphaRestore(...) SK_REQUIRE_LOCAL_VAR(SkAutoAlphaRestore) SkFlattenable* SkComposeShader::CreateProc(SkReadBuffer& buffer) { - SkAutoTUnref<SkShader> shaderA(buffer.readShader()); - SkAutoTUnref<SkShader> shaderB(buffer.readShader()); + sk_sp<SkShader> shaderA(buffer.readShader()); + sk_sp<SkShader> shaderB(buffer.readShader()); SkAutoTUnref<SkXfermode> mode(buffer.readXfermode()); - if (!shaderA.get() || !shaderB.get()) { + if (!shaderA || !shaderB) { return nullptr; } - return new SkComposeShader(shaderA, shaderB, mode); + return new SkComposeShader(std::move(shaderA), std::move(shaderB), mode); } void SkComposeShader::flatten(SkWriteBuffer& buffer) const { - buffer.writeFlattenable(fShaderA); - buffer.writeFlattenable(fShaderB); + buffer.writeFlattenable(fShaderA.get()); + buffer.writeFlattenable(fShaderB.get()); buffer.writeFlattenable(fMode); } @@ -119,8 +118,8 @@ SkComposeShader::ComposeShaderContext::~ComposeShaderContext() { bool SkComposeShader::asACompose(ComposeRec* rec) const { if (rec) { - rec->fShaderA = fShaderA; - rec->fShaderB = fShaderB; + rec->fShaderA = fShaderA.get(); + rec->fShaderB = fShaderB.get(); rec->fMode = fMode; } return true; @@ -255,14 +254,16 @@ void SkComposeShader::toString(SkString* str) const { /////////////////////////////////////////////////////////////////////////////////////////////////// -SkShader* SkShader::CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode* xfer) { +sk_sp<SkShader> SkShader::MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src, + SkXfermode* xfer) { if (!dst || !src) { return nullptr; } - return new SkComposeShader(dst, src, xfer); + return sk_make_sp<SkComposeShader>(std::move(dst), std::move(src), xfer); } -SkShader* SkShader::CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode::Mode mode) { +sk_sp<SkShader> SkShader::MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src, + SkXfermode::Mode mode) { SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(mode)); - return CreateComposeShader(dst, src, xfer); + return MakeComposeShader(std::move(dst), std::move(src), xfer); } diff --git a/src/core/SkComposeShader.h b/src/core/SkComposeShader.h index 9220a0de97..ee6e36a222 100644 --- a/src/core/SkComposeShader.h +++ b/src/core/SkComposeShader.h @@ -31,7 +31,7 @@ public: @param mode The xfermode that combines the colors from the two shaders. If mode is null, then SRC_OVER is assumed. */ - SkComposeShader(SkShader* sA, SkShader* sB, SkXfermode* mode = NULL); + SkComposeShader(sk_sp<SkShader> sA, sk_sp<SkShader> sB, SkXfermode* mode = NULL); virtual ~SkComposeShader(); #if SK_SUPPORT_GPU @@ -63,8 +63,8 @@ public: }; #ifdef SK_DEBUG - SkShader* getShaderA() { return fShaderA; } - SkShader* getShaderB() { return fShaderB; } + SkShader* getShaderA() { return fShaderA.get(); } + SkShader* getShaderB() { return fShaderB.get(); } #endif bool asACompose(ComposeRec* rec) const override; @@ -79,9 +79,9 @@ protected: Context* onCreateContext(const ContextRec&, void*) const override; private: - SkShader* fShaderA; - SkShader* fShaderB; - SkXfermode* fMode; + sk_sp<SkShader> fShaderA; + sk_sp<SkShader> fShaderB; + SkXfermode* fMode; typedef SkShader INHERITED; }; diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp index c479221369..409b652e93 100644 --- a/src/core/SkDraw.cpp +++ b/src/core/SkDraw.cpp @@ -81,10 +81,10 @@ public: SkAutoBitmapShaderInstall(const SkBitmap& src, const SkPaint& paint, const SkMatrix* localMatrix = nullptr) : fPaint(paint) /* makes a copy of the paint */ { - fPaint.setShader(SkCreateBitmapShader(src, SkShader::kClamp_TileMode, - SkShader::kClamp_TileMode, - localMatrix, &fAllocator)); + fPaint.setShader(SkMakeBitmapShader(src, SkShader::kClamp_TileMode, + SkShader::kClamp_TileMode, localMatrix, &fAllocator)); // we deliberately left the shader with an owner-count of 2 + fPaint.getShader()->ref(); SkASSERT(2 == fPaint.getShader()->getRefCnt()); } @@ -1880,7 +1880,7 @@ void SkDraw::drawVertices(SkCanvas::VertexMode vmode, int count, Thus for texture drawing, we need both texture[] and a shader. */ - SkTriColorShader triShader; // must be above declaration of p + auto triShader = sk_make_sp<SkTriColorShader>(); SkPaint p(paint); SkShader* shader = p.getShader(); @@ -1894,11 +1894,12 @@ void SkDraw::drawVertices(SkCanvas::VertexMode vmode, int count, } // setup the custom shader (if needed) - SkAutoTUnref<SkComposeShader> composeShader; + sk_sp<SkShader> composeShader; if (colors) { if (nullptr == textures) { // just colors (no texture) - shader = p.setShader(&triShader); + p.setShader(triShader); + shader = p.getShader(); } else { // colors * texture SkASSERT(shader); @@ -1907,7 +1908,7 @@ void SkDraw::drawVertices(SkCanvas::VertexMode vmode, int count, xmode = SkXfermode::Create(SkXfermode::kModulate_Mode); releaseMode = true; } - composeShader.reset(new SkComposeShader(&triShader, shader, xmode)); + composeShader = sk_make_sp<SkComposeShader>(triShader, sk_ref_sp(shader), xmode); p.setShader(composeShader); if (releaseMode) { xmode->unref(); @@ -1940,14 +1941,14 @@ void SkDraw::drawVertices(SkCanvas::VertexMode vmode, int count, } } if (colors) { - triShader.bindSetupData(&verticesSetup); + triShader->bindSetupData(&verticesSetup); } SkPoint tmp[] = { devVerts[state.f0], devVerts[state.f1], devVerts[state.f2] }; SkScan::FillTriangle(tmp, *fRC, blitter.get()); - triShader.bindSetupData(NULL); + triShader->bindSetupData(NULL); } } else { // no colors[] and no texture, stroke hairlines with paint's color. diff --git a/src/core/SkLocalMatrixShader.cpp b/src/core/SkLocalMatrixShader.cpp index 336f1c49cf..42b378d61a 100644 --- a/src/core/SkLocalMatrixShader.cpp +++ b/src/core/SkLocalMatrixShader.cpp @@ -10,7 +10,7 @@ SkFlattenable* SkLocalMatrixShader::CreateProc(SkReadBuffer& buffer) { SkMatrix lm; buffer.readMatrix(&lm); - SkAutoTUnref<SkShader> baseShader(buffer.readShader()); + auto baseShader(buffer.readShader()); if (!baseShader) { return nullptr; } diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp index 3d768074ca..678b1a1102 100644 --- a/src/core/SkPaint.cpp +++ b/src/core/SkPaint.cpp @@ -1929,7 +1929,7 @@ void SkPaint::unflatten(SkReadBuffer& buffer) { if (flatFlags & kHasEffects_FlatFlag) { SkSafeUnref(this->setPathEffect(buffer.readPathEffect())); - SkSafeUnref(this->setShader(buffer.readShader())); + this->setShader(buffer.readShader()); SkSafeUnref(this->setXfermode(buffer.readXfermode())); SkSafeUnref(this->setMaskFilter(buffer.readMaskFilter())); SkSafeUnref(this->setColorFilter(buffer.readColorFilter())); diff --git a/src/core/SkPictureShader.cpp b/src/core/SkPictureShader.cpp index 3919471b1b..a6644aacba 100644 --- a/src/core/SkPictureShader.cpp +++ b/src/core/SkPictureShader.cpp @@ -93,21 +93,21 @@ struct BitmapShaderRec : public SkResourceCache::Rec { } // namespace -SkPictureShader::SkPictureShader(const SkPicture* picture, TileMode tmx, TileMode tmy, +SkPictureShader::SkPictureShader(sk_sp<const SkPicture> picture, TileMode tmx, TileMode tmy, const SkMatrix* localMatrix, const SkRect* tile) : INHERITED(localMatrix) - , fPicture(SkRef(picture)) - , fTile(tile ? *tile : picture->cullRect()) + , fPicture(std::move(picture)) + , fTile(tile ? *tile : fPicture->cullRect()) , fTmx(tmx) , fTmy(tmy) { } -SkShader* SkPictureShader::Create(const SkPicture* picture, TileMode tmx, TileMode tmy, - const SkMatrix* localMatrix, const SkRect* tile) { +sk_sp<SkShader> SkPictureShader::Make(sk_sp<const SkPicture> picture, TileMode tmx, TileMode tmy, + const SkMatrix* localMatrix, const SkRect* tile) { if (!picture || picture->cullRect().isEmpty() || (tile && tile->isEmpty())) { - return SkShader::CreateEmptyShader(); + return SkShader::MakeEmptyShader(); } - return new SkPictureShader(picture, tmx, tmy, localMatrix, tile); + return sk_sp<SkShader>(new SkPictureShader(std::move(picture), tmx, tmy, localMatrix, tile)); } SkFlattenable* SkPictureShader::CreateProc(SkReadBuffer& buffer) { @@ -118,7 +118,7 @@ SkFlattenable* SkPictureShader::CreateProc(SkReadBuffer& buffer) { SkRect tile; buffer.readRect(&tile); - SkAutoTUnref<SkPicture> picture; + sk_sp<SkPicture> picture; if (buffer.isCrossProcess() && SkPicture::PictureIOSecurityPrecautionsEnabled()) { if (buffer.isVersionLT(SkReadBuffer::kPictureShaderHasPictureBool_Version)) { @@ -136,7 +136,7 @@ SkFlattenable* SkPictureShader::CreateProc(SkReadBuffer& buffer) { picture.reset(SkPicture::CreateFromBuffer(buffer)); } } - return SkPictureShader::Create(picture, mx, my, &lm, &tile); + return SkPictureShader::Make(picture, mx, my, &lm, &tile).release(); } void SkPictureShader::flatten(SkWriteBuffer& buffer) const { @@ -155,8 +155,8 @@ void SkPictureShader::flatten(SkWriteBuffer& buffer) const { } } -SkShader* SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, const SkMatrix* localM, - const int maxTextureSize) const { +sk_sp<SkShader> SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, const SkMatrix* localM, + const int maxTextureSize) const { SkASSERT(fPicture && !fPicture->cullRect().isEmpty()); SkMatrix m; @@ -203,14 +203,14 @@ SkShader* SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, const SkM const SkISize tileSize = scaledSize.toCeil(); #endif if (tileSize.isEmpty()) { - return SkShader::CreateEmptyShader(); + return SkShader::MakeEmptyShader(); } // The actual scale, compensating for rounding & clamping. const SkSize tileScale = SkSize::Make(SkIntToScalar(tileSize.width()) / fTile.width(), SkIntToScalar(tileSize.height()) / fTile.height()); - SkAutoTUnref<SkShader> tileShader; + sk_sp<SkShader> tileShader; BitmapShaderKey key(fPicture->uniqueID(), fTile, fTmx, @@ -224,7 +224,7 @@ SkShader* SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, const SkM SkMatrix::kFill_ScaleToFit); SkAutoTUnref<SkImage> tileImage( - SkImage::NewFromPicture(fPicture, tileSize, &tileMatrix, nullptr)); + SkImage::NewFromPicture(fPicture.get(), tileSize, &tileMatrix, nullptr)); if (!tileImage) { return nullptr; } @@ -238,7 +238,7 @@ SkShader* SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, const SkM tileInfo.getSafeSize(tileInfo.minRowBytes()))); } - return tileShader.detach(); + return tileShader; } size_t SkPictureShader::onContextSize(const ContextRec&) const { @@ -246,8 +246,8 @@ size_t SkPictureShader::onContextSize(const ContextRec&) const { } SkShader::Context* SkPictureShader::onCreateContext(const ContextRec& rec, void* storage) const { - SkAutoTUnref<SkShader> bitmapShader(this->refBitmapShader(*rec.fMatrix, rec.fLocalMatrix)); - if (nullptr == bitmapShader.get()) { + sk_sp<SkShader> bitmapShader(this->refBitmapShader(*rec.fMatrix, rec.fLocalMatrix)); + if (!bitmapShader) { return nullptr; } return PictureShaderContext::Create(storage, *this, rec, bitmapShader); @@ -256,8 +256,10 @@ SkShader::Context* SkPictureShader::onCreateContext(const ContextRec& rec, void* ///////////////////////////////////////////////////////////////////////////////////////// SkShader::Context* SkPictureShader::PictureShaderContext::Create(void* storage, - const SkPictureShader& shader, const ContextRec& rec, SkShader* bitmapShader) { - PictureShaderContext* ctx = new (storage) PictureShaderContext(shader, rec, bitmapShader); + const SkPictureShader& shader, const ContextRec& rec, + sk_sp<SkShader> bitmapShader) { + PictureShaderContext* ctx = new (storage) PictureShaderContext(shader, rec, + std::move(bitmapShader)); if (nullptr == ctx->fBitmapShaderContext) { ctx->~PictureShaderContext(); ctx = nullptr; @@ -266,12 +268,12 @@ SkShader::Context* SkPictureShader::PictureShaderContext::Create(void* storage, } SkPictureShader::PictureShaderContext::PictureShaderContext( - const SkPictureShader& shader, const ContextRec& rec, SkShader* bitmapShader) + const SkPictureShader& shader, const ContextRec& rec, sk_sp<SkShader> bitmapShader) : INHERITED(shader, rec) - , fBitmapShader(SkRef(bitmapShader)) + , fBitmapShader(std::move(bitmapShader)) { - fBitmapShaderContextStorage = sk_malloc_throw(bitmapShader->contextSize(rec)); - fBitmapShaderContext = bitmapShader->createContext(rec, fBitmapShaderContextStorage); + fBitmapShaderContextStorage = sk_malloc_throw(fBitmapShader->contextSize(rec)); + fBitmapShaderContext = fBitmapShader->createContext(rec, fBitmapShaderContextStorage); //if fBitmapShaderContext is null, we are invalid } @@ -325,7 +327,7 @@ const GrFragmentProcessor* SkPictureShader::asFragmentProcessor( if (context) { maxTextureSize = context->caps()->maxTextureSize(); } - SkAutoTUnref<SkShader> bitmapShader(this->refBitmapShader(viewM, localMatrix, maxTextureSize)); + sk_sp<SkShader> bitmapShader(this->refBitmapShader(viewM, localMatrix, maxTextureSize)); if (!bitmapShader) { return nullptr; } diff --git a/src/core/SkPictureShader.h b/src/core/SkPictureShader.h index 8cccd251d5..eb9c38b95b 100644 --- a/src/core/SkPictureShader.h +++ b/src/core/SkPictureShader.h @@ -22,8 +22,8 @@ class SkPicture; */ class SkPictureShader : public SkShader { public: - static SkShader* Create(const SkPicture*, TileMode, TileMode, const SkMatrix*, - const SkRect*); + static sk_sp<SkShader> Make(sk_sp<const SkPicture>, TileMode, TileMode, const SkMatrix*, + const SkRect*); SK_TO_STRING_OVERRIDE() SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPictureShader) @@ -42,18 +42,19 @@ protected: Context* onCreateContext(const ContextRec&, void* storage) const override; private: - SkPictureShader(const SkPicture*, TileMode, TileMode, const SkMatrix*, const SkRect*); + SkPictureShader(sk_sp<const SkPicture>, TileMode, TileMode, const SkMatrix*, const SkRect*); - SkShader* refBitmapShader(const SkMatrix&, const SkMatrix* localMatrix, const int maxTextureSize = 0) const; + sk_sp<SkShader> refBitmapShader(const SkMatrix&, const SkMatrix* localMatrix, + const int maxTextureSize = 0) const; - SkAutoTUnref<const SkPicture> fPicture; - SkRect fTile; - TileMode fTmx, fTmy; + sk_sp<const SkPicture> fPicture; + SkRect fTile; + TileMode fTmx, fTmy; class PictureShaderContext : public SkShader::Context { public: static Context* Create(void* storage, const SkPictureShader&, const ContextRec&, - SkShader* bitmapShader); + sk_sp<SkShader> bitmapShader); virtual ~PictureShaderContext(); @@ -63,11 +64,12 @@ private: void shadeSpan(int x, int y, SkPMColor dstC[], int count) override; private: - PictureShaderContext(const SkPictureShader&, const ContextRec&, SkShader* bitmapShader); + PictureShaderContext(const SkPictureShader&, const ContextRec&, + sk_sp<SkShader> bitmapShader); - SkAutoTUnref<SkShader> fBitmapShader; - SkShader::Context* fBitmapShaderContext; - void* fBitmapShaderContextStorage; + sk_sp<SkShader> fBitmapShader; + SkShader::Context* fBitmapShaderContext; + void* fBitmapShaderContextStorage; typedef SkShader::Context INHERITED; }; diff --git a/src/core/SkReadBuffer.h b/src/core/SkReadBuffer.h index b9b30944ff..5db9f4644d 100644 --- a/src/core/SkReadBuffer.h +++ b/src/core/SkReadBuffer.h @@ -136,7 +136,7 @@ public: SkMaskFilter* readMaskFilter() { return this->readFlattenable<SkMaskFilter>(); } SkPathEffect* readPathEffect() { return this->readFlattenable<SkPathEffect>(); } SkRasterizer* readRasterizer() { return this->readFlattenable<SkRasterizer>(); } - SkShader* readShader() { return this->readFlattenable<SkShader>(); } + sk_sp<SkShader> readShader() { return sk_sp<SkShader>(this->readFlattenable<SkShader>()); } SkXfermode* readXfermode() { return this->readFlattenable<SkXfermode>(); } /** diff --git a/src/core/SkShader.cpp b/src/core/SkShader.cpp index 75f527bff3..7b322fb627 100644 --- a/src/core/SkShader.cpp +++ b/src/core/SkShader.cpp @@ -229,18 +229,18 @@ SkShader* SkShader::refAsALocalMatrixShader(SkMatrix*) const { return nullptr; } -SkShader* SkShader::CreateEmptyShader() { return new SkEmptyShader; } +sk_sp<SkShader> SkShader::MakeEmptyShader() { return sk_make_sp<SkEmptyShader>(); } -SkShader* SkShader::CreateColorShader(SkColor color) { return new SkColorShader(color); } +sk_sp<SkShader> SkShader::MakeColorShader(SkColor color) { return sk_make_sp<SkColorShader>(color); } -SkShader* SkShader::CreateBitmapShader(const SkBitmap& src, TileMode tmx, TileMode tmy, - const SkMatrix* localMatrix) { - return SkCreateBitmapShader(src, tmx, tmy, localMatrix, nullptr); +sk_sp<SkShader> SkShader::MakeBitmapShader(const SkBitmap& src, TileMode tmx, TileMode tmy, + const SkMatrix* localMatrix) { + return SkMakeBitmapShader(src, tmx, tmy, localMatrix, nullptr); } -SkShader* SkShader::CreatePictureShader(const SkPicture* src, TileMode tmx, TileMode tmy, - const SkMatrix* localMatrix, const SkRect* tile) { - return SkPictureShader::Create(src, tmx, tmy, localMatrix, tile); +sk_sp<SkShader> SkShader::MakePictureShader(sk_sp<const SkPicture> src, TileMode tmx, TileMode tmy, + const SkMatrix* localMatrix, const SkRect* tile) { + return SkPictureShader::Make(std::move(src), tmx, tmy, localMatrix, tile); } #ifndef SK_IGNORE_TO_STRING @@ -362,7 +362,7 @@ void SkColorShader::toString(SkString* str) const { /////////////////////////////////////////////////////////////////////////////// SkFlattenable* SkEmptyShader::CreateProc(SkReadBuffer&) { - return SkShader::CreateEmptyShader(); + return SkShader::MakeEmptyShader().release(); } #ifndef SK_IGNORE_TO_STRING @@ -376,3 +376,18 @@ void SkEmptyShader::toString(SkString* str) const { str->append(")"); } #endif + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef SK_SUPPORT_LEGACY_CREATESHADER_PTR +SkShader* SkShader::CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode::Mode mode) { + return MakeComposeShader(sk_ref_sp(dst), sk_ref_sp(src), mode).release(); +} +SkShader* SkShader::CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode* xfer) { + return MakeComposeShader(sk_ref_sp(dst), sk_ref_sp(src), xfer).release(); +} +SkShader* SkShader::CreatePictureShader(const SkPicture* src, TileMode tmx, TileMode tmy, + const SkMatrix* localMatrix, const SkRect* tile) { + return MakePictureShader(sk_ref_sp(src), tmx, tmy, localMatrix, tile).release(); +} +#endif diff --git a/src/effects/SkTileImageFilter.cpp b/src/effects/SkTileImageFilter.cpp index 66cad47ad0..dff8e9bbfc 100644 --- a/src/effects/SkTileImageFilter.cpp +++ b/src/effects/SkTileImageFilter.cpp @@ -96,10 +96,8 @@ bool SkTileImageFilter::onFilterImageDeprecated(Proxy* proxy, const SkBitmap& sr SkCanvas canvas(device); SkPaint paint; paint.setXfermodeMode(SkXfermode::kSrc_Mode); - - SkAutoTUnref<SkShader> shader(SkShader::CreateBitmapShader(subset, - SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode)); - paint.setShader(shader); + paint.setShader(SkShader::MakeBitmapShader(subset, SkShader::kRepeat_TileMode, + SkShader::kRepeat_TileMode)); canvas.translate(-dstRect.fLeft, -dstRect.fTop); canvas.drawRect(dstRect, paint); *dst = device->accessBitmap(false); diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp index 985d45966b..9fe6c91a01 100644 --- a/src/effects/gradients/SkGradientShader.cpp +++ b/src/effects/gradients/SkGradientShader.cpp @@ -786,7 +786,7 @@ static void desc_init(SkGradientShaderBase::Descriptor* desc, desc->fLocalMatrix = localMatrix; } -SkShader* SkGradientShader::CreateLinear(const SkPoint pts[2], +sk_sp<SkShader> SkGradientShader::MakeLinear(const SkPoint pts[2], const SkColor colors[], const SkScalar pos[], int colorCount, SkShader::TileMode mode, @@ -802,10 +802,10 @@ SkShader* SkGradientShader::CreateLinear(const SkPoint pts[2], SkGradientShaderBase::Descriptor desc; desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix); - return new SkLinearGradient(pts, desc); + return sk_make_sp<SkLinearGradient>(pts, desc); } -SkShader* SkGradientShader::CreateRadial(const SkPoint& center, SkScalar radius, +sk_sp<SkShader> SkGradientShader::MakeRadial(const SkPoint& center, SkScalar radius, const SkColor colors[], const SkScalar pos[], int colorCount, SkShader::TileMode mode, @@ -821,10 +821,10 @@ SkShader* SkGradientShader::CreateRadial(const SkPoint& center, SkScalar radius, SkGradientShaderBase::Descriptor desc; desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix); - return new SkRadialGradient(center, radius, desc); + return sk_make_sp<SkRadialGradient>(center, radius, desc); } -SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start, +sk_sp<SkShader> SkGradientShader::MakeTwoPointConical(const SkPoint& start, SkScalar startRadius, const SkPoint& end, SkScalar endRadius, @@ -842,7 +842,7 @@ SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start, } if (startRadius == endRadius) { if (start == end || startRadius == 0) { - return SkShader::CreateEmptyShader(); + return SkShader::MakeEmptyShader(); } } @@ -854,8 +854,8 @@ SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start, if (!flipGradient) { desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix); - return new SkTwoPointConicalGradient(start, startRadius, end, endRadius, flipGradient, - desc); + return sk_make_sp<SkTwoPointConicalGradient>(start, startRadius, end, endRadius, + flipGradient, desc); } else { SkAutoSTArray<8, SkColor> colorsNew(colorCount); SkAutoSTArray<8, SkScalar> posNew(colorCount); @@ -872,12 +872,12 @@ SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start, desc_init(&desc, colorsNew.get(), nullptr, colorCount, mode, flags, localMatrix); } - return new SkTwoPointConicalGradient(end, endRadius, start, startRadius, flipGradient, - desc); + return sk_make_sp<SkTwoPointConicalGradient>(end, endRadius, start, startRadius, + flipGradient, desc); } } -SkShader* SkGradientShader::CreateSweep(SkScalar cx, SkScalar cy, +sk_sp<SkShader> SkGradientShader::MakeSweep(SkScalar cx, SkScalar cy, const SkColor colors[], const SkScalar pos[], int colorCount, @@ -890,7 +890,7 @@ SkShader* SkGradientShader::CreateSweep(SkScalar cx, SkScalar cy, SkGradientShaderBase::Descriptor desc; desc_init(&desc, colors, pos, colorCount, SkShader::kClamp_TileMode, flags, localMatrix); - return new SkSweepGradient(cx, cy, desc); + return sk_make_sp<SkSweepGradient>(cx, cy, desc); } SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkGradientShader) diff --git a/src/effects/gradients/SkLinearGradient.cpp b/src/effects/gradients/SkLinearGradient.cpp index 15d461960d..8ad120991d 100644 --- a/src/effects/gradients/SkLinearGradient.cpp +++ b/src/effects/gradients/SkLinearGradient.cpp @@ -78,8 +78,8 @@ SkFlattenable* SkLinearGradient::CreateProc(SkReadBuffer& buffer) { SkPoint pts[2]; pts[0] = buffer.readPoint(); pts[1] = buffer.readPoint(); - return SkGradientShader::CreateLinear(pts, desc.fColors, desc.fPos, desc.fCount, - desc.fTileMode, desc.fGradFlags, desc.fLocalMatrix); + return SkGradientShader::MakeLinear(pts, desc.fColors, desc.fPos, desc.fCount, desc.fTileMode, + desc.fGradFlags, desc.fLocalMatrix).release(); } void SkLinearGradient::flatten(SkWriteBuffer& buffer) const { @@ -430,9 +430,7 @@ const GrFragmentProcessor* GrLinearGradient::TestCreate(GrProcessorTestData* d) SkScalar* stops = stopsArray; SkShader::TileMode tm; int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm); - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateLinear(points, - colors, stops, colorCount, - tm)); + auto shader = SkGradientShader::MakeLinear(points, colors, stops, colorCount, tm); const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext, GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality); GrAlwaysAssert(fp); diff --git a/src/effects/gradients/SkRadialGradient.cpp b/src/effects/gradients/SkRadialGradient.cpp index d175f238cd..1560cd2f39 100644 --- a/src/effects/gradients/SkRadialGradient.cpp +++ b/src/effects/gradients/SkRadialGradient.cpp @@ -68,8 +68,9 @@ SkFlattenable* SkRadialGradient::CreateProc(SkReadBuffer& buffer) { } const SkPoint center = buffer.readPoint(); const SkScalar radius = buffer.readScalar(); - return SkGradientShader::CreateRadial(center, radius, desc.fColors, desc.fPos, desc.fCount, - desc.fTileMode, desc.fGradFlags, desc.fLocalMatrix); + return SkGradientShader::MakeRadial(center, radius, desc.fColors, desc.fPos, desc.fCount, + desc.fTileMode, desc.fGradFlags, + desc.fLocalMatrix).release(); } void SkRadialGradient::flatten(SkWriteBuffer& buffer) const { @@ -313,9 +314,7 @@ const GrFragmentProcessor* GrRadialGradient::TestCreate(GrProcessorTestData* d) SkScalar* stops = stopsArray; SkShader::TileMode tm; int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm); - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateRadial(center, radius, - colors, stops, colorCount, - tm)); + auto shader = SkGradientShader::MakeRadial(center, radius, colors, stops, colorCount, tm); const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext, GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality); GrAlwaysAssert(fp); diff --git a/src/effects/gradients/SkSweepGradient.cpp b/src/effects/gradients/SkSweepGradient.cpp index 1bdf40e115..3021e4bc08 100644 --- a/src/effects/gradients/SkSweepGradient.cpp +++ b/src/effects/gradients/SkSweepGradient.cpp @@ -36,8 +36,8 @@ SkFlattenable* SkSweepGradient::CreateProc(SkReadBuffer& buffer) { return nullptr; } const SkPoint center = buffer.readPoint(); - return SkGradientShader::CreateSweep(center.x(), center.y(), desc.fColors, desc.fPos, - desc.fCount, desc.fGradFlags, desc.fLocalMatrix); + return SkGradientShader::MakeSweep(center.x(), center.y(), desc.fColors, desc.fPos, + desc.fCount, desc.fGradFlags, desc.fLocalMatrix).release(); } void SkSweepGradient::flatten(SkWriteBuffer& buffer) const { @@ -190,8 +190,8 @@ const GrFragmentProcessor* GrSweepGradient::TestCreate(GrProcessorTestData* d) { SkScalar* stops = stopsArray; SkShader::TileMode tmIgnored; int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tmIgnored); - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateSweep(center.fX, center.fY, - colors, stops, colorCount)); + sk_sp<SkShader> shader(SkGradientShader::MakeSweep(center.fX, center.fY, colors, stops, + colorCount)); const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext, GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality); diff --git a/src/effects/gradients/SkTwoPointConicalGradient.cpp b/src/effects/gradients/SkTwoPointConicalGradient.cpp index 43d6f1f7c9..d9fc39c3bc 100644 --- a/src/effects/gradients/SkTwoPointConicalGradient.cpp +++ b/src/effects/gradients/SkTwoPointConicalGradient.cpp @@ -338,9 +338,9 @@ SkFlattenable* SkTwoPointConicalGradient::CreateProc(SkReadBuffer& buffer) { } } - return SkGradientShader::CreateTwoPointConical(c1, r1, c2, r2, desc.fColors, desc.fPos, - desc.fCount, desc.fTileMode, desc.fGradFlags, - desc.fLocalMatrix); + return SkGradientShader::MakeTwoPointConical(c1, r1, c2, r2, desc.fColors, desc.fPos, + desc.fCount, desc.fTileMode, desc.fGradFlags, + desc.fLocalMatrix).release(); } void SkTwoPointConicalGradient::flatten(SkWriteBuffer& buffer) const { diff --git a/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp b/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp index 5b0855ab7c..539436928c 100644 --- a/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp +++ b/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp @@ -207,10 +207,8 @@ const GrFragmentProcessor* Edge2PtConicalEffect::TestCreate(GrProcessorTestData* SkScalar* stops = stopsArray; SkShader::TileMode tm; int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm); - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1, - center2, radius2, - colors, stops, colorCount, - tm)); + auto shader = SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2, + colors, stops, colorCount, tm); const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext, GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality); GrAlwaysAssert(fp); @@ -484,10 +482,8 @@ const GrFragmentProcessor* FocalOutside2PtConicalEffect::TestCreate(GrProcessorT SkScalar* stops = stopsArray; SkShader::TileMode tm; int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm); - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1, - center2, radius2, - colors, stops, colorCount, - tm)); + auto shader = SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2, + colors, stops, colorCount, tm); const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext, GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality); GrAlwaysAssert(fp); @@ -692,10 +688,8 @@ const GrFragmentProcessor* FocalInside2PtConicalEffect::TestCreate(GrProcessorTe SkScalar* stops = stopsArray; SkShader::TileMode tm; int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm); - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1, - center2, radius2, - colors, stops, colorCount, - tm)); + auto shader = SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2, + colors, stops, colorCount, tm); const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext, GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality); GrAlwaysAssert(fp); @@ -940,10 +934,8 @@ const GrFragmentProcessor* CircleInside2PtConicalEffect::TestCreate(GrProcessorT SkScalar* stops = stopsArray; SkShader::TileMode tm; int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm); - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1, - center2, radius2, - colors, stops, colorCount, - tm)); + auto shader = SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2, + colors, stops, colorCount, tm); const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext, GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality); GrAlwaysAssert(fp); @@ -1173,10 +1165,8 @@ const GrFragmentProcessor* CircleOutside2PtConicalEffect::TestCreate(GrProcessor SkScalar* stops = stopsArray; SkShader::TileMode tm; int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm); - SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1, - center2, radius2, - colors, stops, colorCount, - tm)); + auto shader = SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2, + colors, stops, colorCount, tm); const GrFragmentProcessor* fp = shader->asFragmentProcessor( d->fContext,GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality); GrAlwaysAssert(fp); diff --git a/src/utils/SkMeshUtils.cpp b/src/utils/SkMeshUtils.cpp index cf4e5099b3..5d3eefc54f 100644 --- a/src/utils/SkMeshUtils.cpp +++ b/src/utils/SkMeshUtils.cpp @@ -92,9 +92,9 @@ void SkMeshUtils::Draw(SkCanvas* canvas, const SkBitmap& bitmap, if (idx.init(bitmap.width(), bitmap.height(), rows, cols)) { SkPaint p(paint); - p.setShader(SkShader::CreateBitmapShader(bitmap, + p.setShader(SkShader::MakeBitmapShader(bitmap, SkShader::kClamp_TileMode, - SkShader::kClamp_TileMode))->unref(); + SkShader::kClamp_TileMode)); canvas->drawVertices(SkCanvas::kTriangles_VertexMode, rows * cols, verts, idx.tex(), colors, nullptr, idx.indices(), idx.indexCount(), p); diff --git a/src/utils/SkNinePatch.cpp b/src/utils/SkNinePatch.cpp index 5ee488e44b..aeb65b1e28 100644 --- a/src/utils/SkNinePatch.cpp +++ b/src/utils/SkNinePatch.cpp @@ -236,14 +236,13 @@ void SkNinePatch::DrawMesh(SkCanvas* canvas, const SkRect& bounds, fillRow(verts, texs, bounds.fBottom, SkIntToScalar(bitmap.height()), bounds, xDivs, numXDivs, stretchX, bitmap.width()); - SkShader* shader = SkShader::CreateBitmapShader(bitmap, - SkShader::kClamp_TileMode, - SkShader::kClamp_TileMode); SkPaint p; if (paint) { p = *paint; } - p.setShader(shader)->unref(); + p.setShader(SkShader::MakeBitmapShader(bitmap, + SkShader::kClamp_TileMode, + SkShader::kClamp_TileMode)); canvas->drawVertices(SkCanvas::kTriangles_VertexMode, vCount, mesh.fVerts, mesh.fTexs, mesh.fColors, nullptr, mesh.fIndices, indexCount, p); |