Revert of Switch SkLocalMatrixImageFilter and SkPaintImageFilter over to sk_sp (patchset #6 id:100001 of https://codereview.chromium.org/1842793002/ )
Reason for revert:
This CL is causing the autoroll into Chromium & google3 to fail.
Original issue's description:
> Switch SkLocalMatrixImageFilter and SkPaintImageFilter over to sk_sp
>
> TBR=reed@google.com
>
> GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1842793002
>
> Committed: https://skia.googlesource.com/skia/+/a33cf07a2273315363c0b6fb5d3ce811742f5a85
TBR=fmalita@chromium.org,reed@google.com,robertphillips@google.com
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
Review URL: https://codereview.chromium.org/1837293003
diff --git a/gm/imagefiltersclipped.cpp b/gm/imagefiltersclipped.cpp
index 5401ef5..7c75bf3 100644
--- a/gm/imagefiltersclipped.cpp
+++ b/gm/imagefiltersclipped.cpp
@@ -138,11 +138,11 @@
SkPaint noisePaint;
noisePaint.setShader(noise);
- sk_sp<SkImageFilter> rectFilter(SkPaintImageFilter::Make(noisePaint));
+ SkAutoTUnref<SkImageFilter> rectFilter(SkPaintImageFilter::Create(noisePaint));
canvas->translate(SK_ARRAY_COUNT(filters)*(r.width() + margin), 0);
for (int xOffset = 0; xOffset < 80; xOffset += 16) {
bounds.fLeft = SkIntToScalar(xOffset);
- draw_clipped_filter(canvas, rectFilter.get(), 0, r, bounds);
+ draw_clipped_filter(canvas, rectFilter, 0, r, bounds);
canvas->translate(0, r.height() + margin);
}
}
diff --git a/gm/imagefiltersscaled.cpp b/gm/imagefiltersscaled.cpp
index 9bfac68..b0c55dc 100644
--- a/gm/imagefiltersscaled.cpp
+++ b/gm/imagefiltersscaled.cpp
@@ -86,7 +86,7 @@
SkErodeImageFilter::Create(1, 1, checkerboard.get()),
SkOffsetImageFilter::Create(SkIntToScalar(32), 0),
SkImageFilter::CreateMatrixFilter(resizeMatrix, kNone_SkFilterQuality),
- SkPaintImageFilter::Make(noisePaint).release(),
+ SkPaintImageFilter::Create(noisePaint),
SkLightingImageFilter::CreatePointLitDiffuse(pointLocation, white, surfaceScale, kd),
SkLightingImageFilter::CreateSpotLitDiffuse(spotLocation, spotTarget, spotExponent,
cutoffAngle, white, surfaceScale, kd),
diff --git a/gm/localmatriximagefilter.cpp b/gm/localmatriximagefilter.cpp
index 5414fe3..d53380b 100644
--- a/gm/localmatriximagefilter.cpp
+++ b/gm/localmatriximagefilter.cpp
@@ -49,7 +49,7 @@
return SkISize::Make(640, 640);
}
- static void show_image(SkCanvas* canvas, SkImage* image, sk_sp<SkImageFilter> filter) {
+ static void show_image(SkCanvas* canvas, SkImage* image, SkImageFilter* filter) {
SkPaint paint;
paint.setStyle(SkPaint::kStroke_Style);
SkRect r = SkRect::MakeIWH(image->width(), image->height()).makeOutset(SK_ScalarHalf,
@@ -81,14 +81,14 @@
canvas->translate(40, 40);
for (auto&& factory : factories) {
- sk_sp<SkImageFilter> filter(factory());
+ SkAutoTUnref<SkImageFilter> filter(factory());
canvas->save();
show_image(canvas, image0.get(), filter);
for (const auto& matrix : matrices) {
- sk_sp<SkImageFilter> localFilter(filter->makeWithLocalMatrix(matrix));
+ SkAutoTUnref<SkImageFilter> localFilter(filter->newWithLocalMatrix(matrix));
canvas->translate(spacer, 0);
- show_image(canvas, image0.get(), std::move(localFilter));
+ show_image(canvas, image0.get(), localFilter);
}
canvas->restore();
canvas->translate(0, spacer);
diff --git a/include/core/SkImageFilter.h b/include/core/SkImageFilter.h
index f4273cb..ab72547 100644
--- a/include/core/SkImageFilter.h
+++ b/include/core/SkImageFilter.h
@@ -255,13 +255,7 @@
* If this filter can be represented by another filter + a localMatrix, return that filter,
* else return null.
*/
- sk_sp<SkImageFilter> makeWithLocalMatrix(const SkMatrix&) const;
-
-#ifdef SK_SUPPORT_LEGACY_IMAGEFILTER_PTR
- SkImageFilter* newWithLocalMatrix(const SkMatrix& matrix) const {
- this->makeWithLocalMatrix(matrix).release();
- }
-#endif
+ SkImageFilter* newWithLocalMatrix(const SkMatrix& matrix) const;
/**
* Create an SkMatrixImageFilter, which transforms its input by the given matrix.
@@ -326,9 +320,7 @@
void allocInputs(int count);
};
- SkImageFilter(int inputCount, SkImageFilter** inputs, const CropRect* cropRect = nullptr);
-
- SkImageFilter(sk_sp<SkImageFilter>* inputs, int inputCount, const CropRect* cropRect);
+ SkImageFilter(int inputCount, SkImageFilter** inputs, const CropRect* cropRect = NULL);
virtual ~SkImageFilter();
diff --git a/include/effects/SkPaintImageFilter.h b/include/effects/SkPaintImageFilter.h
index 2876c04..51d375f 100644
--- a/include/effects/SkPaintImageFilter.h
+++ b/include/effects/SkPaintImageFilter.h
@@ -22,21 +22,13 @@
* not specified, the source primitive's bounds are used
* instead.
*/
- static sk_sp<SkImageFilter> Make(const SkPaint& paint, const CropRect* cropRect = nullptr) {
- return sk_sp<SkImageFilter>(new SkPaintImageFilter(paint, cropRect));
- }
+ static SkImageFilter* Create(const SkPaint& paint, const CropRect* rect = NULL);
bool canComputeFastBounds() const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPaintImageFilter)
-#ifdef SK_SUPPORT_LEGACY_IMAGEFILTER_PTR
- static SkImageFilter* Create(const SkPaint& paint, const CropRect* rect = nullptr) {
- return Make(paint, rect).release();
- }
-#endif
-
protected:
void flatten(SkWriteBuffer&) const override;
sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source, const Context&,
diff --git a/samplecode/SampleFilterFuzz.cpp b/samplecode/SampleFilterFuzz.cpp
index 751ef9b..d5fbc97 100644
--- a/samplecode/SampleFilterFuzz.cpp
+++ b/samplecode/SampleFilterFuzz.cpp
@@ -487,7 +487,7 @@
return maskFilter;
}
-static sk_sp<SkImageFilter> make_image_filter(bool canBeNull = true);
+static SkImageFilter* make_image_filter(bool canBeNull = true);
static SkPaint make_paint() {
SkPaint paint;
@@ -540,13 +540,11 @@
return paint;
}
-static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) {
- sk_sp<SkImageFilter> filter;
+static SkImageFilter* make_image_filter(bool canBeNull) {
+ SkImageFilter* filter = 0;
// Add a 1 in 3 chance to get a nullptr input
- if (canBeNull && (R(3) == 1)) {
- return filter;
- }
+ if (canBeNull && (R(3) == 1)) { return filter; }
enum { ALPHA_THRESHOLD, MERGE, COLOR, LUT3D, BLUR, MAGNIFIER,
DOWN_SAMPLE, XFERMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE,
@@ -555,73 +553,49 @@
switch (R(NUM_FILTERS)) {
case ALPHA_THRESHOLD:
- filter = sk_sp<SkImageFilter>(SkAlphaThresholdFilter::Create(make_region(),
- make_scalar(),
- make_scalar()));
+ filter = SkAlphaThresholdFilter::Create(make_region(), make_scalar(), make_scalar());
break;
- case MERGE: {
- sk_sp<SkImageFilter> subFilter1(make_image_filter());
- sk_sp<SkImageFilter> subFilter2(make_image_filter());
- filter = sk_sp<SkImageFilter>(SkMergeImageFilter::Create(subFilter1.get(),
- subFilter2.get(),
- make_xfermode()));
+ case MERGE:
+ filter = SkMergeImageFilter::Create(make_image_filter(), make_image_filter(), make_xfermode());
break;
- }
- case COLOR: {
+ case COLOR:
+ {
sk_sp<SkColorFilter> cf(make_color_filter());
- sk_sp<SkImageFilter> subFilter(make_image_filter());
- filter = cf ? sk_sp<SkImageFilter>(SkColorFilterImageFilter::Create(cf.get(),
- subFilter.get()))
- : nullptr;
- break;
+ filter = cf ? SkColorFilterImageFilter::Create(cf.get(), make_image_filter()) : 0;
}
- case LUT3D: {
+ break;
+ case LUT3D:
+ {
int cubeDimension;
sk_sp<SkData> lut3D(make_3Dlut(&cubeDimension, (R(2) == 1), (R(2) == 1), (R(2) == 1)));
sk_sp<SkColorFilter> cf(SkColorCubeFilter::Make(lut3D, cubeDimension));
- sk_sp<SkImageFilter> subFilter(make_image_filter());
- filter = cf ? sk_sp<SkImageFilter>(SkColorFilterImageFilter::Create(cf.get(),
- subFilter.get()))
- : nullptr;
- break;
+ filter = cf ? SkColorFilterImageFilter::Create(cf.get(), make_image_filter()) : 0;
}
- case BLUR: {
- sk_sp<SkImageFilter> subFilter(make_image_filter());
- filter = sk_sp<SkImageFilter>(SkBlurImageFilter::Create(make_scalar(true),
- make_scalar(true),
- subFilter.get()));
break;
- }
+ case BLUR:
+ filter = SkBlurImageFilter::Create(make_scalar(true), make_scalar(true), make_image_filter());
+ break;
case MAGNIFIER:
- filter = sk_sp<SkImageFilter>(SkMagnifierImageFilter::Create(make_rect(),
- make_scalar(true)));
+ filter = SkMagnifierImageFilter::Create(make_rect(), make_scalar(true));
break;
case DOWN_SAMPLE:
- filter = sk_sp<SkImageFilter>(SkDownSampleImageFilter::Create(make_scalar()));
+ filter = SkDownSampleImageFilter::Create(make_scalar());
break;
- case XFERMODE: {
- sk_sp<SkImageFilter> subFilter1(make_image_filter());
- sk_sp<SkImageFilter> subFilter2(make_image_filter());
+ case XFERMODE:
filter = SkXfermodeImageFilter::Make(SkXfermode::Make(make_xfermode()),
- subFilter1.get(),
- subFilter2.get(),
- nullptr);
+ make_image_filter(), make_image_filter(),
+ nullptr).release();
break;
- }
- case OFFSET: {
- sk_sp<SkImageFilter> subFilter(make_image_filter());
- filter = sk_sp<SkImageFilter>(SkOffsetImageFilter::Create(make_scalar(), make_scalar(),
- subFilter.get()));
+ case OFFSET:
+ filter = SkOffsetImageFilter::Create(make_scalar(), make_scalar(), make_image_filter());
break;
- }
- case MATRIX: {
- sk_sp<SkImageFilter> subFilter(make_image_filter());
- filter = sk_sp<SkImageFilter>(SkImageFilter::CreateMatrixFilter(make_matrix(),
- (SkFilterQuality)R(4),
- subFilter.get()));
+ case MATRIX:
+ filter = SkImageFilter::CreateMatrixFilter(make_matrix(),
+ (SkFilterQuality)R(4),
+ make_image_filter());
break;
- }
- case MATRIX_CONVOLUTION: {
+ case MATRIX_CONVOLUTION:
+ {
SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize)));
SkISize size = SkISize::Make(R(10)+1, R(10)+1);
@@ -632,68 +606,47 @@
}
SkIPoint kernelOffset = SkIPoint::Make(R(SkIntToScalar(size.width())),
R(SkIntToScalar(size.height())));
- sk_sp<SkImageFilter> subFilter(make_image_filter());
-
- filter = sk_sp<SkImageFilter>(SkMatrixConvolutionImageFilter::Create(
- size,
+ filter = SkMatrixConvolutionImageFilter::Create(size,
kernel.begin(),
make_scalar(),
make_scalar(),
kernelOffset,
(SkMatrixConvolutionImageFilter::TileMode)R(3),
R(2) == 1,
- subFilter.get(),
- &cropR));
- break;
+ make_image_filter(),
+ &cropR);
}
- case COMPOSE: {
- sk_sp<SkImageFilter> subFilter1(make_image_filter());
- sk_sp<SkImageFilter> subFilter2(make_image_filter());
- filter = sk_sp<SkImageFilter>(SkComposeImageFilter::Create(subFilter1.get(),
- subFilter2.get()));
break;
- }
- case DISTANT_LIGHT: {
- sk_sp<SkImageFilter> subFilter(make_image_filter());
-
- filter = (R(2) == 1)
- ? sk_sp<SkImageFilter>(SkLightingImageFilter::CreateDistantLitDiffuse(make_point(),
- make_color(), make_scalar(), make_scalar(),
- subFilter.get()))
- : sk_sp<SkImageFilter>(SkLightingImageFilter::CreateDistantLitSpecular(make_point(),
- make_color(), make_scalar(),
- make_scalar(), SkIntToScalar(R(10)),
- subFilter.get()));
+ case COMPOSE:
+ filter = SkComposeImageFilter::Create(make_image_filter(), make_image_filter());
break;
- }
- case POINT_LIGHT: {
- sk_sp<SkImageFilter> subFilter(make_image_filter());
-
- filter = (R(2) == 1)
- ? sk_sp<SkImageFilter>(SkLightingImageFilter::CreatePointLitDiffuse(make_point(),
- make_color(), make_scalar(), make_scalar(),
- subFilter.get()))
- : sk_sp<SkImageFilter>(SkLightingImageFilter::CreatePointLitSpecular(make_point(),
- make_color(), make_scalar(), make_scalar(),
- SkIntToScalar(R(10)),
- subFilter.get()));
+ case DISTANT_LIGHT:
+ filter = (R(2) == 1) ?
+ SkLightingImageFilter::CreateDistantLitDiffuse(make_point(),
+ make_color(), make_scalar(), make_scalar(), make_image_filter()) :
+ SkLightingImageFilter::CreateDistantLitSpecular(make_point(),
+ make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)),
+ make_image_filter());
break;
- }
- case SPOT_LIGHT: {
- sk_sp<SkImageFilter> subFilter(make_image_filter());
-
- filter = (R(2) == 1)
- ? sk_sp<SkImageFilter>(SkLightingImageFilter::CreateSpotLitDiffuse(SkPoint3::Make(0, 0, 0),
- make_point(), make_scalar(), make_scalar(),
- make_color(), make_scalar(), make_scalar(),
- subFilter.get()))
- : sk_sp<SkImageFilter>(SkLightingImageFilter::CreateSpotLitSpecular(SkPoint3::Make(0, 0, 0),
- make_point(), make_scalar(), make_scalar(),
- make_color(), make_scalar(), make_scalar(),
- SkIntToScalar(R(10)), subFilter.get()));
+ case POINT_LIGHT:
+ filter = (R(2) == 1) ?
+ SkLightingImageFilter::CreatePointLitDiffuse(make_point(),
+ make_color(), make_scalar(), make_scalar(), make_image_filter()) :
+ SkLightingImageFilter::CreatePointLitSpecular(make_point(),
+ make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)),
+ make_image_filter());
break;
- }
- case NOISE: {
+ case SPOT_LIGHT:
+ filter = (R(2) == 1) ?
+ SkLightingImageFilter::CreateSpotLitDiffuse(SkPoint3::Make(0, 0, 0),
+ make_point(), make_scalar(), make_scalar(), make_color(),
+ make_scalar(), make_scalar(), make_image_filter()) :
+ SkLightingImageFilter::CreateSpotLitSpecular(SkPoint3::Make(0, 0, 0),
+ make_point(), make_scalar(), make_scalar(), make_color(),
+ make_scalar(), make_scalar(), SkIntToScalar(R(10)), make_image_filter());
+ break;
+ case NOISE:
+ {
sk_sp<SkShader> shader((R(2) == 1) ?
SkPerlinNoiseShader::MakeFractalNoise(
make_scalar(true), make_scalar(true), R(10.0f), make_scalar()) :
@@ -703,68 +656,43 @@
paint.setShader(shader);
SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize)));
- filter = SkPaintImageFilter::Make(paint, &cropR);
- break;
+ filter = SkPaintImageFilter::Create(paint, &cropR);
}
- case DROP_SHADOW: {
- sk_sp<SkImageFilter> subFilter(make_image_filter());
-
- filter = sk_sp<SkImageFilter>(SkDropShadowImageFilter::Create(make_scalar(),
- make_scalar(),
- make_scalar(true),
- make_scalar(true),
- make_color(),
- make_shadow_mode(),
- subFilter.get(),
- nullptr));
break;
- }
- case MORPHOLOGY: {
- sk_sp<SkImageFilter> subFilter(make_image_filter());
-
+ case DROP_SHADOW:
+ filter = SkDropShadowImageFilter::Create(make_scalar(), make_scalar(), make_scalar(true),
+ make_scalar(true), make_color(), make_shadow_mode(), make_image_filter(),
+ nullptr);
+ break;
+ case MORPHOLOGY:
if (R(2) == 1) {
- filter = sk_sp<SkImageFilter>(SkDilateImageFilter::Create(R(static_cast<float>(kBitmapSize)),
- R(static_cast<float>(kBitmapSize)),
- subFilter.get()));
+ filter = SkDilateImageFilter::Create(R(static_cast<float>(kBitmapSize)),
+ R(static_cast<float>(kBitmapSize)), make_image_filter());
} else {
- filter = sk_sp<SkImageFilter>(SkErodeImageFilter::Create(R(static_cast<float>(kBitmapSize)),
- R(static_cast<float>(kBitmapSize)),
- subFilter.get()));
+ filter = SkErodeImageFilter::Create(R(static_cast<float>(kBitmapSize)),
+ R(static_cast<float>(kBitmapSize)), make_image_filter());
}
break;
- }
- case BITMAP: {
+ case BITMAP:
+ {
sk_sp<SkImage> image(SkImage::MakeFromBitmap(make_bitmap()));
if (R(2) == 1) {
- filter = sk_sp<SkImageFilter>(SkImageSource::Create(image.get(),
- make_rect(),
- make_rect(),
- kHigh_SkFilterQuality));
+ filter = SkImageSource::Create(image.get(), make_rect(), make_rect(), kHigh_SkFilterQuality);
} else {
- filter = sk_sp<SkImageFilter>(SkImageSource::Create(image.get()));
+ filter = SkImageSource::Create(image.get());
}
- break;
}
- case DISPLACE: {
- sk_sp<SkImageFilter> subFilter1(make_image_filter(false));
- sk_sp<SkImageFilter> subFilter2(make_image_filter());
-
- filter = sk_sp<SkImageFilter>(SkDisplacementMapEffect::Create(make_channel_selector_type(),
- make_channel_selector_type(),
- make_scalar(),
- subFilter1.get(),
- subFilter2.get()));
break;
- }
- case TILE: {
- sk_sp<SkImageFilter> subFilter(make_image_filter(false));
-
- filter = sk_sp<SkImageFilter>(SkTileImageFilter::Create(make_rect(),
- make_rect(),
- subFilter.get()));
+ case DISPLACE:
+ filter = SkDisplacementMapEffect::Create(make_channel_selector_type(),
+ make_channel_selector_type(), make_scalar(),
+ make_image_filter(false), make_image_filter());
break;
- }
- case PICTURE: {
+ case TILE:
+ filter = SkTileImageFilter::Create(make_rect(), make_rect(), make_image_filter(false));
+ break;
+ case PICTURE:
+ {
SkRTreeFactory factory;
SkPictureRecorder recorder;
SkCanvas* recordingCanvas = recorder.beginRecording(SkIntToScalar(kBitmapSize),
@@ -772,13 +700,13 @@
&factory, 0);
drawSomething(recordingCanvas);
sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture());
- filter = SkPictureImageFilter::Make(pict, make_rect());
- break;
+ filter = SkPictureImageFilter::Make(pict, make_rect()).release();
}
- case PAINT: {
- SkImageFilter::CropRect cropR(make_rect());
- filter = SkPaintImageFilter::Make(make_paint(), &cropR);
break;
+ case PAINT:
+ {
+ SkImageFilter::CropRect cropR(make_rect());
+ filter = SkPaintImageFilter::Create(make_paint(), &cropR);
}
default:
break;
@@ -787,8 +715,8 @@
}
static SkImageFilter* make_serialized_image_filter() {
- sk_sp<SkImageFilter> filter(make_image_filter(false));
- SkAutoTUnref<SkData> data(SkValidatingSerializeFlattenable(filter.get()));
+ SkAutoTUnref<SkImageFilter> filter(make_image_filter(false));
+ SkAutoTUnref<SkData> data(SkValidatingSerializeFlattenable(filter));
const unsigned char* ptr = static_cast<const unsigned char*>(data->data());
size_t len = data->size();
#ifdef SK_ADD_RANDOM_BIT_FLIPS
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 2f6477c..f177744 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -1161,8 +1161,9 @@
SkCanvas c(dst);
+ SkAutoTUnref<SkImageFilter> localF(filter->newWithLocalMatrix(ctm));
SkPaint p;
- p.setImageFilter(filter->makeWithLocalMatrix(ctm));
+ p.setImageFilter(localF);
const SkScalar x = SkIntToScalar(src->getOrigin().x());
const SkScalar y = SkIntToScalar(src->getOrigin().y());
c.drawBitmap(srcBM, x, y, &p);
diff --git a/src/core/SkImageFilter.cpp b/src/core/SkImageFilter.cpp
index e999d3a..06076c6 100644
--- a/src/core/SkImageFilter.cpp
+++ b/src/core/SkImageFilter.cpp
@@ -158,22 +158,6 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
-SkImageFilter::SkImageFilter(sk_sp<SkImageFilter>* inputs,
- int inputCount,
- const CropRect* cropRect)
- : fInputCount(inputCount),
- fInputs(new SkImageFilter*[inputCount]),
- fUsesSrcInput(false),
- fCropRect(cropRect ? *cropRect : CropRect(SkRect(), 0x0)),
- fUniqueID(next_image_filter_unique_id()) {
- for (int i = 0; i < inputCount; ++i) {
- if (nullptr == inputs[i] || inputs[i]->usesSrcInput()) {
- fUsesSrcInput = true;
- }
- fInputs[i] = SkSafeRef(inputs[i].get());
- }
-}
-
SkImageFilter::SkImageFilter(int inputCount, SkImageFilter** inputs, const CropRect* cropRect)
: fInputCount(inputCount),
fInputs(new SkImageFilter*[inputCount]),
@@ -184,7 +168,8 @@
if (nullptr == inputs[i] || inputs[i]->usesSrcInput()) {
fUsesSrcInput = true;
}
- fInputs[i] = SkSafeRef(inputs[i]);
+ fInputs[i] = inputs[i];
+ SkSafeRef(fInputs[i]);
}
}
@@ -571,12 +556,11 @@
return SkMatrixImageFilter::Create(matrix, filterQuality, input);
}
-sk_sp<SkImageFilter> SkImageFilter::makeWithLocalMatrix(const SkMatrix& matrix) const {
+SkImageFilter* SkImageFilter::newWithLocalMatrix(const SkMatrix& matrix) const {
// SkLocalMatrixImageFilter takes SkImage* in its factory, but logically that parameter
// is *always* treated as a const ptr. Hence the const-cast here.
//
- SkImageFilter* nonConstThis = const_cast<SkImageFilter*>(this);
- return SkLocalMatrixImageFilter::Make(matrix, sk_ref_sp<SkImageFilter>(nonConstThis));
+ return SkLocalMatrixImageFilter::Create(matrix, const_cast<SkImageFilter*>(this));
}
sk_sp<SkSpecialImage> SkImageFilter::filterInput(int index,
diff --git a/src/core/SkLocalMatrixImageFilter.cpp b/src/core/SkLocalMatrixImageFilter.cpp
index d1b5715..15f2f0e 100644
--- a/src/core/SkLocalMatrixImageFilter.cpp
+++ b/src/core/SkLocalMatrixImageFilter.cpp
@@ -10,9 +10,21 @@
#include "SkSpecialImage.h"
#include "SkString.h"
-SkLocalMatrixImageFilter::SkLocalMatrixImageFilter(const SkMatrix& localM,
- sk_sp<SkImageFilter> input)
- : INHERITED(&input, 1, nullptr)
+SkImageFilter* SkLocalMatrixImageFilter::Create(const SkMatrix& localM, SkImageFilter* input) {
+ if (!input) {
+ return nullptr;
+ }
+ if (localM.getType() & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask)) {
+ return nullptr;
+ }
+ if (localM.isIdentity()) {
+ return SkRef(input);
+ }
+ return new SkLocalMatrixImageFilter(localM, input);
+}
+
+SkLocalMatrixImageFilter::SkLocalMatrixImageFilter(const SkMatrix& localM, SkImageFilter* input)
+ : INHERITED(1, &input)
, fLocalM(localM) {
}
@@ -20,8 +32,7 @@
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
SkMatrix lm;
buffer.readMatrix(&lm);
- return SkLocalMatrixImageFilter::Make(lm,
- sk_ref_sp<SkImageFilter>(common.getInput(0))).release();
+ return SkLocalMatrixImageFilter::Create(lm, common.getInput(0));
}
void SkLocalMatrixImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/core/SkLocalMatrixImageFilter.h b/src/core/SkLocalMatrixImageFilter.h
index eb112b0..412b391 100644
--- a/src/core/SkLocalMatrixImageFilter.h
+++ b/src/core/SkLocalMatrixImageFilter.h
@@ -16,28 +16,11 @@
*/
class SkLocalMatrixImageFilter : public SkImageFilter {
public:
- static sk_sp<SkImageFilter> Make(const SkMatrix& localM, sk_sp<SkImageFilter> input) {
- if (!input) {
- return nullptr;
- }
- if (localM.getType() & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask)) {
- return nullptr;
- }
- if (localM.isIdentity()) {
- return input;
- }
- return sk_sp<SkImageFilter>(new SkLocalMatrixImageFilter(localM, input));
- }
+ static SkImageFilter* Create(const SkMatrix& localM, SkImageFilter* input);
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLocalMatrixImageFilter)
-#ifdef SK_SUPPORT_LEGACY_IMAGEFILTER_PTR
- static SkImageFilter* Create(const SkMatrix& localM, SkImageFilter* input) {
- return Make(localM, sk_sp<SkImageFilter>(SkSafeRef(input))).release();
- }
-#endif
-
protected:
void flatten(SkWriteBuffer&) const override;
sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source, const Context&,
@@ -45,7 +28,7 @@
SkIRect onFilterBounds(const SkIRect& src, const SkMatrix&, MapDirection) const override;
private:
- SkLocalMatrixImageFilter(const SkMatrix& localM, sk_sp<SkImageFilter> input);
+ SkLocalMatrixImageFilter(const SkMatrix& localM, SkImageFilter* input);
SkMatrix fLocalM;
diff --git a/src/effects/SkPaintImageFilter.cpp b/src/effects/SkPaintImageFilter.cpp
index cbd793a..7056f26 100644
--- a/src/effects/SkPaintImageFilter.cpp
+++ b/src/effects/SkPaintImageFilter.cpp
@@ -12,16 +12,20 @@
#include "SkSpecialSurface.h"
#include "SkWriteBuffer.h"
+SkImageFilter* SkPaintImageFilter::Create(const SkPaint& paint, const CropRect* cropRect) {
+ return new SkPaintImageFilter(paint, cropRect);
+}
+
SkPaintImageFilter::SkPaintImageFilter(const SkPaint& paint, const CropRect* cropRect)
- : INHERITED(nullptr, 0, cropRect)
- , fPaint(paint) {
+ : INHERITED(0, nullptr, cropRect)
+ , fPaint(paint) {
}
SkFlattenable* SkPaintImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 0);
SkPaint paint;
buffer.readPaint(&paint);
- return SkPaintImageFilter::Make(paint, &common.cropRect()).release();
+ return Create(paint, &common.cropRect());
}
void SkPaintImageFilter::flatten(SkWriteBuffer& buffer) const {
@@ -76,7 +80,6 @@
#ifndef SK_IGNORE_TO_STRING
void SkPaintImageFilter::toString(SkString* str) const {
str->appendf("SkPaintImageFilter: (");
- fPaint.toString(str);
str->append(")");
}
#endif
diff --git a/src/effects/SkPictureImageFilter.cpp b/src/effects/SkPictureImageFilter.cpp
index 2005463..f5e3d46 100644
--- a/src/effects/SkPictureImageFilter.cpp
+++ b/src/effects/SkPictureImageFilter.cpp
@@ -14,7 +14,7 @@
#include "SkValidationUtils.h"
SkPictureImageFilter::SkPictureImageFilter(sk_sp<SkPicture> picture)
- : INHERITED(nullptr, 0, nullptr)
+ : INHERITED(0, 0, nullptr)
, fPicture(std::move(picture))
, fCropRect(fPicture ? fPicture->cullRect() : SkRect::MakeEmpty())
, fPictureResolution(kDeviceSpace_PictureResolution)
@@ -24,7 +24,7 @@
SkPictureImageFilter::SkPictureImageFilter(sk_sp<SkPicture> picture, const SkRect& cropRect,
PictureResolution pictureResolution,
SkFilterQuality filterQuality)
- : INHERITED(nullptr, 0, nullptr)
+ : INHERITED(0, 0, nullptr)
, fPicture(std::move(picture))
, fCropRect(cropRect)
, fPictureResolution(pictureResolution)
diff --git a/tests/ImageFilterTest.cpp b/tests/ImageFilterTest.cpp
index cd900e3..9d20396 100644
--- a/tests/ImageFilterTest.cpp
+++ b/tests/ImageFilterTest.cpp
@@ -138,17 +138,17 @@
SkPaint paint;
paint.setShader(shader);
- sk_sp<SkImageFilter> paintFilter(SkPaintImageFilter::Make(paint));
+ SkAutoTUnref<SkImageFilter> paintFilter(SkPaintImageFilter::Create(paint));
sk_sp<SkShader> greenColorShader(SkShader::MakeColorShader(SK_ColorGREEN));
SkPaint greenColorShaderPaint;
greenColorShaderPaint.setShader(greenColorShader);
SkImageFilter::CropRect leftSideCropRect(SkRect::MakeXYWH(0, 0, 32, 64));
- sk_sp<SkImageFilter> paintFilterLeft(SkPaintImageFilter::Make(greenColorShaderPaint,
- &leftSideCropRect));
+ SkAutoTUnref<SkImageFilter> paintFilterLeft(SkPaintImageFilter::Create(
+ greenColorShaderPaint, &leftSideCropRect));
SkImageFilter::CropRect rightSideCropRect(SkRect::MakeXYWH(32, 0, 32, 64));
- sk_sp<SkImageFilter> paintFilterRight(SkPaintImageFilter::Make(greenColorShaderPaint,
- &rightSideCropRect));
+ SkAutoTUnref<SkImageFilter> paintFilterRight(SkPaintImageFilter::Create(
+ greenColorShaderPaint, &rightSideCropRect));
this->addFilter("color filter",
SkColorFilterImageFilter::Create(cf.get(), input, cropRect));
@@ -172,8 +172,7 @@
this->addFilter("merge", SkMergeImageFilter::Create(input, input, SkXfermode::kSrcOver_Mode,
cropRect));
this->addFilter("merge with disjoint inputs", SkMergeImageFilter::Create(
- paintFilterLeft.get(), paintFilterRight.get(),
- SkXfermode::kSrcOver_Mode, cropRect));
+ paintFilterLeft, paintFilterRight, SkXfermode::kSrcOver_Mode, cropRect));
this->addFilter("offset",
SkOffsetImageFilter::Create(SK_Scalar1, SK_Scalar1, input, cropRect));
this->addFilter("dilate", SkDilateImageFilter::Create(3, 2, input, cropRect));
diff --git a/tests/PaintImageFilterTest.cpp b/tests/PaintImageFilterTest.cpp
index 0365336..f1c0c2e 100644
--- a/tests/PaintImageFilterTest.cpp
+++ b/tests/PaintImageFilterTest.cpp
@@ -38,7 +38,7 @@
{
SkPaint paint;
SkImageFilter::CropRect cr(r);
- paint.setImageFilter(SkPaintImageFilter::Make(gradientPaint, &cr));
+ paint.setImageFilter(SkPaintImageFilter::Create(gradientPaint, &cr))->unref();
canvasFilter.drawRect(r, paint);
}
@@ -84,7 +84,7 @@
{
SkPaint paint;
SkImageFilter::CropRect cr(r);
- paint.setImageFilter(SkPaintImageFilter::Make(gradientPaint, &cr));
+ paint.setImageFilter(SkPaintImageFilter::Create(gradientPaint, &cr))->unref();
canvasFilter.scale(SkIntToScalar(2), SkIntToScalar(2));
canvasFilter.drawRect(r, paint);
}