aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/core
diff options
context:
space:
mode:
Diffstat (limited to 'src/core')
-rw-r--r--src/core/SkBlitter.cpp5
-rw-r--r--src/core/SkCanvas.cpp14
-rw-r--r--src/core/SkColorFilter.cpp34
-rw-r--r--src/core/SkColorFilterShader.cpp24
-rw-r--r--src/core/SkColorFilterShader.h6
-rw-r--r--src/core/SkColorMatrixFilterRowMajor255.cpp14
-rw-r--r--src/core/SkColorMatrixFilterRowMajor255.h7
-rw-r--r--src/core/SkDevice.cpp3
-rw-r--r--src/core/SkModeColorFilter.cpp10
-rw-r--r--src/core/SkModeColorFilter.h7
-rw-r--r--src/core/SkPaint.cpp4
-rw-r--r--src/core/SkReadBuffer.h4
-rw-r--r--src/core/SkShader.cpp3
13 files changed, 75 insertions, 60 deletions
diff --git a/src/core/SkBlitter.cpp b/src/core/SkBlitter.cpp
index 04897e3828..15562168e9 100644
--- a/src/core/SkBlitter.cpp
+++ b/src/core/SkBlitter.cpp
@@ -844,7 +844,8 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
if (SkXfermode::IsMode(mode, SkXfermode::kClear_Mode)) {
SkPaint* p = paint.writable();
shader = p->setShader(nullptr);
- cf = p->setColorFilter(nullptr);
+ p->setColorFilter(nullptr);
+ cf = nullptr;
mode = p->setXfermodeMode(SkXfermode::kSrc_Mode);
p->setColor(0);
}
@@ -867,7 +868,7 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
if (cf) {
SkASSERT(shader);
- paint.writable()->setShader(shader->makeWithColorFilter(cf));
+ paint.writable()->setShader(shader->makeWithColorFilter(sk_ref_sp(cf)));
shader = paint->getShader();
// blitters should ignore the presence/absence of a filter, since
// if there is one, the shader will take care of it.
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 3efb44cc54..f7f870210d 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -391,16 +391,17 @@ static SkPaint* set_if_needed(SkLazyPaint* lazy, const SkPaint& orig) {
* If the paint has an imagefilter, but it can be simplified to just a colorfilter, return that
* colorfilter, else return nullptr.
*/
-static SkColorFilter* image_to_color_filter(const SkPaint& paint) {
+static sk_sp<SkColorFilter> image_to_color_filter(const SkPaint& paint) {
SkImageFilter* imgf = paint.getImageFilter();
if (!imgf) {
return nullptr;
}
- SkColorFilter* imgCF;
- if (!imgf->asAColorFilter(&imgCF)) {
+ SkColorFilter* imgCFPtr;
+ if (!imgf->asAColorFilter(&imgCFPtr)) {
return nullptr;
}
+ sk_sp<SkColorFilter> imgCF(imgCFPtr);
SkColorFilter* paintCF = paint.getColorFilter();
if (nullptr == paintCF) {
@@ -410,8 +411,7 @@ static SkColorFilter* image_to_color_filter(const SkPaint& paint) {
// The paint has both a colorfilter(paintCF) and an imagefilter-which-is-a-colorfilter(imgCF)
// and we need to combine them into a single colorfilter.
- SkAutoTUnref<SkColorFilter> autoImgCF(imgCF);
- return SkColorFilter::CreateComposeFilter(imgCF, paintCF);
+ return SkColorFilter::MakeComposeFilter(std::move(imgCF), sk_ref_sp(paintCF));
}
/**
@@ -455,10 +455,10 @@ public:
fTempLayerForImageFilter = false;
fDone = false;
- SkColorFilter* simplifiedCF = image_to_color_filter(fOrigPaint);
+ auto simplifiedCF = image_to_color_filter(fOrigPaint);
if (simplifiedCF) {
SkPaint* paint = set_if_needed(&fLazyPaintInit, fOrigPaint);
- paint->setColorFilter(simplifiedCF)->unref();
+ paint->setColorFilter(std::move(simplifiedCF));
paint->setImageFilter(nullptr);
fPaint = paint;
}
diff --git a/src/core/SkColorFilter.cpp b/src/core/SkColorFilter.cpp
index dab4ccf7b5..59a625d0b6 100644
--- a/src/core/SkColorFilter.cpp
+++ b/src/core/SkColorFilter.cpp
@@ -114,14 +114,15 @@ public:
protected:
void flatten(SkWriteBuffer& buffer) const override {
- buffer.writeFlattenable(fOuter);
- buffer.writeFlattenable(fInner);
+ buffer.writeFlattenable(fOuter.get());
+ buffer.writeFlattenable(fInner.get());
}
private:
- SkComposeColorFilter(SkColorFilter* outer, SkColorFilter* inner, int composedFilterCount)
- : fOuter(SkRef(outer))
- , fInner(SkRef(inner))
+ SkComposeColorFilter(sk_sp<SkColorFilter> outer, sk_sp<SkColorFilter> inner,
+ int composedFilterCount)
+ : fOuter(std::move(outer))
+ , fInner(std::move(inner))
, fComposedFilterCount(composedFilterCount)
{
SkASSERT(composedFilterCount >= 2);
@@ -132,9 +133,9 @@ private:
return fComposedFilterCount;
}
- SkAutoTUnref<SkColorFilter> fOuter;
- SkAutoTUnref<SkColorFilter> fInner;
- const int fComposedFilterCount;
+ sk_sp<SkColorFilter> fOuter;
+ sk_sp<SkColorFilter> fInner;
+ const int fComposedFilterCount;
friend class SkColorFilter;
@@ -142,23 +143,24 @@ private:
};
SkFlattenable* SkComposeColorFilter::CreateProc(SkReadBuffer& buffer) {
- SkAutoTUnref<SkColorFilter> outer(buffer.readColorFilter());
- SkAutoTUnref<SkColorFilter> inner(buffer.readColorFilter());
- return CreateComposeFilter(outer, inner);
+ sk_sp<SkColorFilter> outer(buffer.readColorFilter());
+ sk_sp<SkColorFilter> inner(buffer.readColorFilter());
+ return MakeComposeFilter(std::move(outer), std::move(inner)).release();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
-SkColorFilter* SkColorFilter::CreateComposeFilter(SkColorFilter* outer, SkColorFilter* inner) {
+sk_sp<SkColorFilter> SkColorFilter::MakeComposeFilter(sk_sp<SkColorFilter> outer,
+ sk_sp<SkColorFilter> inner) {
if (!outer) {
- return SkSafeRef(inner);
+ return inner;
}
if (!inner) {
- return SkSafeRef(outer);
+ return outer;
}
// Give the subclass a shot at a more optimal composition...
- SkColorFilter* composition = outer->newComposed(inner);
+ auto composition = outer->makeComposed(inner);
if (composition) {
return composition;
}
@@ -167,7 +169,7 @@ SkColorFilter* SkColorFilter::CreateComposeFilter(SkColorFilter* outer, SkColorF
if (count > SK_MAX_COMPOSE_COLORFILTER_COUNT) {
return nullptr;
}
- return new SkComposeColorFilter(outer, inner, count);
+ return sk_sp<SkColorFilter>(new SkComposeColorFilter(std::move(outer), std::move(inner),count));
}
#include "SkModeColorFilter.h"
diff --git a/src/core/SkColorFilterShader.cpp b/src/core/SkColorFilterShader.cpp
index 2e426a17ed..8a175024de 100644
--- a/src/core/SkColorFilterShader.cpp
+++ b/src/core/SkColorFilterShader.cpp
@@ -15,26 +15,26 @@
#include "GrFragmentProcessor.h"
#endif
-SkColorFilterShader::SkColorFilterShader(SkShader* shader, SkColorFilter* filter)
- : fShader(SkRef(shader))
- , fFilter(SkRef(filter))
+SkColorFilterShader::SkColorFilterShader(sk_sp<SkShader> shader, sk_sp<SkColorFilter> filter)
+ : fShader(std::move(shader))
+ , fFilter(std::move(filter))
{
- SkASSERT(shader);
- SkASSERT(filter);
+ SkASSERT(fShader);
+ SkASSERT(fFilter);
}
SkFlattenable* SkColorFilterShader::CreateProc(SkReadBuffer& buffer) {
auto shader = buffer.readShader();
- SkAutoTUnref<SkColorFilter> filter(buffer.readColorFilter());
- if (!shader || !filter.get()) {
+ auto filter = buffer.readColorFilter();
+ if (!shader || !filter) {
return nullptr;
}
- return new SkColorFilterShader(shader.get(), filter);
+ return new SkColorFilterShader(shader, filter);
}
void SkColorFilterShader::flatten(SkWriteBuffer& buffer) const {
- buffer.writeFlattenable(fShader);
- buffer.writeFlattenable(fFilter);
+ buffer.writeFlattenable(fShader.get());
+ buffer.writeFlattenable(fFilter.get());
}
uint32_t SkColorFilterShader::FilterShaderContext::getFlags() const {
@@ -137,10 +137,10 @@ void SkColorFilterShader::toString(SkString* str) const {
///////////////////////////////////////////////////////////////////////////////////////////////////
-sk_sp<SkShader> SkShader::makeWithColorFilter(SkColorFilter* filter) const {
+sk_sp<SkShader> SkShader::makeWithColorFilter(sk_sp<SkColorFilter> filter) const {
SkShader* base = const_cast<SkShader*>(this);
if (!filter) {
return sk_ref_sp(base);
}
- return sk_make_sp<SkColorFilterShader>(base, filter);
+ return sk_make_sp<SkColorFilterShader>(sk_ref_sp(base), filter);
}
diff --git a/src/core/SkColorFilterShader.h b/src/core/SkColorFilterShader.h
index 0f41a43c49..167a272fa4 100644
--- a/src/core/SkColorFilterShader.h
+++ b/src/core/SkColorFilterShader.h
@@ -13,7 +13,7 @@
class SkColorFilterShader : public SkShader {
public:
- SkColorFilterShader(SkShader* shader, SkColorFilter* filter);
+ SkColorFilterShader(sk_sp<SkShader> shader, sk_sp<SkColorFilter> filter);
#if SK_SUPPORT_GPU
const GrFragmentProcessor* asFragmentProcessor(GrContext*,
@@ -53,8 +53,8 @@ protected:
Context* onCreateContext(const ContextRec&, void* storage) const override;
private:
- SkAutoTUnref<SkShader> fShader;
- SkAutoTUnref<SkColorFilter> fFilter;
+ sk_sp<SkShader> fShader;
+ sk_sp<SkColorFilter> fFilter;
typedef SkShader INHERITED;
};
diff --git a/src/core/SkColorMatrixFilterRowMajor255.cpp b/src/core/SkColorMatrixFilterRowMajor255.cpp
index 09df61699d..bd9a66a561 100644
--- a/src/core/SkColorMatrixFilterRowMajor255.cpp
+++ b/src/core/SkColorMatrixFilterRowMajor255.cpp
@@ -226,12 +226,13 @@ static void set_concat(SkScalar result[20], const SkScalar outer[20], const SkSc
// End duplication
//////
-SkColorFilter* SkColorMatrixFilterRowMajor255::newComposed(const SkColorFilter* innerFilter) const {
+sk_sp<SkColorFilter>
+SkColorMatrixFilterRowMajor255::makeComposed(sk_sp<SkColorFilter> innerFilter) const {
SkScalar innerMatrix[20];
if (innerFilter->asColorMatrix(innerMatrix) && !needs_clamping(innerMatrix)) {
SkScalar concat[20];
set_concat(concat, fMatrix, innerMatrix);
- return new SkColorMatrixFilterRowMajor255(concat);
+ return sk_make_sp<SkColorMatrixFilterRowMajor255>(concat);
}
return nullptr;
}
@@ -417,15 +418,16 @@ void SkColorMatrixFilterRowMajor255::toString(SkString* str) const {
///////////////////////////////////////////////////////////////////////////////
-SkColorFilter* SkColorFilter::CreateMatrixFilterRowMajor255(const SkScalar array[20]) {
- return new SkColorMatrixFilterRowMajor255(array);
+sk_sp<SkColorFilter> SkColorFilter::MakeMatrixFilterRowMajor255(const SkScalar array[20]) {
+ return sk_sp<SkColorFilter>(new SkColorMatrixFilterRowMajor255(array));
}
///////////////////////////////////////////////////////////////////////////////
-SkColorFilter* SkColorMatrixFilterRowMajor255::CreateSingleChannelOutput(const SkScalar row[5]) {
+sk_sp<SkColorFilter>
+SkColorMatrixFilterRowMajor255::MakeSingleChannelOutput(const SkScalar row[5]) {
SkASSERT(row);
- SkColorMatrixFilterRowMajor255* cf = new SkColorMatrixFilterRowMajor255();
+ auto cf = sk_make_sp<SkColorMatrixFilterRowMajor255>();
static_assert(sizeof(SkScalar) * 5 * 4 == sizeof(cf->fMatrix), "sizes don't match");
for (int i = 0; i < 4; ++i) {
memcpy(cf->fMatrix + 5 * i, row, sizeof(SkScalar) * 5);
diff --git a/src/core/SkColorMatrixFilterRowMajor255.h b/src/core/SkColorMatrixFilterRowMajor255.h
index 106d2bd882..0ad64fa2f0 100644
--- a/src/core/SkColorMatrixFilterRowMajor255.h
+++ b/src/core/SkColorMatrixFilterRowMajor255.h
@@ -12,16 +12,17 @@
class SK_API SkColorMatrixFilterRowMajor255 : public SkColorFilter {
public:
+ SkColorMatrixFilterRowMajor255() {};
explicit SkColorMatrixFilterRowMajor255(const SkScalar array[20]);
/** Creates a color matrix filter that returns the same value in all four channels. */
- static SkColorFilter* CreateSingleChannelOutput(const SkScalar row[5]);
+ static sk_sp<SkColorFilter> MakeSingleChannelOutput(const SkScalar row[5]);
void filterSpan(const SkPMColor src[], int count, SkPMColor[]) const override;
void filterSpan4f(const SkPM4f src[], int count, SkPM4f[]) const override;
uint32_t getFlags() const override;
bool asColorMatrix(SkScalar matrix[20]) const override;
- SkColorFilter* newComposed(const SkColorFilter*) const override;
+ sk_sp<SkColorFilter> makeComposed(sk_sp<SkColorFilter>) const override;
#if SK_SUPPORT_GPU
const GrFragmentProcessor* asFragmentProcessor(GrContext*) const override;
@@ -35,8 +36,6 @@ protected:
void flatten(SkWriteBuffer&) const override;
private:
- SkColorMatrixFilterRowMajor255() {};
-
SkScalar fMatrix[20];
float fTranspose[20]; // for Sk4s
uint32_t fFlags;
diff --git a/src/core/SkDevice.cpp b/src/core/SkDevice.cpp
index 90be52b403..fb4b48fdbd 100644
--- a/src/core/SkDevice.cpp
+++ b/src/core/SkDevice.cpp
@@ -207,8 +207,7 @@ void SkBaseDevice::drawAtlas(const SkDraw& draw, const SkImage* atlas, const SkR
pnt.setShader(std::move(shader));
if (colors) {
- SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(colors[i], mode));
- pnt.setColorFilter(cf);
+ pnt.setColorFilter(SkColorFilter::MakeModeFilter(colors[i], mode));
}
path.rewind();
diff --git a/src/core/SkModeColorFilter.cpp b/src/core/SkModeColorFilter.cpp
index 1e104d8dc7..3da51609a3 100644
--- a/src/core/SkModeColorFilter.cpp
+++ b/src/core/SkModeColorFilter.cpp
@@ -80,7 +80,7 @@ void SkModeColorFilter::updateCache() {
SkFlattenable* SkModeColorFilter::CreateProc(SkReadBuffer& buffer) {
SkColor color = buffer.readColor();
SkXfermode::Mode mode = (SkXfermode::Mode)buffer.readUInt();
- return SkColorFilter::CreateModeFilter(color, mode);
+ return SkColorFilter::MakeModeFilter(color, mode).release();
}
///////////////////////////////////////////////////////////////////////////////
@@ -148,7 +148,7 @@ private:
///////////////////////////////////////////////////////////////////////////////
-SkColorFilter* SkColorFilter::CreateModeFilter(SkColor color, SkXfermode::Mode mode) {
+sk_sp<SkColorFilter> SkColorFilter::MakeModeFilter(SkColor color, SkXfermode::Mode mode) {
if (!SkIsValidMode(mode)) {
return nullptr;
}
@@ -183,10 +183,10 @@ SkColorFilter* SkColorFilter::CreateModeFilter(SkColor color, SkXfermode::Mode m
switch (mode) {
case SkXfermode::kSrc_Mode:
- return new Src_SkModeColorFilter(color);
+ return sk_make_sp<Src_SkModeColorFilter>(color);
case SkXfermode::kSrcOver_Mode:
- return new SrcOver_SkModeColorFilter(color);
+ return sk_make_sp<SrcOver_SkModeColorFilter>(color);
default:
- return SkModeColorFilter::Create(color, mode);
+ return SkModeColorFilter::Make(color, mode);
}
}
diff --git a/src/core/SkModeColorFilter.h b/src/core/SkModeColorFilter.h
index 44e618a3ad..d73cab7932 100644
--- a/src/core/SkModeColorFilter.h
+++ b/src/core/SkModeColorFilter.h
@@ -13,9 +13,14 @@
class SkModeColorFilter : public SkColorFilter {
public:
+ static sk_sp<SkColorFilter> Make(SkColor color, SkXfermode::Mode mode) {
+ return sk_sp<SkColorFilter>(new SkModeColorFilter(color, mode));
+ }
+#ifdef SK_SUPPORT_LEGACY_COLORFILTER_PTR
static SkColorFilter* Create(SkColor color, SkXfermode::Mode mode) {
- return new SkModeColorFilter(color, mode);
+ return Make(color, mode).release();
}
+#endif
SkColor getColor() const { return fColor; }
SkXfermode::Mode getMode() const { return fMode; }
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index 19bdcaf0aa..6fe9d7599d 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -375,7 +375,9 @@ SET_PTR(Rasterizer)
#endif
SET_PTR(ImageFilter)
SET_PTR(Shader)
+#ifdef SK_SUPPORT_LEGACY_COLORFILTER_PTR
SET_PTR(ColorFilter)
+#endif
SET_PTR(Xfermode)
#ifdef SK_SUPPORT_LEGACY_PATHEFFECT_PTR
SET_PTR(PathEffect)
@@ -1940,7 +1942,7 @@ void SkPaint::unflatten(SkReadBuffer& buffer) {
this->setShader(buffer.readShader());
SkSafeUnref(this->setXfermode(buffer.readXfermode()));
SkSafeUnref(this->setMaskFilter(buffer.readMaskFilter()));
- SkSafeUnref(this->setColorFilter(buffer.readColorFilter()));
+ this->setColorFilter(buffer.readColorFilter());
this->setRasterizer(buffer.readRasterizer());
this->setLooper(buffer.readDrawLooper());
SkSafeUnref(this->setImageFilter(buffer.readImageFilter()));
diff --git a/src/core/SkReadBuffer.h b/src/core/SkReadBuffer.h
index 575375eded..46f6b818da 100644
--- a/src/core/SkReadBuffer.h
+++ b/src/core/SkReadBuffer.h
@@ -130,7 +130,9 @@ public:
template <typename T> T* readFlattenable() {
return (T*) this->readFlattenable(T::GetFlattenableType());
}
- SkColorFilter* readColorFilter() { return this->readFlattenable<SkColorFilter>(); }
+ sk_sp<SkColorFilter> readColorFilter() {
+ return sk_sp<SkColorFilter>(this->readFlattenable<SkColorFilter>());
+ }
sk_sp<SkDrawLooper> readDrawLooper() {
return sk_sp<SkDrawLooper>(this->readFlattenable<SkDrawLooper>());
}
diff --git a/src/core/SkShader.cpp b/src/core/SkShader.cpp
index 52d0064eb1..75fa6fc60c 100644
--- a/src/core/SkShader.cpp
+++ b/src/core/SkShader.cpp
@@ -449,4 +449,7 @@ SkShader* SkShader::CreatePictureShader(const SkPicture* src, TileMode tmx, Tile
return MakePictureShader(sk_ref_sp(const_cast<SkPicture*>(src)), tmx, tmy,
localMatrix, tile).release();
}
+SkShader* SkShader::newWithColorFilter(SkColorFilter* filter) const {
+ return this->makeWithColorFilter(sk_ref_sp(filter)).release();
+}
#endif
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-27 08:42:20 +0000