Make GrFragmentProcessor be non-refcounted and use std::unique_ptr.
Change-Id: I985e54a071338e99292a5aa2f42c92bc115b4008
Reviewed-on: https://skia-review.googlesource.com/32760
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Brian Osman <brianosman@google.com>
diff --git a/src/core/SkColorFilter.cpp b/src/core/SkColorFilter.cpp
index 4291644..22b8221 100644
--- a/src/core/SkColorFilter.cpp
+++ b/src/core/SkColorFilter.cpp
@@ -36,7 +36,8 @@
}
#if SK_SUPPORT_GPU
-sk_sp<GrFragmentProcessor> SkColorFilter::asFragmentProcessor(GrContext*, SkColorSpace*) const {
+std::unique_ptr<GrFragmentProcessor> SkColorFilter::asFragmentProcessor(GrContext*,
+ SkColorSpace*) const {
return nullptr;
}
#endif
@@ -119,14 +120,14 @@
}
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(GrContext* context,
- SkColorSpace* dstColorSpace) const override {
- sk_sp<GrFragmentProcessor> innerFP(fInner->asFragmentProcessor(context, dstColorSpace));
- sk_sp<GrFragmentProcessor> outerFP(fOuter->asFragmentProcessor(context, dstColorSpace));
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(
+ GrContext* context, SkColorSpace* dstColorSpace) const override {
+ auto innerFP = fInner->asFragmentProcessor(context, dstColorSpace);
+ auto outerFP = fOuter->asFragmentProcessor(context, dstColorSpace);
if (!innerFP || !outerFP) {
return nullptr;
}
- sk_sp<GrFragmentProcessor> series[] = { std::move(innerFP), std::move(outerFP) };
+ std::unique_ptr<GrFragmentProcessor> series[] = { std::move(innerFP), std::move(outerFP) };
return GrFragmentProcessor::RunInSeries(series, 2);
}
#endif
@@ -215,7 +216,8 @@
SkSRGBGammaColorFilter(Direction dir) : fDir(dir) {}
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(GrContext* x, SkColorSpace* cs) const override {
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(GrContext* x,
+ SkColorSpace* cs) const override {
// wish our caller would let us know if our input was opaque...
GrSRGBEffect::Alpha alpha = GrSRGBEffect::Alpha::kPremul;
switch (fDir) {
diff --git a/src/core/SkColorMatrixFilterRowMajor255.cpp b/src/core/SkColorMatrixFilterRowMajor255.cpp
index 9262e5b..e2d6c37 100644
--- a/src/core/SkColorMatrixFilterRowMajor255.cpp
+++ b/src/core/SkColorMatrixFilterRowMajor255.cpp
@@ -183,15 +183,15 @@
class ColorMatrixEffect : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(const SkScalar matrix[20]) {
- return sk_sp<GrFragmentProcessor>(new ColorMatrixEffect(matrix));
+ static std::unique_ptr<GrFragmentProcessor> Make(const SkScalar matrix[20]) {
+ return std::unique_ptr<GrFragmentProcessor>(new ColorMatrixEffect(matrix));
}
const char* name() const override { return "Color Matrix"; }
GR_DECLARE_FRAGMENT_PROCESSOR_TEST
- sk_sp<GrFragmentProcessor> clone() const override { return Make(fMatrix); }
+ std::unique_ptr<GrFragmentProcessor> clone() const override { return Make(fMatrix); }
private:
class GLSLProcessor : public GrGLSLFragmentProcessor {
@@ -284,7 +284,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ColorMatrixEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> ColorMatrixEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> ColorMatrixEffect::TestCreate(GrProcessorTestData* d) {
SkScalar colorMatrix[20];
for (size_t i = 0; i < SK_ARRAY_COUNT(colorMatrix); ++i) {
colorMatrix[i] = d->fRandom->nextSScalar1();
@@ -294,8 +294,8 @@
#endif
-sk_sp<GrFragmentProcessor> SkColorMatrixFilterRowMajor255::asFragmentProcessor(
- GrContext*, SkColorSpace*) const {
+std::unique_ptr<GrFragmentProcessor> SkColorMatrixFilterRowMajor255::asFragmentProcessor(
+ GrContext*, SkColorSpace*) const {
return ColorMatrixEffect::Make(fMatrix);
}
diff --git a/src/core/SkColorMatrixFilterRowMajor255.h b/src/core/SkColorMatrixFilterRowMajor255.h
index 7a1471a..7767646 100644
--- a/src/core/SkColorMatrixFilterRowMajor255.h
+++ b/src/core/SkColorMatrixFilterRowMajor255.h
@@ -23,7 +23,8 @@
sk_sp<SkColorFilter> makeComposed(sk_sp<SkColorFilter>) const override;
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(GrContext*, SkColorSpace*) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(GrContext*,
+ SkColorSpace*) const override;
#endif
SK_TO_STRING_OVERRIDE()
diff --git a/src/core/SkGpuBlurUtils.cpp b/src/core/SkGpuBlurUtils.cpp
index 5121cc5..b328eea 100644
--- a/src/core/SkGpuBlurUtils.cpp
+++ b/src/core/SkGpuBlurUtils.cpp
@@ -81,7 +81,7 @@
GrPaint paint;
paint.setGammaCorrect(renderTargetContext->isGammaCorrect());
- sk_sp<GrFragmentProcessor> conv(GrGaussianConvolutionFragmentProcessor::Make(
+ std::unique_ptr<GrFragmentProcessor> conv(GrGaussianConvolutionFragmentProcessor::Make(
std::move(proxy), direction, radius, sigma, mode, bounds));
paint.addColorFragmentProcessor(std::move(conv));
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
@@ -109,9 +109,8 @@
GrPaint paint;
paint.setGammaCorrect(renderTargetContext->isGammaCorrect());
- sk_sp<GrFragmentProcessor> conv(GrMatrixConvolutionEffect::MakeGaussian(
- std::move(proxy), srcBounds, size, 1.0, 0.0, kernelOffset,
- mode, true, sigmaX, sigmaY));
+ auto conv = GrMatrixConvolutionEffect::MakeGaussian(std::move(proxy), srcBounds, size, 1.0, 0.0,
+ kernelOffset, mode, true, sigmaX, sigmaY);
paint.addColorFragmentProcessor(std::move(conv));
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
renderTargetContext->fillRectWithLocalMatrix(clip, std::move(paint), GrAA::kNo, SkMatrix::I(),
@@ -280,13 +279,12 @@
SkRect domain = SkRect::Make(localSrcBounds);
domain.inset((i < scaleFactorX) ? SK_ScalarHalf : 0.0f,
(i < scaleFactorY) ? SK_ScalarHalf : 0.0f);
- sk_sp<GrFragmentProcessor> fp(GrTextureDomainEffect::Make(
- std::move(srcProxy),
- nullptr,
- SkMatrix::I(),
- domain,
- modeForScaling,
- GrSamplerParams::kBilerp_FilterMode));
+ auto fp = GrTextureDomainEffect::Make(std::move(srcProxy),
+ nullptr,
+ SkMatrix::I(),
+ domain,
+ modeForScaling,
+ GrSamplerParams::kBilerp_FilterMode);
paint.addColorFragmentProcessor(std::move(fp));
srcRect.offset(-srcOffset);
srcOffset.set(0, 0);
@@ -402,13 +400,12 @@
if (GrTextureDomain::kIgnore_Mode != mode) {
SkRect domain = SkRect::Make(localSrcBounds);
- sk_sp<GrFragmentProcessor> fp(GrTextureDomainEffect::Make(
- std::move(srcProxy),
- nullptr,
- SkMatrix::I(),
- domain,
- modeForScaling,
- GrSamplerParams::kBilerp_FilterMode));
+ auto fp = GrTextureDomainEffect::Make(std::move(srcProxy),
+ nullptr,
+ SkMatrix::I(),
+ domain,
+ modeForScaling,
+ GrSamplerParams::kBilerp_FilterMode);
paint.addColorFragmentProcessor(std::move(fp));
} else {
// FIXME: this should be mitchell, not bilinear.
diff --git a/src/core/SkImageFilter.cpp b/src/core/SkImageFilter.cpp
index cc0f1e9..7301442 100644
--- a/src/core/SkImageFilter.cpp
+++ b/src/core/SkImageFilter.cpp
@@ -291,7 +291,7 @@
#if SK_SUPPORT_GPU
sk_sp<SkSpecialImage> SkImageFilter::DrawWithFP(GrContext* context,
- sk_sp<GrFragmentProcessor> fp,
+ std::unique_ptr<GrFragmentProcessor> fp,
const SkIRect& bounds,
const OutputProperties& outputProperties) {
GrPaint paint;
diff --git a/src/core/SkModeColorFilter.cpp b/src/core/SkModeColorFilter.cpp
index 2d2fa93..1e2e8de 100644
--- a/src/core/SkModeColorFilter.cpp
+++ b/src/core/SkModeColorFilter.cpp
@@ -97,17 +97,15 @@
#include "effects/GrConstColorProcessor.h"
#include "SkGr.h"
-sk_sp<GrFragmentProcessor> SkModeColorFilter::asFragmentProcessor(
- GrContext*, SkColorSpace* dstColorSpace) const {
+std::unique_ptr<GrFragmentProcessor> SkModeColorFilter::asFragmentProcessor(
+ GrContext*, SkColorSpace* dstColorSpace) const {
if (SkBlendMode::kDst == fMode) {
return nullptr;
}
- sk_sp<GrFragmentProcessor> constFP(
- GrConstColorProcessor::Make(SkColorToPremulGrColor4f(fColor, dstColorSpace),
- GrConstColorProcessor::kIgnore_InputMode));
- sk_sp<GrFragmentProcessor> fp(
- GrXfermodeFragmentProcessor::MakeFromSrcProcessor(std::move(constFP), fMode));
+ auto constFP = GrConstColorProcessor::Make(SkColorToPremulGrColor4f(fColor, dstColorSpace),
+ GrConstColorProcessor::kIgnore_InputMode);
+ auto fp = GrXfermodeFragmentProcessor::MakeFromSrcProcessor(std::move(constFP), fMode);
if (!fp) {
return nullptr;
}
diff --git a/src/core/SkModeColorFilter.h b/src/core/SkModeColorFilter.h
index ea503ac..c5bd785 100644
--- a/src/core/SkModeColorFilter.h
+++ b/src/core/SkModeColorFilter.h
@@ -27,7 +27,8 @@
#endif
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(GrContext*, SkColorSpace*) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(GrContext*,
+ SkColorSpace*) const override;
#endif
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkModeColorFilter)
diff --git a/src/effects/GrAlphaThresholdFragmentProcessor.cpp b/src/effects/GrAlphaThresholdFragmentProcessor.cpp
index 731ca99..8c3afb7 100644
--- a/src/effects/GrAlphaThresholdFragmentProcessor.cpp
+++ b/src/effects/GrAlphaThresholdFragmentProcessor.cpp
@@ -123,12 +123,12 @@
this->addCoordTransform(&fImageCoordTransform);
this->addCoordTransform(&fMaskCoordTransform);
}
-sk_sp<GrFragmentProcessor> GrAlphaThresholdFragmentProcessor::clone() const {
- return sk_sp<GrFragmentProcessor>(new GrAlphaThresholdFragmentProcessor(*this));
+std::unique_ptr<GrFragmentProcessor> GrAlphaThresholdFragmentProcessor::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(new GrAlphaThresholdFragmentProcessor(*this));
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrAlphaThresholdFragmentProcessor);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrAlphaThresholdFragmentProcessor::TestCreate(
+std::unique_ptr<GrFragmentProcessor> GrAlphaThresholdFragmentProcessor::TestCreate(
GrProcessorTestData* testData) {
sk_sp<GrTextureProxy> bmpProxy = testData->textureProxy(GrProcessorUnitTest::kSkiaPMTextureIdx);
sk_sp<GrTextureProxy> maskProxy = testData->textureProxy(GrProcessorUnitTest::kAlphaTextureIdx);
diff --git a/src/effects/GrAlphaThresholdFragmentProcessor.fp b/src/effects/GrAlphaThresholdFragmentProcessor.fp
index e930ed9..481549e 100644
--- a/src/effects/GrAlphaThresholdFragmentProcessor.fp
+++ b/src/effects/GrAlphaThresholdFragmentProcessor.fp
@@ -13,18 +13,14 @@
}
@make {
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> image,
- sk_sp<GrColorSpaceXform> colorXform,
- sk_sp<GrTextureProxy> mask,
- float innerThreshold,
- float outerThreshold,
- const SkIRect& bounds) {
- return sk_sp<GrFragmentProcessor>(new GrAlphaThresholdFragmentProcessor(image,
- colorXform,
- mask,
- innerThreshold,
- outerThreshold,
- bounds));
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> image,
+ sk_sp<GrColorSpaceXform> colorXform,
+ sk_sp<GrTextureProxy> mask,
+ float innerThreshold,
+ float outerThreshold,
+ const SkIRect& bounds) {
+ return std::unique_ptr<GrFragmentProcessor>(new GrAlphaThresholdFragmentProcessor(
+ image, colorXform, mask, innerThreshold, outerThreshold, bounds));
}
}
@@ -89,4 +85,4 @@
std::move(maskProxy),
innerThresh, outerThresh,
bounds);
-}
\ No newline at end of file
+}
diff --git a/src/effects/GrAlphaThresholdFragmentProcessor.h b/src/effects/GrAlphaThresholdFragmentProcessor.h
index 78424d0..3b64951 100644
--- a/src/effects/GrAlphaThresholdFragmentProcessor.h
+++ b/src/effects/GrAlphaThresholdFragmentProcessor.h
@@ -24,19 +24,19 @@
float innerThreshold() const { return fInnerThreshold; }
float outerThreshold() const { return fOuterThreshold; }
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> image,
- sk_sp<GrColorSpaceXform>
- colorXform,
- sk_sp<GrTextureProxy>
- mask,
- float innerThreshold,
- float outerThreshold,
- const SkIRect& bounds) {
- return sk_sp<GrFragmentProcessor>(new GrAlphaThresholdFragmentProcessor(
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> image,
+ sk_sp<GrColorSpaceXform>
+ colorXform,
+ sk_sp<GrTextureProxy>
+ mask,
+ float innerThreshold,
+ float outerThreshold,
+ const SkIRect& bounds) {
+ return std::unique_ptr<GrFragmentProcessor>(new GrAlphaThresholdFragmentProcessor(
image, colorXform, mask, innerThreshold, outerThreshold, bounds));
}
GrAlphaThresholdFragmentProcessor(const GrAlphaThresholdFragmentProcessor& src);
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
const char* name() const override { return "AlphaThresholdFragmentProcessor"; }
private:
diff --git a/src/effects/GrCircleBlurFragmentProcessor.cpp b/src/effects/GrCircleBlurFragmentProcessor.cpp
index 68ba0af..7cec3cc 100644
--- a/src/effects/GrCircleBlurFragmentProcessor.cpp
+++ b/src/effects/GrCircleBlurFragmentProcessor.cpp
@@ -206,9 +206,8 @@
return blurProfile;
}
-sk_sp<GrFragmentProcessor> GrCircleBlurFragmentProcessor::Make(GrResourceProvider* resourceProvider,
- const SkRect& circle,
- float sigma) {
+std::unique_ptr<GrFragmentProcessor> GrCircleBlurFragmentProcessor::Make(
+ GrResourceProvider* resourceProvider, const SkRect& circle, float sigma) {
float solidRadius;
float textureRadius;
sk_sp<GrTextureProxy> profile(
@@ -216,7 +215,7 @@
if (!profile) {
return nullptr;
}
- return sk_sp<GrFragmentProcessor>(new GrCircleBlurFragmentProcessor(
+ return std::unique_ptr<GrFragmentProcessor>(new GrCircleBlurFragmentProcessor(
circle, textureRadius, solidRadius, std::move(profile), resourceProvider));
}
#include "glsl/GrGLSLColorSpaceXformHelper.h"
@@ -295,12 +294,12 @@
this->initClassID<GrCircleBlurFragmentProcessor>();
this->addTextureSampler(&fBlurProfileSampler);
}
-sk_sp<GrFragmentProcessor> GrCircleBlurFragmentProcessor::clone() const {
- return sk_sp<GrFragmentProcessor>(new GrCircleBlurFragmentProcessor(*this));
+std::unique_ptr<GrFragmentProcessor> GrCircleBlurFragmentProcessor::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(new GrCircleBlurFragmentProcessor(*this));
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrCircleBlurFragmentProcessor);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrCircleBlurFragmentProcessor::TestCreate(
+std::unique_ptr<GrFragmentProcessor> GrCircleBlurFragmentProcessor::TestCreate(
GrProcessorTestData* testData) {
SkScalar wh = testData->fRandom->nextRangeScalar(100.f, 1000.f);
SkScalar sigma = testData->fRandom->nextRangeF(1.f, 10.f);
diff --git a/src/effects/GrCircleBlurFragmentProcessor.fp b/src/effects/GrCircleBlurFragmentProcessor.fp
index 01e5426..856a468 100644
--- a/src/effects/GrCircleBlurFragmentProcessor.fp
+++ b/src/effects/GrCircleBlurFragmentProcessor.fp
@@ -18,8 +18,8 @@
}
@make {
- static sk_sp<GrFragmentProcessor> Make(GrResourceProvider* resourceProvider,
- const SkRect& circle, float sigma);
+ static std::unique_ptr<GrFragmentProcessor> Make(GrResourceProvider* resourceProvider,
+ const SkRect& circle, float sigma);
}
@setData(data) {
@@ -256,10 +256,8 @@
return blurProfile;
}
- sk_sp<GrFragmentProcessor> GrCircleBlurFragmentProcessor::Make(
- GrResourceProvider* resourceProvider,
- const SkRect& circle,
- float sigma) {
+ std::unique_ptr<GrFragmentProcessor> GrCircleBlurFragmentProcessor::Make(
+ GrResourceProvider* resourceProvider, const SkRect& circle, float sigma) {
float solidRadius;
float textureRadius;
sk_sp<GrTextureProxy> profile(create_profile_texture(resourceProvider, circle, sigma,
@@ -267,11 +265,8 @@
if (!profile) {
return nullptr;
}
- return sk_sp<GrFragmentProcessor>(new GrCircleBlurFragmentProcessor(circle,
- textureRadius,
- solidRadius,
- std::move(profile),
- resourceProvider));
+ return std::unique_ptr<GrFragmentProcessor>(new GrCircleBlurFragmentProcessor(
+ circle, textureRadius, solidRadius, std::move(profile), resourceProvider));
}
}
@@ -289,4 +284,4 @@
SkScalar sigma = testData->fRandom->nextRangeF(1.f,10.f);
SkRect circle = SkRect::MakeWH(wh, wh);
return GrCircleBlurFragmentProcessor::Make(testData->resourceProvider(), circle, sigma);
-}
\ No newline at end of file
+}
diff --git a/src/effects/GrCircleBlurFragmentProcessor.h b/src/effects/GrCircleBlurFragmentProcessor.h
index 9ef204d..e98714b 100644
--- a/src/effects/GrCircleBlurFragmentProcessor.h
+++ b/src/effects/GrCircleBlurFragmentProcessor.h
@@ -21,10 +21,10 @@
float textureRadius() const { return fTextureRadius; }
float solidRadius() const { return fSolidRadius; }
- static sk_sp<GrFragmentProcessor> Make(GrResourceProvider* resourceProvider,
- const SkRect& circle, float sigma);
+ static std::unique_ptr<GrFragmentProcessor> Make(GrResourceProvider* resourceProvider,
+ const SkRect& circle, float sigma);
GrCircleBlurFragmentProcessor(const GrCircleBlurFragmentProcessor& src);
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
const char* name() const override { return "CircleBlurFragmentProcessor"; }
private:
diff --git a/src/effects/SkAlphaThresholdFilter.cpp b/src/effects/SkAlphaThresholdFilter.cpp
index e46be12..634e6ae 100644
--- a/src/effects/SkAlphaThresholdFilter.cpp
+++ b/src/effects/SkAlphaThresholdFilter.cpp
@@ -173,13 +173,12 @@
sk_sp<GrColorSpaceXform> colorSpaceXform = GrColorSpaceXform::Make(input->getColorSpace(),
outProps.colorSpace());
- sk_sp<GrFragmentProcessor> fp(GrAlphaThresholdFragmentProcessor::Make(
- std::move(inputProxy),
- std::move(colorSpaceXform),
- std::move(maskProxy),
- fInnerThreshold,
- fOuterThreshold,
- bounds));
+ auto fp = GrAlphaThresholdFragmentProcessor::Make(std::move(inputProxy),
+ std::move(colorSpaceXform),
+ std::move(maskProxy),
+ fInnerThreshold,
+ fOuterThreshold,
+ bounds);
if (!fp) {
return nullptr;
}
diff --git a/src/effects/SkArithmeticImageFilter.cpp b/src/effects/SkArithmeticImageFilter.cpp
index 41bafb8..34df275 100644
--- a/src/effects/SkArithmeticImageFilter.cpp
+++ b/src/effects/SkArithmeticImageFilter.cpp
@@ -207,9 +207,10 @@
namespace {
class ArithmeticFP : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(float k1, float k2, float k3, float k4,
- bool enforcePMColor, sk_sp<GrFragmentProcessor> dst) {
- return sk_sp<GrFragmentProcessor>(
+ static std::unique_ptr<GrFragmentProcessor> Make(float k1, float k2, float k3, float k4,
+ bool enforcePMColor,
+ std::unique_ptr<GrFragmentProcessor> dst) {
+ return std::unique_ptr<GrFragmentProcessor>(
new ArithmeticFP(k1, k2, k3, k4, enforcePMColor, std::move(dst)));
}
@@ -223,7 +224,7 @@
return str;
}
- sk_sp<GrFragmentProcessor> clone() const override {
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
return Make(fK1, fK2, fK3, fK4, fEnforcePMColor, this->childProcessor(0).clone());
}
@@ -291,7 +292,7 @@
// This could implement the const input -> const output optimization but it's unlikely to help.
ArithmeticFP(float k1, float k2, float k3, float k4, bool enforcePMColor,
- sk_sp<GrFragmentProcessor> dst)
+ std::unique_ptr<GrFragmentProcessor> dst)
: INHERITED(kNone_OptimizationFlags)
, fK1(k1)
, fK2(k2)
@@ -313,14 +314,14 @@
}
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> ArithmeticFP::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> ArithmeticFP::TestCreate(GrProcessorTestData* d) {
float k1 = d->fRandom->nextF();
float k2 = d->fRandom->nextF();
float k3 = d->fRandom->nextF();
float k4 = d->fRandom->nextF();
bool enforcePMColor = d->fRandom->nextBool();
- sk_sp<GrFragmentProcessor> dst(GrProcessorUnitTest::MakeChildFP(d));
+ std::unique_ptr<GrFragmentProcessor> dst(GrProcessorUnitTest::MakeChildFP(d));
return ArithmeticFP::Make(k1, k2, k3, k4, enforcePMColor, std::move(dst));
}
#endif
@@ -350,7 +351,7 @@
}
GrPaint paint;
- sk_sp<GrFragmentProcessor> bgFP;
+ std::unique_ptr<GrFragmentProcessor> bgFP;
if (backgroundProxy) {
SkMatrix backgroundMatrix = SkMatrix::MakeTrans(-SkIntToScalar(backgroundOffset.fX),
@@ -371,14 +372,13 @@
-SkIntToScalar(foregroundOffset.fY));
sk_sp<GrColorSpaceXform> fgXform =
GrColorSpaceXform::Make(foreground->getColorSpace(), outputProperties.colorSpace());
- sk_sp<GrFragmentProcessor> foregroundFP(GrTextureDomainEffect::Make(
- std::move(foregroundProxy), std::move(fgXform),
- foregroundMatrix,
- GrTextureDomain::MakeTexelDomain(foreground->subset()),
- GrTextureDomain::kDecal_Mode, GrSamplerParams::kNone_FilterMode));
+ auto foregroundFP = GrTextureDomainEffect::Make(
+ std::move(foregroundProxy), std::move(fgXform), foregroundMatrix,
+ GrTextureDomain::MakeTexelDomain(foreground->subset()),
+ GrTextureDomain::kDecal_Mode, GrSamplerParams::kNone_FilterMode);
paint.addColorFragmentProcessor(std::move(foregroundFP));
- sk_sp<GrFragmentProcessor> xferFP =
+ std::unique_ptr<GrFragmentProcessor> xferFP =
ArithmeticFP::Make(fK[0], fK[1], fK[2], fK[3], fEnforcePMColor, std::move(bgFP));
// A null 'xferFP' here means kSrc_Mode was used in which case we can just proceed
diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index f927cc7..2fc10ed 100644
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -769,8 +769,8 @@
const char* name() const override { return "RectBlur"; }
- static sk_sp<GrFragmentProcessor> Make(GrResourceProvider* resourceProvider,
- const SkRect& rect, float sigma) {
+ static std::unique_ptr<GrFragmentProcessor> Make(GrResourceProvider* resourceProvider,
+ const SkRect& rect, float sigma) {
int doubleProfileSize = SkScalarCeilToInt(12*sigma);
if (doubleProfileSize >= rect.width() || doubleProfileSize >= rect.height()) {
@@ -803,12 +803,12 @@
precision = kDefault_GrSLPrecision;
}
- return sk_sp<GrFragmentProcessor>(new GrRectBlurEffect(rect, sigma,
- std::move(blurProfile), precision));
+ return std::unique_ptr<GrFragmentProcessor>(
+ new GrRectBlurEffect(rect, sigma, std::move(blurProfile), precision));
}
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new GrRectBlurEffect(
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new GrRectBlurEffect(
fRect, fSigma, sk_ref_sp(fBlurProfileSampler.proxy()), fPrecision));
}
@@ -1009,7 +1009,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRectBlurEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrRectBlurEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrRectBlurEffect::TestCreate(GrProcessorTestData* d) {
float sigma = d->fRandom->nextRangeF(3,8);
float width = d->fRandom->nextRangeF(200,300);
float height = d->fRandom->nextRangeF(200,300);
@@ -1039,7 +1039,7 @@
SkScalar xformedSigma = this->computeXformedSigma(viewMatrix);
GrResourceProvider* resourceProvider = context->resourceProvider();
- sk_sp<GrFragmentProcessor> fp;
+ std::unique_ptr<GrFragmentProcessor> fp;
SkRect rect;
if (path.isRect(&rect)) {
@@ -1076,9 +1076,9 @@
class GrRRectBlurEffect : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(GrContext*,
- float sigma, float xformedSigma,
- const SkRRect& srcRRect, const SkRRect& devRRect);
+ static std::unique_ptr<GrFragmentProcessor> Make(GrContext*, float sigma, float xformedSigma,
+ const SkRRect& srcRRect,
+ const SkRRect& devRRect);
~GrRRectBlurEffect() override {}
const char* name() const override { return "GrRRectBlur"; }
@@ -1086,7 +1086,7 @@
const SkRRect& getRRect() const { return fRRect; }
float getSigma() const { return fSigma; }
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
private:
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
@@ -1171,9 +1171,10 @@
return mask;
}
-sk_sp<GrFragmentProcessor> GrRRectBlurEffect::Make(GrContext* context,
- float sigma, float xformedSigma,
- const SkRRect& srcRRect, const SkRRect& devRRect) {
+std::unique_ptr<GrFragmentProcessor> GrRRectBlurEffect::Make(GrContext* context, float sigma,
+ float xformedSigma,
+ const SkRRect& srcRRect,
+ const SkRRect& devRRect) {
SkASSERT(!devRRect.isCircle() && !devRRect.isRect()); // Should've been caught up-stream
// TODO: loosen this up
@@ -1208,9 +1209,8 @@
return nullptr;
}
- return sk_sp<GrFragmentProcessor>(new GrRRectBlurEffect(xformedSigma,
- devRRect,
- std::move(mask)));
+ return std::unique_ptr<GrFragmentProcessor>(
+ new GrRRectBlurEffect(xformedSigma, devRRect, std::move(mask)));
}
GrRRectBlurEffect::GrRRectBlurEffect(float sigma, const SkRRect& rrect,
@@ -1223,8 +1223,8 @@
this->addTextureSampler(&fNinePatchSampler);
}
-sk_sp<GrFragmentProcessor> GrRRectBlurEffect::clone() const {
- return sk_sp<GrFragmentProcessor>(
+std::unique_ptr<GrFragmentProcessor> GrRRectBlurEffect::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(
new GrRRectBlurEffect(fSigma, fRRect, sk_ref_sp(fNinePatchSampler.proxy())));
}
@@ -1240,7 +1240,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRRectBlurEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrRRectBlurEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrRRectBlurEffect::TestCreate(GrProcessorTestData* d) {
SkScalar w = d->fRandom->nextRangeScalar(100.f, 1000.f);
SkScalar h = d->fRandom->nextRangeScalar(100.f, 1000.f);
SkScalar r = d->fRandom->nextRangeF(1.f, 9.f);
@@ -1372,7 +1372,7 @@
SkScalar xformedSigma = this->computeXformedSigma(viewMatrix);
if (devRRect.isRect() || devRRect.isCircle()) {
- sk_sp<GrFragmentProcessor> fp;
+ std::unique_ptr<GrFragmentProcessor> fp;
if (devRRect.isRect()) {
SkScalar pad = 3.0f * xformedSigma;
const SkRect dstCoverageRect = devRRect.rect().makeOutset(pad, pad);
@@ -1404,8 +1404,7 @@
return true;
}
- sk_sp<GrFragmentProcessor> fp(GrRRectBlurEffect::Make(context, fSigma, xformedSigma,
- srcRRect, devRRect));
+ auto fp = GrRRectBlurEffect::Make(context, fSigma, xformedSigma, srcRRect, devRRect);
if (!fp) {
return false;
}
diff --git a/src/effects/SkColorMatrixFilter.cpp b/src/effects/SkColorMatrixFilter.cpp
index 0bd6c2c..43a3941 100644
--- a/src/effects/SkColorMatrixFilter.cpp
+++ b/src/effects/SkColorMatrixFilter.cpp
@@ -66,8 +66,8 @@
Factory getFactory() const override { return fMatrixFilter->getFactory(); }
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(GrContext* ctx,
- SkColorSpace* cs) const override {
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(GrContext* ctx,
+ SkColorSpace* cs) const override {
return fMatrixFilter->asFragmentProcessor(ctx, cs);
}
#endif
diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp
index 626ff9f..ff17af1 100644
--- a/src/effects/SkDisplacementMapEffect.cpp
+++ b/src/effects/SkDisplacementMapEffect.cpp
@@ -164,17 +164,15 @@
#if SK_SUPPORT_GPU
class GrDisplacementMapEffect : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(
- SkDisplacementMapEffect::ChannelSelectorType xChannelSelector,
- SkDisplacementMapEffect::ChannelSelectorType yChannelSelector, SkVector scale,
- sk_sp<GrTextureProxy> displacement, const SkMatrix& offsetMatrix,
- sk_sp<GrTextureProxy> color,
- sk_sp<GrColorSpaceXform> colorSpaceXform, const SkISize& colorDimensions) {
- return sk_sp<GrFragmentProcessor>(
- new GrDisplacementMapEffect(xChannelSelector, yChannelSelector, scale,
- std::move(displacement),
- offsetMatrix, std::move(color), std::move(colorSpaceXform),
- colorDimensions));
+ static std::unique_ptr<GrFragmentProcessor> Make(
+ SkDisplacementMapEffect::ChannelSelectorType xChannelSelector,
+ SkDisplacementMapEffect::ChannelSelectorType yChannelSelector, SkVector scale,
+ sk_sp<GrTextureProxy> displacement, const SkMatrix& offsetMatrix,
+ sk_sp<GrTextureProxy> color, sk_sp<GrColorSpaceXform> colorSpaceXform,
+ const SkISize& colorDimensions) {
+ return std::unique_ptr<GrFragmentProcessor>(new GrDisplacementMapEffect(
+ xChannelSelector, yChannelSelector, scale, std::move(displacement), offsetMatrix,
+ std::move(color), std::move(colorSpaceXform), colorDimensions));
}
~GrDisplacementMapEffect() override;
@@ -191,7 +189,7 @@
const GrTextureDomain& domain() const { return fDomain; }
GrColorSpaceXform* colorSpaceXform() const { return fColorSpaceXform.get(); }
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
private:
static OptimizationFlags OptimizationFlags(GrPixelConfig colorConfig);
@@ -504,8 +502,8 @@
GrDisplacementMapEffect::~GrDisplacementMapEffect() {}
-sk_sp<GrFragmentProcessor> GrDisplacementMapEffect::clone() const {
- return sk_sp<GrFragmentProcessor>(new GrDisplacementMapEffect(*this));
+std::unique_ptr<GrFragmentProcessor> GrDisplacementMapEffect::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(new GrDisplacementMapEffect(*this));
}
bool GrDisplacementMapEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
@@ -520,7 +518,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDisplacementMapEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrDisplacementMapEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrDisplacementMapEffect::TestCreate(GrProcessorTestData* d) {
int texIdxDispl = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
GrProcessorUnitTest::kAlphaTextureIdx;
int texIdxColor = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
diff --git a/src/effects/SkHighContrastFilter.cpp b/src/effects/SkHighContrastFilter.cpp
index 6d9853e..3de7603 100644
--- a/src/effects/SkHighContrastFilter.cpp
+++ b/src/effects/SkHighContrastFilter.cpp
@@ -35,7 +35,8 @@
~SkHighContrast_Filter() override {}
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(GrContext*, SkColorSpace*) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(GrContext*,
+ SkColorSpace*) const override;
#endif
void onAppendStages(SkRasterPipeline* p,
@@ -166,15 +167,15 @@
#if SK_SUPPORT_GPU
class HighContrastFilterEffect : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(const SkHighContrastConfig& config) {
- return sk_sp<GrFragmentProcessor>(new HighContrastFilterEffect(config));
+ static std::unique_ptr<GrFragmentProcessor> Make(const SkHighContrastConfig& config) {
+ return std::unique_ptr<GrFragmentProcessor>(new HighContrastFilterEffect(config));
}
const char* name() const override { return "HighContrastFilter"; }
const SkHighContrastConfig& config() const { return fConfig; }
- sk_sp<GrFragmentProcessor> clone() const override { return Make(fConfig); }
+ std::unique_ptr<GrFragmentProcessor> clone() const override { return Make(fConfig); }
private:
HighContrastFilterEffect(const SkHighContrastConfig& config)
@@ -353,7 +354,8 @@
fragBuilder->codeAppendf("%s = color;", args.fOutputColor);
}
-sk_sp<GrFragmentProcessor> SkHighContrast_Filter::asFragmentProcessor(GrContext*, SkColorSpace*) const {
+std::unique_ptr<GrFragmentProcessor> SkHighContrast_Filter::asFragmentProcessor(
+ GrContext*, SkColorSpace*) const {
return HighContrastFilterEffect::Make(fConfig);
}
#endif
diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index 817f96f..fa02104 100644
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -411,10 +411,11 @@
const SkIRect& bounds,
const SkMatrix& matrix,
const OutputProperties& outputProperties) const;
- virtual sk_sp<GrFragmentProcessor> makeFragmentProcessor(sk_sp<GrTextureProxy>,
- const SkMatrix&,
- const SkIRect* srcBounds,
- BoundaryMode boundaryMode) const = 0;
+ virtual std::unique_ptr<GrFragmentProcessor> makeFragmentProcessor(
+ sk_sp<GrTextureProxy>,
+ const SkMatrix&,
+ const SkIRect* srcBounds,
+ BoundaryMode boundaryMode) const = 0;
#endif
private:
#if SK_SUPPORT_GPU
@@ -442,9 +443,7 @@
SkRect srcRect = dstRect.makeOffset(SkIntToScalar(bounds.x()), SkIntToScalar(bounds.y()));
GrPaint paint;
paint.setGammaCorrect(renderTargetContext->isGammaCorrect());
- sk_sp<GrFragmentProcessor> fp(this->makeFragmentProcessor(std::move(srcProxy),
- matrix, srcBounds,
- boundaryMode));
+ auto fp = this->makeFragmentProcessor(std::move(srcProxy), matrix, srcBounds, boundaryMode);
paint.addColorFragmentProcessor(std::move(fp));
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
renderTargetContext->fillRectToRect(clip, std::move(paint), GrAA::kNo, SkMatrix::I(), dstRect,
@@ -541,9 +540,10 @@
sk_sp<SkImageFilter> onMakeColorSpace(SkColorSpaceXformer*) const override;
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> makeFragmentProcessor(sk_sp<GrTextureProxy>,
- const SkMatrix&, const SkIRect* bounds,
- BoundaryMode) const override;
+ std::unique_ptr<GrFragmentProcessor> makeFragmentProcessor(sk_sp<GrTextureProxy>,
+ const SkMatrix&,
+ const SkIRect* bounds,
+ BoundaryMode) const override;
#endif
private:
@@ -578,9 +578,10 @@
sk_sp<SkImageFilter> onMakeColorSpace(SkColorSpaceXformer*) const override;
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> makeFragmentProcessor(sk_sp<GrTextureProxy>,
- const SkMatrix&, const SkIRect* bounds,
- BoundaryMode) const override;
+ std::unique_ptr<GrFragmentProcessor> makeFragmentProcessor(sk_sp<GrTextureProxy>,
+ const SkMatrix&,
+ const SkIRect* bounds,
+ BoundaryMode) const override;
#endif
private:
@@ -623,22 +624,22 @@
class GrDiffuseLightingEffect : public GrLightingEffect {
public:
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
- sk_sp<const SkImageFilterLight> light,
- SkScalar surfaceScale,
- const SkMatrix& matrix,
- SkScalar kd,
- BoundaryMode boundaryMode,
- const SkIRect* srcBounds) {
- return sk_sp<GrFragmentProcessor>(
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
+ sk_sp<const SkImageFilterLight> light,
+ SkScalar surfaceScale,
+ const SkMatrix& matrix,
+ SkScalar kd,
+ BoundaryMode boundaryMode,
+ const SkIRect* srcBounds) {
+ return std::unique_ptr<GrFragmentProcessor>(
new GrDiffuseLightingEffect(std::move(proxy), std::move(light), surfaceScale,
matrix, kd, boundaryMode, srcBounds));
}
const char* name() const override { return "DiffuseLighting"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new GrDiffuseLightingEffect(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new GrDiffuseLightingEffect(*this));
}
SkScalar kd() const { return fKD; }
@@ -668,23 +669,23 @@
class GrSpecularLightingEffect : public GrLightingEffect {
public:
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
- sk_sp<const SkImageFilterLight> light,
- SkScalar surfaceScale,
- const SkMatrix& matrix,
- SkScalar ks,
- SkScalar shininess,
- BoundaryMode boundaryMode,
- const SkIRect* srcBounds) {
- return sk_sp<GrFragmentProcessor>(
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
+ sk_sp<const SkImageFilterLight> light,
+ SkScalar surfaceScale,
+ const SkMatrix& matrix,
+ SkScalar ks,
+ SkScalar shininess,
+ BoundaryMode boundaryMode,
+ const SkIRect* srcBounds) {
+ return std::unique_ptr<GrFragmentProcessor>(
new GrSpecularLightingEffect(std::move(proxy), std::move(light), surfaceScale,
matrix, ks, shininess, boundaryMode, srcBounds));
}
const char* name() const override { return "SpecularLighting"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrSpecularLightingEffect>(new GrSpecularLightingEffect(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new GrSpecularLightingEffect(*this));
}
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
@@ -1373,11 +1374,11 @@
#endif
#if SK_SUPPORT_GPU
-sk_sp<GrFragmentProcessor> SkDiffuseLightingImageFilter::makeFragmentProcessor(
- sk_sp<GrTextureProxy> proxy,
- const SkMatrix& matrix,
- const SkIRect* srcBounds,
- BoundaryMode boundaryMode) const {
+std::unique_ptr<GrFragmentProcessor> SkDiffuseLightingImageFilter::makeFragmentProcessor(
+ sk_sp<GrTextureProxy> proxy,
+ const SkMatrix& matrix,
+ const SkIRect* srcBounds,
+ BoundaryMode boundaryMode) const {
SkScalar scale = this->surfaceScale() * 255;
return GrDiffuseLightingEffect::Make(std::move(proxy), this->refLight(), scale, matrix,
this->kd(), boundaryMode, srcBounds);
@@ -1529,11 +1530,11 @@
#endif
#if SK_SUPPORT_GPU
-sk_sp<GrFragmentProcessor> SkSpecularLightingImageFilter::makeFragmentProcessor(
- sk_sp<GrTextureProxy> proxy,
- const SkMatrix& matrix,
- const SkIRect* srcBounds,
- BoundaryMode boundaryMode) const {
+std::unique_ptr<GrFragmentProcessor> SkSpecularLightingImageFilter::makeFragmentProcessor(
+ sk_sp<GrTextureProxy> proxy,
+ const SkMatrix& matrix,
+ const SkIRect* srcBounds,
+ BoundaryMode boundaryMode) const {
SkScalar scale = this->surfaceScale() * 255;
return GrSpecularLightingEffect::Make(std::move(proxy), this->refLight(), scale, matrix,
this->ks(), this->shininess(), boundaryMode, srcBounds);
@@ -1794,7 +1795,7 @@
}
}
-sk_sp<GrFragmentProcessor> GrDiffuseLightingEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrDiffuseLightingEffect::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
: GrProcessorUnitTest::kAlphaTextureIdx;
sk_sp<GrTextureProxy> proxy = d->textureProxy(texIdx);
@@ -2020,7 +2021,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSpecularLightingEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrSpecularLightingEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrSpecularLightingEffect::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
: GrProcessorUnitTest::kAlphaTextureIdx;
sk_sp<GrTextureProxy> proxy = d->textureProxy(texIdx);
diff --git a/src/effects/SkLumaColorFilter.cpp b/src/effects/SkLumaColorFilter.cpp
index 2a065b3..4422733 100644
--- a/src/effects/SkLumaColorFilter.cpp
+++ b/src/effects/SkLumaColorFilter.cpp
@@ -45,13 +45,13 @@
#if SK_SUPPORT_GPU
class LumaColorFilterEffect : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make() {
- return sk_sp<GrFragmentProcessor>(new LumaColorFilterEffect);
+ static std::unique_ptr<GrFragmentProcessor> Make() {
+ return std::unique_ptr<GrFragmentProcessor>(new LumaColorFilterEffect);
}
const char* name() const override { return "Luminance-to-Alpha"; }
- sk_sp<GrFragmentProcessor> clone() const override { return Make(); }
+ std::unique_ptr<GrFragmentProcessor> clone() const override { return Make(); }
private:
class GLSLProcessor : public GrGLSLFragmentProcessor {
@@ -103,7 +103,8 @@
typedef GrFragmentProcessor INHERITED;
};
-sk_sp<GrFragmentProcessor> SkLumaColorFilter::asFragmentProcessor(GrContext*, SkColorSpace*) const {
+std::unique_ptr<GrFragmentProcessor> SkLumaColorFilter::asFragmentProcessor(GrContext*,
+ SkColorSpace*) const {
return LumaColorFilterEffect::Make();
}
#endif
diff --git a/src/effects/SkMagnifierImageFilter.cpp b/src/effects/SkMagnifierImageFilter.cpp
index 7b03307..ba01969 100644
--- a/src/effects/SkMagnifierImageFilter.cpp
+++ b/src/effects/SkMagnifierImageFilter.cpp
@@ -49,27 +49,25 @@
#if SK_SUPPORT_GPU
class GrMagnifierEffect : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
- sk_sp<GrColorSpaceXform> colorSpaceXform,
- const SkIRect& bounds,
- const SkRect& srcRect,
- float xInvZoom,
- float yInvZoom,
- float xInvInset,
- float yInvInset) {
- return sk_sp<GrFragmentProcessor>(new GrMagnifierEffect(std::move(proxy),
- std::move(colorSpaceXform),
- bounds, srcRect,
- xInvZoom, yInvZoom,
- xInvInset, yInvInset));
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
+ sk_sp<GrColorSpaceXform> colorSpaceXform,
+ const SkIRect& bounds,
+ const SkRect& srcRect,
+ float xInvZoom,
+ float yInvZoom,
+ float xInvInset,
+ float yInvInset) {
+ return std::unique_ptr<GrFragmentProcessor>(
+ new GrMagnifierEffect(std::move(proxy), std::move(colorSpaceXform), bounds, srcRect,
+ xInvZoom, yInvZoom, xInvInset, yInvInset));
}
~GrMagnifierEffect() override {}
const char* name() const override { return "Magnifier"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new GrMagnifierEffect(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new GrMagnifierEffect(*this));
}
SkString dumpInfo() const override {
@@ -285,7 +283,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMagnifierEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrMagnifierEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrMagnifierEffect::TestCreate(GrProcessorTestData* d) {
sk_sp<GrTextureProxy> proxy = d->textureProxy(0);
const int kMaxWidth = 200;
const int kMaxHeight = 200;
@@ -298,15 +296,14 @@
SkIRect bounds = SkIRect::MakeWH(SkIntToScalar(kMaxWidth), SkIntToScalar(kMaxHeight));
SkRect srcRect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
- sk_sp<GrFragmentProcessor> effect(GrMagnifierEffect::Make(
- std::move(proxy),
- std::move(colorSpaceXform),
- bounds,
- srcRect,
- srcRect.width() / bounds.width(),
- srcRect.height() / bounds.height(),
- bounds.width() / inset,
- bounds.height() / inset));
+ auto effect = GrMagnifierEffect::Make(std::move(proxy),
+ std::move(colorSpaceXform),
+ bounds,
+ srcRect,
+ srcRect.width() / bounds.width(),
+ srcRect.height() / bounds.height(),
+ bounds.width() / inset,
+ bounds.height() / inset);
SkASSERT(effect);
return effect;
}
@@ -388,15 +385,14 @@
SkColorSpace* dstColorSpace = ctx.outputProperties().colorSpace();
sk_sp<GrColorSpaceXform> colorSpaceXform = GrColorSpaceXform::Make(input->getColorSpace(),
dstColorSpace);
- sk_sp<GrFragmentProcessor> fp(GrMagnifierEffect::Make(
- std::move(inputProxy),
- std::move(colorSpaceXform),
- bounds,
- fSrcRect,
- invXZoom,
- invYZoom,
- bounds.width() * invInset,
- bounds.height() * invInset));
+ auto fp = GrMagnifierEffect::Make(std::move(inputProxy),
+ std::move(colorSpaceXform),
+ bounds,
+ fSrcRect,
+ invXZoom,
+ invYZoom,
+ bounds.width() * invInset,
+ bounds.height() * invInset);
if (!fp) {
return nullptr;
}
diff --git a/src/effects/SkMatrixConvolutionImageFilter.cpp b/src/effects/SkMatrixConvolutionImageFilter.cpp
index b94ece5..ce84f3e 100644
--- a/src/effects/SkMatrixConvolutionImageFilter.cpp
+++ b/src/effects/SkMatrixConvolutionImageFilter.cpp
@@ -316,15 +316,15 @@
offset->fY = bounds.top();
bounds.offset(-inputOffset);
- sk_sp<GrFragmentProcessor> fp(GrMatrixConvolutionEffect::Make(std::move(inputProxy),
- bounds,
- fKernelSize,
- fKernel,
- fGain,
- fBias,
- fKernelOffset,
- convert_tilemodes(fTileMode),
- fConvolveAlpha));
+ auto fp = GrMatrixConvolutionEffect::Make(std::move(inputProxy),
+ bounds,
+ fKernelSize,
+ fKernel,
+ fGain,
+ fBias,
+ fKernelOffset,
+ convert_tilemodes(fTileMode),
+ fConvolveAlpha);
if (!fp) {
return nullptr;
}
diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp
index a29bca3..1585c9d 100644
--- a/src/effects/SkMorphologyImageFilter.cpp
+++ b/src/effects/SkMorphologyImageFilter.cpp
@@ -142,16 +142,16 @@
enum class Direction { kX, kY };
enum class Type { kErode, kDilate };
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy, Direction dir, int radius,
- Type type) {
- return sk_sp<GrFragmentProcessor>(
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy, Direction dir,
+ int radius, Type type) {
+ return std::unique_ptr<GrFragmentProcessor>(
new GrMorphologyEffect(std::move(proxy), dir, radius, type, nullptr));
}
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy, Direction dir, int radius,
- Type type, const float bounds[2]) {
- return sk_sp<GrFragmentProcessor>(new GrMorphologyEffect(std::move(proxy),
- dir, radius, type, bounds));
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy, Direction dir,
+ int radius, Type type, const float bounds[2]) {
+ return std::unique_ptr<GrFragmentProcessor>(
+ new GrMorphologyEffect(std::move(proxy), dir, radius, type, bounds));
}
Type type() const { return fType; }
@@ -163,8 +163,8 @@
const char* name() const override { return "Morphology"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new GrMorphologyEffect(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new GrMorphologyEffect(*this));
}
private:
@@ -382,7 +382,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMorphologyEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrMorphologyEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrMorphologyEffect::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
: GrProcessorUnitTest::kAlphaTextureIdx;
sk_sp<GrTextureProxy> proxy = d->textureProxy(texIdx);
diff --git a/src/effects/SkOverdrawColorFilter.cpp b/src/effects/SkOverdrawColorFilter.cpp
index 4eb9bfc..8ca699e 100644
--- a/src/effects/SkOverdrawColorFilter.cpp
+++ b/src/effects/SkOverdrawColorFilter.cpp
@@ -73,12 +73,12 @@
class OverdrawFragmentProcessor : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(const SkPMColor* colors);
+ static std::unique_ptr<GrFragmentProcessor> Make(const SkPMColor* colors);
const char* name() const override { return "Overdraw"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new OverdrawFragmentProcessor(fColors));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new OverdrawFragmentProcessor(fColors));
}
private:
@@ -108,12 +108,12 @@
typedef GrGLSLFragmentProcessor INHERITED;
};
-sk_sp<GrFragmentProcessor> SkOverdrawColorFilter::asFragmentProcessor(GrContext*,
- SkColorSpace*) const {
+std::unique_ptr<GrFragmentProcessor> SkOverdrawColorFilter::asFragmentProcessor(
+ GrContext*, SkColorSpace*) const {
return OverdrawFragmentProcessor::Make(fColors);
}
-sk_sp<GrFragmentProcessor> OverdrawFragmentProcessor::Make(const SkPMColor* colors) {
+std::unique_ptr<GrFragmentProcessor> OverdrawFragmentProcessor::Make(const SkPMColor* colors) {
GrColor4f grColors[SkOverdrawColorFilter::kNumColors];
for (int i = 0; i < SkOverdrawColorFilter::kNumColors; i++) {
grColors[i] = GrColor4f::FromGrColor(GrColorPackRGBA(SkGetPackedR32(colors[i]),
@@ -122,7 +122,7 @@
SkGetPackedA32(colors[i])));
}
- return sk_sp<GrFragmentProcessor>(new OverdrawFragmentProcessor(grColors));
+ return std::unique_ptr<GrFragmentProcessor>(new OverdrawFragmentProcessor(grColors));
}
// This could implement the constant input -> constant output optimization, but we don't really
diff --git a/src/effects/SkOverdrawColorFilter.h b/src/effects/SkOverdrawColorFilter.h
index 2840a09..0948f70 100644
--- a/src/effects/SkOverdrawColorFilter.h
+++ b/src/effects/SkOverdrawColorFilter.h
@@ -28,7 +28,8 @@
}
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(GrContext*, SkColorSpace*) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(GrContext*,
+ SkColorSpace*) const override;
#endif
void toString(SkString* str) const override;
diff --git a/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp b/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp
index 8b1856a..2f045f1 100644
--- a/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp
+++ b/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp
@@ -204,15 +204,16 @@
kSimpleCircular_Mode,
};
- static sk_sp<GrFragmentProcessor> Make(const SkRRect& first, const SkRRect& second,
- SkScalar radius) {
- return sk_sp<GrFragmentProcessor>(new RRectsGaussianEdgeFP(first, second, radius));
+ static std::unique_ptr<GrFragmentProcessor> Make(const SkRRect& first, const SkRRect& second,
+ SkScalar radius) {
+ return std::unique_ptr<GrFragmentProcessor>(
+ new RRectsGaussianEdgeFP(first, second, radius));
}
const char* name() const override { return "RRectsGaussianEdgeFP"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new RRectsGaussianEdgeFP(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new RRectsGaussianEdgeFP(*this));
}
const SkRRect& first() const { return fFirst; }
diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp
index 0fb9109..2101bd6 100644
--- a/src/effects/SkTableColorFilter.cpp
+++ b/src/effects/SkTableColorFilter.cpp
@@ -86,7 +86,8 @@
sk_sp<SkColorFilter> makeComposed(sk_sp<SkColorFilter> inner) const override;
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(GrContext*, SkColorSpace*) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(GrContext*,
+ SkColorSpace*) const override;
#endif
SK_TO_STRING_OVERRIDE()
@@ -330,7 +331,7 @@
class ColorTableEffect : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(GrContext* context, const SkBitmap& bitmap);
+ static std::unique_ptr<GrFragmentProcessor> Make(GrContext* context, const SkBitmap& bitmap);
~ColorTableEffect() override;
@@ -339,7 +340,7 @@
const GrTextureStripAtlas* atlas() const { return fAtlas; }
int atlasRow() const { return fRow; }
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
private:
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
@@ -443,7 +444,8 @@
}
///////////////////////////////////////////////////////////////////////////////
-sk_sp<GrFragmentProcessor> ColorTableEffect::Make(GrContext* context, const SkBitmap& bitmap) {
+std::unique_ptr<GrFragmentProcessor> ColorTableEffect::Make(GrContext* context,
+ const SkBitmap& bitmap) {
GrTextureStripAtlas::Desc desc;
desc.fWidth = bitmap.width();
desc.fHeight = 128;
@@ -467,7 +469,7 @@
return nullptr;
}
- return sk_sp<GrFragmentProcessor>(new ColorTableEffect(std::move(proxy), atlas, row));
+ return std::unique_ptr<GrFragmentProcessor>(new ColorTableEffect(std::move(proxy), atlas, row));
}
ColorTableEffect::ColorTableEffect(sk_sp<GrTextureProxy> proxy, GrTextureStripAtlas* atlas, int row)
@@ -485,9 +487,9 @@
}
}
-sk_sp<GrFragmentProcessor> ColorTableEffect::clone() const {
+std::unique_ptr<GrFragmentProcessor> ColorTableEffect::clone() const {
fAtlas->lockRow(fRow);
- return sk_sp<GrFragmentProcessor>(
+ return std::unique_ptr<GrFragmentProcessor>(
new ColorTableEffect(sk_ref_sp(fTextureSampler.proxy()), fAtlas, fRow));
}
@@ -515,7 +517,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ColorTableEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> ColorTableEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> ColorTableEffect::TestCreate(GrProcessorTestData* d) {
int flags = 0;
uint8_t luts[256][4];
do {
@@ -537,14 +539,14 @@
(flags & (1 << 3)) ? luts[3] : nullptr
));
sk_sp<SkColorSpace> colorSpace = GrTest::TestColorSpace(d->fRandom);
- sk_sp<GrFragmentProcessor> fp = filter->asFragmentProcessor(d->context(), colorSpace.get());
+ auto fp = filter->asFragmentProcessor(d->context(), colorSpace.get());
SkASSERT(fp);
return fp;
}
#endif
-sk_sp<GrFragmentProcessor> SkTable_ColorFilter::asFragmentProcessor(GrContext* context,
- SkColorSpace*) const {
+std::unique_ptr<GrFragmentProcessor> SkTable_ColorFilter::asFragmentProcessor(GrContext* context,
+ SkColorSpace*) const {
SkBitmap bitmap;
this->asComponentTable(&bitmap);
diff --git a/src/effects/SkToSRGBColorFilter.cpp b/src/effects/SkToSRGBColorFilter.cpp
index f2ffc08..150877f 100644
--- a/src/effects/SkToSRGBColorFilter.cpp
+++ b/src/effects/SkToSRGBColorFilter.cpp
@@ -86,8 +86,8 @@
#endif
#if SK_SUPPORT_GPU
-sk_sp<GrFragmentProcessor> SkToSRGBColorFilter::asFragmentProcessor(GrContext*,
- SkColorSpace*) const {
+std::unique_ptr<GrFragmentProcessor> SkToSRGBColorFilter::asFragmentProcessor(GrContext*,
+ SkColorSpace*) const {
return GrNonlinearColorSpaceXformEffect::Make(fSrcColorSpace.get(),
SkColorSpace::MakeSRGB().get());
}
diff --git a/src/effects/SkXfermodeImageFilter.cpp b/src/effects/SkXfermodeImageFilter.cpp
index f0c70a2..e1033cf 100644
--- a/src/effects/SkXfermodeImageFilter.cpp
+++ b/src/effects/SkXfermodeImageFilter.cpp
@@ -54,7 +54,8 @@
void drawForeground(SkCanvas* canvas, SkSpecialImage*, const SkIRect&) const;
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> makeFGFrag(sk_sp<GrFragmentProcessor> bgFP) const;
+ std::unique_ptr<GrFragmentProcessor> makeFGFrag(
+ std::unique_ptr<GrFragmentProcessor> bgFP) const;
#endif
private:
@@ -243,7 +244,7 @@
}
GrPaint paint;
- sk_sp<GrFragmentProcessor> bgFP;
+ std::unique_ptr<GrFragmentProcessor> bgFP;
if (backgroundProxy) {
SkMatrix bgMatrix = SkMatrix::MakeTrans(-SkIntToScalar(backgroundOffset.fX),
@@ -266,15 +267,13 @@
-SkIntToScalar(foregroundOffset.fY));
sk_sp<GrColorSpaceXform> fgXform = GrColorSpaceXform::Make(foreground->getColorSpace(),
outputProperties.colorSpace());
- sk_sp<GrFragmentProcessor> foregroundFP(GrTextureDomainEffect::Make(
- std::move(foregroundProxy),
- std::move(fgXform), fgMatrix,
- GrTextureDomain::MakeTexelDomain(foreground->subset()),
- GrTextureDomain::kDecal_Mode,
- GrSamplerParams::kNone_FilterMode));
+ auto foregroundFP = GrTextureDomainEffect::Make(
+ std::move(foregroundProxy), std::move(fgXform), fgMatrix,
+ GrTextureDomain::MakeTexelDomain(foreground->subset()),
+ GrTextureDomain::kDecal_Mode, GrSamplerParams::kNone_FilterMode);
paint.addColorFragmentProcessor(std::move(foregroundFP));
- sk_sp<GrFragmentProcessor> xferFP = this->makeFGFrag(std::move(bgFP));
+ std::unique_ptr<GrFragmentProcessor> xferFP = this->makeFGFrag(std::move(bgFP));
// A null 'xferFP' here means kSrc_Mode was used in which case we can just proceed
if (xferFP) {
@@ -307,8 +306,8 @@
renderTargetContext->refColorSpace());
}
-sk_sp<GrFragmentProcessor>
-SkXfermodeImageFilter_Base::makeFGFrag(sk_sp<GrFragmentProcessor> bgFP) const {
+std::unique_ptr<GrFragmentProcessor> SkXfermodeImageFilter_Base::makeFGFrag(
+ std::unique_ptr<GrFragmentProcessor> bgFP) const {
return GrXfermodeFragmentProcessor::MakeFromDstProcessor(std::move(bgFP), fMode);
}
diff --git a/src/gpu/GrAppliedClip.h b/src/gpu/GrAppliedClip.h
index 7ef3346..bcf6eb9 100644
--- a/src/gpu/GrAppliedClip.h
+++ b/src/gpu/GrAppliedClip.h
@@ -27,7 +27,7 @@
const GrScissorState& scissorState() const { return fScissorState; }
const GrWindowRectsState& windowRectsState() const { return fWindowRectsState; }
GrFragmentProcessor* clipCoverageFragmentProcessor() const { return fClipCoverageFP.get(); }
- sk_sp<GrFragmentProcessor> detachClipCoverageFragmentProcessor() {
+ std::unique_ptr<GrFragmentProcessor> detachClipCoverageFragmentProcessor() {
return std::move(fClipCoverageFP);
}
bool hasStencilClip() const { return SkClipStack::kInvalidGenID != fClipStackID; }
@@ -51,9 +51,9 @@
fWindowRectsState.set(windows, mode);
}
- void addCoverageFP(sk_sp<GrFragmentProcessor> fp) {
+ void addCoverageFP(std::unique_ptr<GrFragmentProcessor> fp) {
SkASSERT(!fClipCoverageFP);
- fClipCoverageFP = fp;
+ fClipCoverageFP = std::move(fp);
}
void addStencilClip(uint32_t clipStackID) {
@@ -85,7 +85,7 @@
private:
GrScissorState fScissorState;
GrWindowRectsState fWindowRectsState;
- sk_sp<GrFragmentProcessor> fClipCoverageFP;
+ std::unique_ptr<GrFragmentProcessor> fClipCoverageFP;
uint32_t fClipStackID = SkClipStack::kInvalidGenID;
};
diff --git a/src/gpu/GrClipStackClip.cpp b/src/gpu/GrClipStackClip.cpp
index 49d5635..0b07fd5 100644
--- a/src/gpu/GrClipStackClip.cpp
+++ b/src/gpu/GrClipStackClip.cpp
@@ -73,8 +73,8 @@
////////////////////////////////////////////////////////////////////////////////
// set up the draw state to enable the aa clipping mask.
-static sk_sp<GrFragmentProcessor> create_fp_for_mask(sk_sp<GrTextureProxy> mask,
- const SkIRect &devBound) {
+static std::unique_ptr<GrFragmentProcessor> create_fp_for_mask(sk_sp<GrTextureProxy> mask,
+ const SkIRect& devBound) {
SkIRect domainTexels = SkIRect::MakeWH(devBound.width(), devBound.height());
return GrDeviceSpaceTextureDecalFragmentProcessor::Make(std::move(mask), domainTexels,
{devBound.fLeft, devBound.fTop});
@@ -174,9 +174,9 @@
static bool get_analytic_clip_processor(const ElementList& elements,
bool abortIfAA,
const SkRect& drawDevBounds,
- sk_sp<GrFragmentProcessor>* resultFP) {
+ std::unique_ptr<GrFragmentProcessor>* resultFP) {
SkASSERT(elements.count() <= kMaxAnalyticElements);
- SkSTArray<kMaxAnalyticElements, sk_sp<GrFragmentProcessor>> fps;
+ SkSTArray<kMaxAnalyticElements, std::unique_ptr<GrFragmentProcessor>> fps;
ElementList::Iter iter(elements);
while (iter.get()) {
SkClipOp op = iter.get()->getOp();
@@ -302,7 +302,7 @@
// is multisampled.
disallowAnalyticAA = useHWAA || hasUserStencilSettings;
}
- sk_sp<GrFragmentProcessor> clipFP;
+ std::unique_ptr<GrFragmentProcessor> clipFP;
if ((reducedClip.requiresAA() || avoidStencilBuffers) &&
get_analytic_clip_processor(reducedClip.elements(), disallowAnalyticAA, devBounds,
&clipFP)) {
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index efa8e8c..d5c82c6 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -479,8 +479,7 @@
}
if (tempProxy) {
- sk_sp<GrFragmentProcessor> fp = GrSimpleTextureEffect::Make(
- tempProxy, nullptr, SkMatrix::I());
+ auto fp = GrSimpleTextureEffect::Make(tempProxy, nullptr, SkMatrix::I());
if (premulOnGpu) {
fp = fContext->createUPMToPMEffect(std::move(fp), useConfigConversionEffect);
}
@@ -607,8 +606,7 @@
if (tempRTC) {
SkMatrix textureMatrix = SkMatrix::MakeTrans(SkIntToScalar(left), SkIntToScalar(top));
sk_sp<GrTextureProxy> proxy = src->asTextureProxyRef();
- sk_sp<GrFragmentProcessor> fp = GrSimpleTextureEffect::Make(
- std::move(proxy), nullptr, textureMatrix);
+ auto fp = GrSimpleTextureEffect::Make(std::move(proxy), nullptr, textureMatrix);
if (unpremulOnGpu) {
fp = fContext->createPMToUPMEffect(std::move(fp), useConfigConversionEffect);
// We no longer need to do this on CPU after the read back.
@@ -922,8 +920,8 @@
return fDrawingManager->wasAbandoned();
}
-sk_sp<GrFragmentProcessor> GrContext::createPMToUPMEffect(sk_sp<GrFragmentProcessor> fp,
- bool useConfigConversionEffect) {
+std::unique_ptr<GrFragmentProcessor> GrContext::createPMToUPMEffect(
+ std::unique_ptr<GrFragmentProcessor> fp, bool useConfigConversionEffect) {
ASSERT_SINGLE_OWNER
// We have specialized effects that guarantee round-trip conversion for some formats
if (useConfigConversionEffect) {
@@ -941,8 +939,8 @@
}
}
-sk_sp<GrFragmentProcessor> GrContext::createUPMToPMEffect(sk_sp<GrFragmentProcessor> fp,
- bool useConfigConversionEffect) {
+std::unique_ptr<GrFragmentProcessor> GrContext::createUPMToPMEffect(
+ std::unique_ptr<GrFragmentProcessor> fp, bool useConfigConversionEffect) {
ASSERT_SINGLE_OWNER
// We have specialized effects that guarantee round-trip conversion for these formats
if (useConfigConversionEffect) {
diff --git a/src/gpu/GrFragmentProcessor.cpp b/src/gpu/GrFragmentProcessor.cpp
index 44b14ad..060cde5 100644
--- a/src/gpu/GrFragmentProcessor.cpp
+++ b/src/gpu/GrFragmentProcessor.cpp
@@ -16,14 +16,6 @@
#include "glsl/GrGLSLProgramDataManager.h"
#include "glsl/GrGLSLUniformHandler.h"
-GrFragmentProcessor::~GrFragmentProcessor() {
- // If we got here then our ref count must have reached zero, so we will have converted refs
- // to pending executions for all children.
- for (int i = 0; i < fChildProcessors.count(); ++i) {
- fChildProcessors[i]->completedExecution();
- }
-}
-
bool GrFragmentProcessor::isEqual(const GrFragmentProcessor& that) const {
if (this->classID() != that.classID() ||
!this->hasSameSamplersAndAccesses(that)) {
@@ -75,7 +67,15 @@
return true;
}
-int GrFragmentProcessor::registerChildProcessor(sk_sp<GrFragmentProcessor> child) {
+void GrFragmentProcessor::markPendingExecution() const {
+ INHERITED::addPendingIOs();
+ INHERITED::removeRefs();
+ for (int i = 0; i < this->numChildProcessors(); ++i) {
+ this->childProcessor(i).markPendingExecution();
+ }
+}
+
+int GrFragmentProcessor::registerChildProcessor(std::unique_ptr<GrFragmentProcessor> child) {
this->combineRequiredFeatures(*child);
if (child->usesLocalCoords()) {
@@ -83,19 +83,11 @@
}
int index = fChildProcessors.count();
- fChildProcessors.push_back(child.release());
+ fChildProcessors.push_back(std::move(child));
return index;
}
-void GrFragmentProcessor::notifyRefCntIsZero() const {
- // See comment above GrProgramElement for a detailed explanation of why we do this.
- for (int i = 0; i < fChildProcessors.count(); ++i) {
- fChildProcessors[i]->addPendingExecution();
- fChildProcessors[i]->unref();
- }
-}
-
bool GrFragmentProcessor::hasSameTransforms(const GrFragmentProcessor& that) const {
if (this->numCoordTransforms() != that.numCoordTransforms()) {
return false;
@@ -109,8 +101,8 @@
return true;
}
-sk_sp<GrFragmentProcessor> GrFragmentProcessor::MulOutputByInputAlpha(
- sk_sp<GrFragmentProcessor> fp) {
+std::unique_ptr<GrFragmentProcessor> GrFragmentProcessor::MulOutputByInputAlpha(
+ std::unique_ptr<GrFragmentProcessor> fp) {
if (!fp) {
return nullptr;
}
@@ -121,13 +113,13 @@
class PremulInputFragmentProcessor : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make() {
- return sk_sp<GrFragmentProcessor>(new PremulInputFragmentProcessor);
+ static std::unique_ptr<GrFragmentProcessor> Make() {
+ return std::unique_ptr<GrFragmentProcessor>(new PremulInputFragmentProcessor);
}
const char* name() const override { return "PremultiplyInput"; }
- sk_sp<GrFragmentProcessor> clone() const override { return Make(); }
+ std::unique_ptr<GrFragmentProcessor> clone() const override { return Make(); }
private:
PremulInputFragmentProcessor()
@@ -163,13 +155,13 @@
class UnpremulInputFragmentProcessor : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make() {
- return sk_sp<GrFragmentProcessor>(new UnpremulInputFragmentProcessor);
+ static std::unique_ptr<GrFragmentProcessor> Make() {
+ return std::unique_ptr<GrFragmentProcessor>(new UnpremulInputFragmentProcessor);
}
const char* name() const override { return "UnpremultiplyInput"; }
- sk_sp<GrFragmentProcessor> clone() const override { return Make(); }
+ std::unique_ptr<GrFragmentProcessor> clone() const override { return Make(); }
private:
UnpremulInputFragmentProcessor()
@@ -206,42 +198,48 @@
}
-sk_sp<GrFragmentProcessor> GrFragmentProcessor::PremulInput(sk_sp<GrFragmentProcessor> fp) {
+std::unique_ptr<GrFragmentProcessor> GrFragmentProcessor::PremulInput(
+ std::unique_ptr<GrFragmentProcessor> fp) {
if (!fp) {
return nullptr;
}
- sk_sp<GrFragmentProcessor> fpPipeline[] = { PremulInputFragmentProcessor::Make(), fp};
+ std::unique_ptr<GrFragmentProcessor> fpPipeline[] = { PremulInputFragmentProcessor::Make(),
+ std::move(fp) };
return GrFragmentProcessor::RunInSeries(fpPipeline, 2);
}
-sk_sp<GrFragmentProcessor> GrFragmentProcessor::PremulOutput(sk_sp<GrFragmentProcessor> fp) {
+std::unique_ptr<GrFragmentProcessor> GrFragmentProcessor::PremulOutput(
+ std::unique_ptr<GrFragmentProcessor> fp) {
if (!fp) {
return nullptr;
}
- sk_sp<GrFragmentProcessor> fpPipeline[] = { fp, PremulInputFragmentProcessor::Make() };
+ std::unique_ptr<GrFragmentProcessor> fpPipeline[] = { std::move(fp),
+ PremulInputFragmentProcessor::Make() };
return GrFragmentProcessor::RunInSeries(fpPipeline, 2);
}
-sk_sp<GrFragmentProcessor> GrFragmentProcessor::UnpremulOutput(sk_sp<GrFragmentProcessor> fp) {
+std::unique_ptr<GrFragmentProcessor> GrFragmentProcessor::UnpremulOutput(
+ std::unique_ptr<GrFragmentProcessor> fp) {
if (!fp) {
return nullptr;
}
- sk_sp<GrFragmentProcessor> fpPipeline[] = { fp, UnpremulInputFragmentProcessor::Make() };
+ std::unique_ptr<GrFragmentProcessor> fpPipeline[] = { std::move(fp),
+ UnpremulInputFragmentProcessor::Make() };
return GrFragmentProcessor::RunInSeries(fpPipeline, 2);
}
-sk_sp<GrFragmentProcessor> GrFragmentProcessor::SwizzleOutput(sk_sp<GrFragmentProcessor> fp,
- const GrSwizzle& swizzle) {
+std::unique_ptr<GrFragmentProcessor> GrFragmentProcessor::SwizzleOutput(
+ std::unique_ptr<GrFragmentProcessor> fp, const GrSwizzle& swizzle) {
class SwizzleFragmentProcessor : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(const GrSwizzle& swizzle) {
- return sk_sp<GrFragmentProcessor>(new SwizzleFragmentProcessor(swizzle));
+ static std::unique_ptr<GrFragmentProcessor> Make(const GrSwizzle& swizzle) {
+ return std::unique_ptr<GrFragmentProcessor>(new SwizzleFragmentProcessor(swizzle));
}
const char* name() const override { return "Swizzle"; }
const GrSwizzle& swizzle() const { return fSwizzle; }
- sk_sp<GrFragmentProcessor> clone() const override { return Make(fSwizzle); }
+ std::unique_ptr<GrFragmentProcessor> clone() const override { return Make(fSwizzle); }
private:
SwizzleFragmentProcessor(const GrSwizzle& swizzle)
@@ -289,30 +287,32 @@
if (GrSwizzle::RGBA() == swizzle) {
return fp;
}
- sk_sp<GrFragmentProcessor> fpPipeline[] = { fp, SwizzleFragmentProcessor::Make(swizzle) };
+ std::unique_ptr<GrFragmentProcessor> fpPipeline[] = { std::move(fp),
+ SwizzleFragmentProcessor::Make(swizzle) };
return GrFragmentProcessor::RunInSeries(fpPipeline, 2);
}
-sk_sp<GrFragmentProcessor> GrFragmentProcessor::MakeInputPremulAndMulByOutput(
- sk_sp<GrFragmentProcessor> fp) {
-
+std::unique_ptr<GrFragmentProcessor> GrFragmentProcessor::MakeInputPremulAndMulByOutput(
+ std::unique_ptr<GrFragmentProcessor> fp) {
class PremulFragmentProcessor : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrFragmentProcessor> processor) {
- return sk_sp<GrFragmentProcessor>(new PremulFragmentProcessor(std::move(processor)));
+ static std::unique_ptr<GrFragmentProcessor> Make(
+ std::unique_ptr<GrFragmentProcessor> processor) {
+ return std::unique_ptr<GrFragmentProcessor>(
+ new PremulFragmentProcessor(std::move(processor)));
}
const char* name() const override { return "Premultiply"; }
- sk_sp<GrFragmentProcessor> clone() const override {
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
return Make(this->childProcessor(0).clone());
}
private:
- PremulFragmentProcessor(sk_sp<GrFragmentProcessor> processor)
+ PremulFragmentProcessor(std::unique_ptr<GrFragmentProcessor> processor)
: INHERITED(OptFlags(processor.get())) {
this->initClassID<PremulFragmentProcessor>();
- this->registerChildProcessor(processor);
+ this->registerChildProcessor(std::move(processor));
}
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
@@ -363,18 +363,19 @@
//////////////////////////////////////////////////////////////////////////////
-sk_sp<GrFragmentProcessor> GrFragmentProcessor::OverrideInput(sk_sp<GrFragmentProcessor> fp,
- GrColor4f color) {
+std::unique_ptr<GrFragmentProcessor> GrFragmentProcessor::OverrideInput(
+ std::unique_ptr<GrFragmentProcessor> fp, GrColor4f color) {
class ReplaceInputFragmentProcessor : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrFragmentProcessor> child, GrColor4f color) {
- return sk_sp<GrFragmentProcessor>(new ReplaceInputFragmentProcessor(std::move(child),
- color));
+ static std::unique_ptr<GrFragmentProcessor> Make(std::unique_ptr<GrFragmentProcessor> child,
+ GrColor4f color) {
+ return std::unique_ptr<GrFragmentProcessor>(
+ new ReplaceInputFragmentProcessor(std::move(child), color));
}
const char* name() const override { return "Replace Color"; }
- sk_sp<GrFragmentProcessor> clone() const override {
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
return Make(this->childProcessor(0).clone(), fColor);
}
@@ -411,7 +412,7 @@
return new GLFP;
}
- ReplaceInputFragmentProcessor(sk_sp<GrFragmentProcessor> child, GrColor4f color)
+ ReplaceInputFragmentProcessor(std::unique_ptr<GrFragmentProcessor> child, GrColor4f color)
: INHERITED(OptFlags(child.get(), color)), fColor(color) {
this->initClassID<ReplaceInputFragmentProcessor>();
this->registerChildProcessor(std::move(child));
@@ -451,18 +452,19 @@
return ReplaceInputFragmentProcessor::Make(std::move(fp), color);
}
-sk_sp<GrFragmentProcessor> GrFragmentProcessor::RunInSeries(sk_sp<GrFragmentProcessor>* series,
- int cnt) {
+std::unique_ptr<GrFragmentProcessor> GrFragmentProcessor::RunInSeries(
+ std::unique_ptr<GrFragmentProcessor>* series, int cnt) {
class SeriesFragmentProcessor : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrFragmentProcessor>* children, int cnt) {
- return sk_sp<GrFragmentProcessor>(new SeriesFragmentProcessor(children, cnt));
+ static std::unique_ptr<GrFragmentProcessor> Make(
+ std::unique_ptr<GrFragmentProcessor>* children, int cnt) {
+ return std::unique_ptr<GrFragmentProcessor>(new SeriesFragmentProcessor(children, cnt));
}
const char* name() const override { return "Series"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- SkSTArray<4, sk_sp<GrFragmentProcessor>> children(this->numChildProcessors());
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ SkSTArray<4, std::unique_ptr<GrFragmentProcessor>> children(this->numChildProcessors());
for (int i = 0; i < this->numChildProcessors(); ++i) {
if (!children.push_back(this->childProcessor(i).clone())) {
return nullptr;
@@ -492,7 +494,7 @@
return new GLFP;
}
- SeriesFragmentProcessor(sk_sp<GrFragmentProcessor>* children, int cnt)
+ SeriesFragmentProcessor(std::unique_ptr<GrFragmentProcessor>* children, int cnt)
: INHERITED(OptFlags(children, cnt)) {
SkASSERT(cnt > 1);
this->initClassID<SeriesFragmentProcessor>();
@@ -501,7 +503,7 @@
}
}
- static OptimizationFlags OptFlags(sk_sp<GrFragmentProcessor>* children, int cnt) {
+ static OptimizationFlags OptFlags(std::unique_ptr<GrFragmentProcessor>* children, int cnt) {
OptimizationFlags flags = kAll_OptimizationFlags;
for (int i = 0; i < cnt && flags != kNone_OptimizationFlags; ++i) {
flags &= children[i]->optimizationFlags();
@@ -527,18 +529,18 @@
return nullptr;
}
if (1 == cnt) {
- return series[0];
+ return std::move(series[0]);
}
// Run the through the series, do the invariant output processing, and look for eliminations.
GrProcessorAnalysisColor inputColor;
inputColor.setToUnknown();
- GrColorFragmentProcessorAnalysis info(inputColor, sk_sp_address_as_pointer_address(series),
+ GrColorFragmentProcessorAnalysis info(inputColor, unique_ptr_address_as_pointer_address(series),
cnt);
- SkTArray<sk_sp<GrFragmentProcessor>> replacementSeries;
+ SkTArray<std::unique_ptr<GrFragmentProcessor>> replacementSeries;
GrColor4f knownColor;
int leadingFPsToEliminate = info.initialProcessorsToEliminate(&knownColor);
if (leadingFPsToEliminate) {
- sk_sp<GrFragmentProcessor> colorFP(
+ std::unique_ptr<GrFragmentProcessor> colorFP(
GrConstColorProcessor::Make(knownColor, GrConstColorProcessor::kIgnore_InputMode));
if (leadingFPsToEliminate == cnt) {
return colorFP;
diff --git a/src/gpu/GrFragmentProcessor.h b/src/gpu/GrFragmentProcessor.h
index 0784031..29a302b 100644
--- a/src/gpu/GrFragmentProcessor.h
+++ b/src/gpu/GrFragmentProcessor.h
@@ -23,7 +23,7 @@
GrCoordTransforms to receive a transformation of the local coordinates that map from local space
to the fragment being processed.
*/
-class GrFragmentProcessor : public GrResourceIOProcessor, public GrProgramElement {
+class GrFragmentProcessor : public GrResourceIOProcessor {
public:
/**
* In many instances (e.g. SkShader::asFragmentProcessor() implementations) it is desirable to
@@ -33,7 +33,8 @@
* does so by returning a parent FP that multiplies the passed in FPs output by the parent's
* input alpha. The passed in FP will not receive an input color.
*/
- static sk_sp<GrFragmentProcessor> MulOutputByInputAlpha(sk_sp<GrFragmentProcessor>);
+ static std::unique_ptr<GrFragmentProcessor> MulOutputByInputAlpha(
+ std::unique_ptr<GrFragmentProcessor>);
/**
* This assumes that the input color to the returned processor will be unpremul and that the
@@ -41,38 +42,42 @@
* The result of the returned processor is a premul of its input color modulated by the child
* processor's premul output.
*/
- static sk_sp<GrFragmentProcessor> MakeInputPremulAndMulByOutput(sk_sp<GrFragmentProcessor>);
+ static std::unique_ptr<GrFragmentProcessor> MakeInputPremulAndMulByOutput(
+ std::unique_ptr<GrFragmentProcessor>);
/**
* Returns a parent fragment processor that adopts the passed fragment processor as a child.
* The parent will ignore its input color and instead feed the passed in color as input to the
* child.
*/
- static sk_sp<GrFragmentProcessor> OverrideInput(sk_sp<GrFragmentProcessor>, GrColor4f);
+ static std::unique_ptr<GrFragmentProcessor> OverrideInput(std::unique_ptr<GrFragmentProcessor>,
+ GrColor4f);
/**
* Returns a fragment processor that premuls the input before calling the passed in fragment
* processor.
*/
- static sk_sp<GrFragmentProcessor> PremulInput(sk_sp<GrFragmentProcessor>);
+ static std::unique_ptr<GrFragmentProcessor> PremulInput(std::unique_ptr<GrFragmentProcessor>);
/**
* Returns a fragment processor that calls the passed in fragment processor, and then premuls
* the output.
*/
- static sk_sp<GrFragmentProcessor> PremulOutput(sk_sp<GrFragmentProcessor>);
+ static std::unique_ptr<GrFragmentProcessor> PremulOutput(std::unique_ptr<GrFragmentProcessor>);
/**
* Returns a fragment processor that calls the passed in fragment processor, and then unpremuls
* the output.
*/
- static sk_sp<GrFragmentProcessor> UnpremulOutput(sk_sp<GrFragmentProcessor>);
+ static std::unique_ptr<GrFragmentProcessor> UnpremulOutput(
+ std::unique_ptr<GrFragmentProcessor>);
/**
* Returns a fragment processor that calls the passed in fragment processor, and then swizzles
* the output.
*/
- static sk_sp<GrFragmentProcessor> SwizzleOutput(sk_sp<GrFragmentProcessor>, const GrSwizzle&);
+ static std::unique_ptr<GrFragmentProcessor> SwizzleOutput(std::unique_ptr<GrFragmentProcessor>,
+ const GrSwizzle&);
/**
* Returns a fragment processor that runs the passed in array of fragment processors in a
@@ -82,15 +87,14 @@
*
* The array elements with be moved.
*/
- static sk_sp<GrFragmentProcessor> RunInSeries(sk_sp<GrFragmentProcessor>*, int cnt);
-
- ~GrFragmentProcessor() override;
+ static std::unique_ptr<GrFragmentProcessor> RunInSeries(std::unique_ptr<GrFragmentProcessor>*,
+ int cnt);
/**
* Makes a copy of this fragment processor that draws equivalently to the original.
* If the processor has child processors they are cloned as well.
*/
- virtual sk_sp<GrFragmentProcessor> clone() const = 0;
+ virtual std::unique_ptr<GrFragmentProcessor> clone() const = 0;
GrGLSLFragmentProcessor* createGLSLInstance() const;
@@ -117,6 +121,8 @@
bool instantiate(GrResourceProvider*) const;
+ void markPendingExecution() const;
+
/** Do any of the coordtransforms for this processor require local coords? */
bool usesLocalCoords() const { return SkToBool(fFlags & kUsesLocalCoords_Flag); }
@@ -309,15 +315,9 @@
* processors will allow the ProgramBuilder to automatically handle their transformed coords and
* texture accesses and mangle their uniform and output color names.
*/
- int registerChildProcessor(sk_sp<GrFragmentProcessor> child);
+ int registerChildProcessor(std::unique_ptr<GrFragmentProcessor> child);
private:
- void addPendingIOs() const override { GrResourceIOProcessor::addPendingIOs(); }
- void removeRefs() const override { GrResourceIOProcessor::removeRefs(); }
- void pendingIOComplete() const override { GrResourceIOProcessor::pendingIOComplete(); }
-
- void notifyRefCntIsZero() const final;
-
virtual GrColor4f constantOutputForConstantInput(GrColor4f /* inputColor */) const {
SkFAIL("Subclass must override this if advertising this optimization.");
return GrColor4f::TransparentBlack();
@@ -350,11 +350,7 @@
SkSTArray<4, const GrCoordTransform*, true> fCoordTransforms;
- /**
- * This is not SkSTArray<1, sk_sp<GrFragmentProcessor>> because this class holds strong
- * references until notifyRefCntIsZero and then it holds pending executions.
- */
- SkSTArray<1, GrFragmentProcessor*, true> fChildProcessors;
+ SkSTArray<1, std::unique_ptr<GrFragmentProcessor>, true> fChildProcessors;
typedef GrResourceIOProcessor INHERITED;
};
diff --git a/src/gpu/GrPaint.h b/src/gpu/GrPaint.h
index 1ab01f3..ae19cad 100644
--- a/src/gpu/GrPaint.h
+++ b/src/gpu/GrPaint.h
@@ -91,7 +91,7 @@
/**
* Appends an additional color processor to the color computation.
*/
- void addColorFragmentProcessor(sk_sp<GrFragmentProcessor> fp) {
+ void addColorFragmentProcessor(std::unique_ptr<GrFragmentProcessor> fp) {
SkASSERT(fp);
fColorFragmentProcessors.push_back(std::move(fp));
fTrivial = false;
@@ -100,7 +100,7 @@
/**
* Appends an additional coverage processor to the coverage computation.
*/
- void addCoverageFragmentProcessor(sk_sp<GrFragmentProcessor> fp) {
+ void addCoverageFragmentProcessor(std::unique_ptr<GrFragmentProcessor> fp) {
SkASSERT(fp);
fCoverageFragmentProcessors.push_back(std::move(fp));
fTrivial = false;
@@ -157,8 +157,8 @@
friend class GrProcessorSet;
const GrXPFactory* fXPFactory = nullptr;
- SkSTArray<4, sk_sp<GrFragmentProcessor>> fColorFragmentProcessors;
- SkSTArray<2, sk_sp<GrFragmentProcessor>> fCoverageFragmentProcessors;
+ SkSTArray<4, std::unique_ptr<GrFragmentProcessor>> fColorFragmentProcessors;
+ SkSTArray<2, std::unique_ptr<GrFragmentProcessor>> fCoverageFragmentProcessors;
bool fDisableOutputConversionToSRGB = false;
bool fAllowSRGBInputs = false;
bool fTrivial = true;
diff --git a/src/gpu/GrPipeline.cpp b/src/gpu/GrPipeline.cpp
index a6e8fba..d07dd08 100644
--- a/src/gpu/GrPipeline.cpp
+++ b/src/gpu/GrPipeline.cpp
@@ -58,22 +58,20 @@
fFragmentProcessors.reset(numTotalProcessors);
int currFPIdx = 0;
for (int i = 0; i < processors.numColorFragmentProcessors(); ++i, ++currFPIdx) {
- const GrFragmentProcessor* fp = processors.colorFragmentProcessor(i);
- fFragmentProcessors[currFPIdx].reset(fp);
- if (!fp->instantiate(args.fResourceProvider)) {
+ fFragmentProcessors[currFPIdx] = processors.detachColorFragmentProcessor(i);
+ if (!fFragmentProcessors[currFPIdx]->instantiate(args.fResourceProvider)) {
this->markAsBad();
}
}
for (int i = 0; i < processors.numCoverageFragmentProcessors(); ++i, ++currFPIdx) {
- const GrFragmentProcessor* fp = processors.coverageFragmentProcessor(i);
- fFragmentProcessors[currFPIdx].reset(fp);
- if (!fp->instantiate(args.fResourceProvider)) {
+ fFragmentProcessors[currFPIdx] = processors.detachCoverageFragmentProcessor(i);
+ if (!fFragmentProcessors[currFPIdx]->instantiate(args.fResourceProvider)) {
this->markAsBad();
}
}
if (clipFP) {
- fFragmentProcessors[currFPIdx].reset(clipFP.get());
+ fFragmentProcessors[currFPIdx] = std::move(clipFP);
if (!fFragmentProcessors[currFPIdx]->instantiate(args.fResourceProvider)) {
this->markAsBad();
}
diff --git a/src/gpu/GrPipeline.h b/src/gpu/GrPipeline.h
index 7583c6c..c431995 100644
--- a/src/gpu/GrPipeline.h
+++ b/src/gpu/GrPipeline.h
@@ -230,8 +230,7 @@
using RenderTargetProxy = GrPendingIOResource<GrRenderTargetProxy, kWrite_GrIOType>;
using DstTextureProxy = GrPendingIOResource<GrTextureProxy, kRead_GrIOType>;
- using PendingFragmentProcessor = GrPendingProgramElement<const GrFragmentProcessor>;
- using FragmentProcessorArray = SkAutoSTArray<8, PendingFragmentProcessor>;
+ using FragmentProcessorArray = SkAutoSTArray<8, std::unique_ptr<const GrFragmentProcessor>>;
DstTextureProxy fDstTextureProxy;
SkIPoint fDstTextureOffset;
diff --git a/src/gpu/GrProcessorSet.cpp b/src/gpu/GrProcessorSet.cpp
index 20d6745..cb4a25f 100644
--- a/src/gpu/GrProcessorSet.cpp
+++ b/src/gpu/GrProcessorSet.cpp
@@ -29,11 +29,11 @@
int i = 0;
for (auto& fp : paint.fColorFragmentProcessors) {
SkASSERT(fp.get());
- fFragmentProcessors[i++] = fp.release();
+ fFragmentProcessors[i++] = std::move(fp);
}
for (auto& fp : paint.fCoverageFragmentProcessors) {
SkASSERT(fp.get());
- fFragmentProcessors[i++] = fp.release();
+ fFragmentProcessors[i++] = std::move(fp);
}
} else {
SkDebugf("Insane number of color fragment processors in paint. Dropping all processors.");
@@ -47,14 +47,14 @@
, fFragmentProcessorOffset(0)
, fFlags(0) {}
-GrProcessorSet::GrProcessorSet(sk_sp<GrFragmentProcessor> colorFP)
+GrProcessorSet::GrProcessorSet(std::unique_ptr<GrFragmentProcessor> colorFP)
: fFragmentProcessors(1)
, fXP((const GrXPFactory*)nullptr)
, fColorFragmentProcessorCnt(1)
, fFragmentProcessorOffset(0)
, fFlags(0) {
SkASSERT(colorFP);
- fFragmentProcessors[0] = colorFP.release();
+ fFragmentProcessors[0] = std::move(colorFP);
}
GrProcessorSet::GrProcessorSet(GrProcessorSet&& that)
@@ -64,20 +64,14 @@
, fFlags(that.fFlags) {
fFragmentProcessors.reset(that.fFragmentProcessors.count() - that.fFragmentProcessorOffset);
for (int i = 0; i < fFragmentProcessors.count(); ++i) {
- fFragmentProcessors[i] = that.fFragmentProcessors[i + that.fFragmentProcessorOffset];
+ fFragmentProcessors[i] =
+ std::move(that.fFragmentProcessors[i + that.fFragmentProcessorOffset]);
}
that.fColorFragmentProcessorCnt = 0;
that.fFragmentProcessors.reset(0);
}
GrProcessorSet::~GrProcessorSet() {
- for (int i = fFragmentProcessorOffset; i < fFragmentProcessors.count(); ++i) {
- if (this->isFinalized()) {
- fFragmentProcessors[i]->completedExecution();
- } else {
- fFragmentProcessors[i]->unref();
- }
- }
if (this->isFinalized() && this->xferProcessor()) {
this->xferProcessor()->unref();
}
@@ -173,8 +167,10 @@
analysis.fCompatibleWithCoverageAsAlpha = GrProcessorAnalysisCoverage::kLCD != coverageInput;
const GrFragmentProcessor* clipFP = clip ? clip->clipCoverageFragmentProcessor() : nullptr;
- const GrFragmentProcessor* const* fps = fFragmentProcessors.get() + fFragmentProcessorOffset;
- GrColorFragmentProcessorAnalysis colorAnalysis(colorInput, fps, fColorFragmentProcessorCnt);
+ const std::unique_ptr<const GrFragmentProcessor>* fps =
+ fFragmentProcessors.get() + fFragmentProcessorOffset;
+ GrColorFragmentProcessorAnalysis colorAnalysis(
+ colorInput, unique_ptr_address_as_pointer_address(fps), fColorFragmentProcessorCnt);
analysis.fCompatibleWithCoverageAsAlpha &=
colorAnalysis.allProcessorsCompatibleWithCoverageAsAlpha();
fps += fColorFragmentProcessorCnt;
@@ -236,12 +232,10 @@
analysis.fUsesLocalCoords = coverageUsesLocalCoords | colorAnalysis.usesLocalCoords();
}
for (int i = 0; i < colorFPsToEliminate; ++i) {
- fFragmentProcessors[i]->unref();
- fFragmentProcessors[i] = nullptr;
+ fFragmentProcessors[i].reset(nullptr);
}
for (int i = colorFPsToEliminate; i < fFragmentProcessors.count(); ++i) {
- fFragmentProcessors[i]->addPendingExecution();
- fFragmentProcessors[i]->unref();
+ fFragmentProcessors[i]->markPendingExecution();
}
fFragmentProcessorOffset = colorFPsToEliminate;
fColorFragmentProcessorCnt -= colorFPsToEliminate;
diff --git a/src/gpu/GrProcessorSet.h b/src/gpu/GrProcessorSet.h
index d3aaf6d..023c4df 100644
--- a/src/gpu/GrProcessorSet.h
+++ b/src/gpu/GrProcessorSet.h
@@ -25,7 +25,7 @@
public:
GrProcessorSet(GrPaint&&);
GrProcessorSet(SkBlendMode);
- GrProcessorSet(sk_sp<GrFragmentProcessor> colorFP);
+ GrProcessorSet(std::unique_ptr<GrFragmentProcessor> colorFP);
GrProcessorSet(GrProcessorSet&&);
GrProcessorSet(const GrProcessorSet&) = delete;
GrProcessorSet& operator=(const GrProcessorSet&) = delete;
@@ -42,10 +42,11 @@
const GrFragmentProcessor* colorFragmentProcessor(int idx) const {
SkASSERT(idx < fColorFragmentProcessorCnt);
- return fFragmentProcessors[idx + fFragmentProcessorOffset];
+ return fFragmentProcessors[idx + fFragmentProcessorOffset].get();
}
const GrFragmentProcessor* coverageFragmentProcessor(int idx) const {
- return fFragmentProcessors[idx + fColorFragmentProcessorCnt + fFragmentProcessorOffset];
+ return fFragmentProcessors[idx + fColorFragmentProcessorCnt +
+ fFragmentProcessorOffset].get();
}
const GrXferProcessor* xferProcessor() const {
@@ -57,6 +58,16 @@
return sk_ref_sp(fXP.fProcessor);
}
+ std::unique_ptr<const GrFragmentProcessor> detachColorFragmentProcessor(int idx) {
+ SkASSERT(idx < fColorFragmentProcessorCnt);
+ return std::move(fFragmentProcessors[idx + fFragmentProcessorOffset]);
+ }
+
+ std::unique_ptr<const GrFragmentProcessor> detachCoverageFragmentProcessor(int idx) {
+ return std::move(
+ fFragmentProcessors[idx + fFragmentProcessorOffset + fColorFragmentProcessorCnt]);
+ }
+
/** Comparisons are only legal on finalized processor sets. */
bool operator==(const GrProcessorSet& that) const;
bool operator!=(const GrProcessorSet& that) const { return !(*this == that); }
@@ -168,7 +179,7 @@
return fXP.fFactory;
}
- SkAutoSTArray<4, const GrFragmentProcessor*> fFragmentProcessors;
+ SkAutoSTArray<4, std::unique_ptr<const GrFragmentProcessor>> fFragmentProcessors;
XP fXP;
uint8_t fColorFragmentProcessorCnt = 0;
uint8_t fFragmentProcessorOffset = 0;
diff --git a/src/gpu/GrProcessorUnitTest.cpp b/src/gpu/GrProcessorUnitTest.cpp
index 563fd7c..473903d 100644
--- a/src/gpu/GrProcessorUnitTest.cpp
+++ b/src/gpu/GrProcessorUnitTest.cpp
@@ -10,9 +10,9 @@
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrProcessorUnitTest::MakeChildFP(GrProcessorTestData* data) {
+std::unique_ptr<GrFragmentProcessor> GrProcessorUnitTest::MakeChildFP(GrProcessorTestData* data) {
#if SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
- sk_sp<GrFragmentProcessor> fp;
+ std::unique_ptr<GrFragmentProcessor> fp;
do {
fp = GrFragmentProcessorTestFactory::Make(data);
SkASSERT(fp);
diff --git a/src/gpu/GrProcessorUnitTest.h b/src/gpu/GrProcessorUnitTest.h
index 73a2cf3..739b2f0 100644
--- a/src/gpu/GrProcessorUnitTest.h
+++ b/src/gpu/GrProcessorUnitTest.h
@@ -35,7 +35,7 @@
/** This allows parent FPs to implement a test create with known leaf children in order to avoid
creating an unbounded FP tree which may overflow various shader limits. */
-sk_sp<GrFragmentProcessor> MakeChildFP(GrProcessorTestData*);
+std::unique_ptr<GrFragmentProcessor> MakeChildFP(GrProcessorTestData*);
}
@@ -117,7 +117,7 @@
static SkTArray<GrProcessorTestFactory<ProcessorSmartPtr>*, true>* GetFactories();
};
-using GrFragmentProcessorTestFactory = GrProcessorTestFactory<sk_sp<GrFragmentProcessor>>;
+using GrFragmentProcessorTestFactory = GrProcessorTestFactory<std::unique_ptr<GrFragmentProcessor>>;
using GrGeometryProcessorTestFactory = GrProcessorTestFactory<sk_sp<GrGeometryProcessor>>;
class GrXPFactoryTestFactory : private SkNoncopyable {
@@ -151,7 +151,7 @@
#define GR_DECLARE_FRAGMENT_PROCESSOR_TEST \
static GrFragmentProcessorTestFactory gTestFactory SK_UNUSED; \
- static sk_sp<GrFragmentProcessor> TestCreate(GrProcessorTestData*);
+ static std::unique_ptr<GrFragmentProcessor> TestCreate(GrProcessorTestData*);
#define GR_DECLARE_XP_FACTORY_TEST \
static GrXPFactoryTestFactory gTestFactory SK_UNUSED; \
@@ -175,7 +175,7 @@
// The unit test relies on static initializers. Just declare the TestCreate function so that
// its definitions will compile.
#define GR_DECLARE_FRAGMENT_PROCESSOR_TEST \
- static sk_sp<GrFragmentProcessor> TestCreate(GrProcessorTestData*);
+ static std::unique_ptr<GrFragmentProcessor> TestCreate(GrProcessorTestData*);
#define GR_DEFINE_FRAGMENT_PROCESSOR_TEST(X)
// The unit test relies on static initializers. Just declare the TestCreate function so that
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index 10f21e8..03b120c 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -1205,12 +1205,12 @@
}
// TODO these need to be a geometry processors
- sk_sp<GrFragmentProcessor> innerEffect(GrRRectEffect::Make(innerEdgeType, *inner));
+ std::unique_ptr<GrFragmentProcessor> innerEffect(GrRRectEffect::Make(innerEdgeType, *inner));
if (!innerEffect) {
return false;
}
- sk_sp<GrFragmentProcessor> outerEffect(GrRRectEffect::Make(outerEdgeType, *outer));
+ std::unique_ptr<GrFragmentProcessor> outerEffect(GrRRectEffect::Make(outerEdgeType, *outer));
if (!outerEffect) {
return false;
}
diff --git a/src/gpu/GrRenderTargetContext.h b/src/gpu/GrRenderTargetContext.h
index 2b9308a..33a9d8b 100644
--- a/src/gpu/GrRenderTargetContext.h
+++ b/src/gpu/GrRenderTargetContext.h
@@ -390,8 +390,8 @@
friend class GrCCPRAtlas; // for access to addDrawOp
friend class GrCoverageCountingPathRenderer; // for access to addDrawOp
// for a unit test
- friend void test_draw_op(GrRenderTargetContext*,
- sk_sp<GrFragmentProcessor>, sk_sp<GrTextureProxy>);
+ friend void test_draw_op(GrRenderTargetContext*, std::unique_ptr<GrFragmentProcessor>,
+ sk_sp<GrTextureProxy>);
void internalClear(const GrFixedClip&, const GrColor, bool canIgnoreClip);
diff --git a/src/gpu/GrTextureAdjuster.cpp b/src/gpu/GrTextureAdjuster.cpp
index 166cb9d..546ea67 100644
--- a/src/gpu/GrTextureAdjuster.cpp
+++ b/src/gpu/GrTextureAdjuster.cpp
@@ -105,14 +105,13 @@
return copy;
}
-sk_sp<GrFragmentProcessor> GrTextureAdjuster::createFragmentProcessor(
- const SkMatrix& origTextureMatrix,
- const SkRect& origConstraintRect,
- FilterConstraint filterConstraint,
- bool coordsLimitedToConstraintRect,
- const GrSamplerParams::FilterMode* filterOrNullForBicubic,
- SkColorSpace* dstColorSpace) {
-
+std::unique_ptr<GrFragmentProcessor> GrTextureAdjuster::createFragmentProcessor(
+ const SkMatrix& origTextureMatrix,
+ const SkRect& origConstraintRect,
+ FilterConstraint filterConstraint,
+ bool coordsLimitedToConstraintRect,
+ const GrSamplerParams::FilterMode* filterOrNullForBicubic,
+ SkColorSpace* dstColorSpace) {
SkMatrix textureMatrix = origTextureMatrix;
const SkIRect* contentArea = this->contentAreaOrNull();
// Convert the constraintRect to be relative to the texture rather than the content area so
diff --git a/src/gpu/GrTextureAdjuster.h b/src/gpu/GrTextureAdjuster.h
index eb500f7..fad533f 100644
--- a/src/gpu/GrTextureAdjuster.h
+++ b/src/gpu/GrTextureAdjuster.h
@@ -27,13 +27,13 @@
sk_sp<GrTextureProxy> refTextureProxySafeForParams(const GrSamplerParams&, SkIPoint* outOffset,
SkScalar scaleAdjust[2]);
- sk_sp<GrFragmentProcessor> createFragmentProcessor(
- const SkMatrix& textureMatrix,
- const SkRect& constraintRect,
- FilterConstraint,
- bool coordsLimitedToConstraintRect,
- const GrSamplerParams::FilterMode* filterOrNullForBicubic,
- SkColorSpace* dstColorSpace) override;
+ std::unique_ptr<GrFragmentProcessor> createFragmentProcessor(
+ const SkMatrix& textureMatrix,
+ const SkRect& constraintRect,
+ FilterConstraint,
+ bool coordsLimitedToConstraintRect,
+ const GrSamplerParams::FilterMode* filterOrNullForBicubic,
+ SkColorSpace* dstColorSpace) override;
// We do not ref the texture nor the colorspace, so the caller must keep them in scope while
// this Adjuster is alive.
diff --git a/src/gpu/GrTextureMaker.cpp b/src/gpu/GrTextureMaker.cpp
index 2962ddb..7e257d8 100644
--- a/src/gpu/GrTextureMaker.cpp
+++ b/src/gpu/GrTextureMaker.cpp
@@ -76,14 +76,13 @@
return result;
}
-sk_sp<GrFragmentProcessor> GrTextureMaker::createFragmentProcessor(
- const SkMatrix& textureMatrix,
- const SkRect& constraintRect,
- FilterConstraint filterConstraint,
- bool coordsLimitedToConstraintRect,
- const GrSamplerParams::FilterMode* filterOrNullForBicubic,
- SkColorSpace* dstColorSpace) {
-
+std::unique_ptr<GrFragmentProcessor> GrTextureMaker::createFragmentProcessor(
+ const SkMatrix& textureMatrix,
+ const SkRect& constraintRect,
+ FilterConstraint filterConstraint,
+ bool coordsLimitedToConstraintRect,
+ const GrSamplerParams::FilterMode* filterOrNullForBicubic,
+ SkColorSpace* dstColorSpace) {
const GrSamplerParams::FilterMode* fmForDetermineDomain = filterOrNullForBicubic;
if (filterOrNullForBicubic && GrSamplerParams::kMipMap_FilterMode == *filterOrNullForBicubic &&
kYes_FilterConstraint == filterConstraint) {
diff --git a/src/gpu/GrTextureMaker.h b/src/gpu/GrTextureMaker.h
index 9e1e0dd..5055a8a 100644
--- a/src/gpu/GrTextureMaker.h
+++ b/src/gpu/GrTextureMaker.h
@@ -30,13 +30,13 @@
sk_sp<SkColorSpace>* texColorSpace,
SkScalar scaleAdjust[2]);
- sk_sp<GrFragmentProcessor> createFragmentProcessor(
- const SkMatrix& textureMatrix,
- const SkRect& constraintRect,
- FilterConstraint filterConstraint,
- bool coordsLimitedToConstraintRect,
- const GrSamplerParams::FilterMode* filterOrNullForBicubic,
- SkColorSpace* dstColorSpace) override;
+ std::unique_ptr<GrFragmentProcessor> createFragmentProcessor(
+ const SkMatrix& textureMatrix,
+ const SkRect& constraintRect,
+ FilterConstraint filterConstraint,
+ bool coordsLimitedToConstraintRect,
+ const GrSamplerParams::FilterMode* filterOrNullForBicubic,
+ SkColorSpace* dstColorSpace) override;
protected:
GrTextureMaker(GrContext* context, int width, int height, bool isAlphaOnly)
diff --git a/src/gpu/GrTextureProducer.cpp b/src/gpu/GrTextureProducer.cpp
index 78d143b..9273223 100644
--- a/src/gpu/GrTextureProducer.cpp
+++ b/src/gpu/GrTextureProducer.cpp
@@ -218,13 +218,13 @@
return kDomain_DomainMode;
}
-sk_sp<GrFragmentProcessor> GrTextureProducer::CreateFragmentProcessorForDomainAndFilter(
- sk_sp<GrTextureProxy> proxy,
- sk_sp<GrColorSpaceXform> colorSpaceXform,
- const SkMatrix& textureMatrix,
- DomainMode domainMode,
- const SkRect& domain,
- const GrSamplerParams::FilterMode* filterOrNullForBicubic) {
+std::unique_ptr<GrFragmentProcessor> GrTextureProducer::CreateFragmentProcessorForDomainAndFilter(
+ sk_sp<GrTextureProxy> proxy,
+ sk_sp<GrColorSpaceXform> colorSpaceXform,
+ const SkMatrix& textureMatrix,
+ DomainMode domainMode,
+ const SkRect& domain,
+ const GrSamplerParams::FilterMode* filterOrNullForBicubic) {
SkASSERT(kTightCopy_DomainMode != domainMode);
if (filterOrNullForBicubic) {
if (kDomain_DomainMode == domainMode) {
diff --git a/src/gpu/GrTextureProducer.h b/src/gpu/GrTextureProducer.h
index 6a32e2f..ccc0dae 100644
--- a/src/gpu/GrTextureProducer.h
+++ b/src/gpu/GrTextureProducer.h
@@ -56,13 +56,13 @@
* @param filterOrNullForBicubic If non-null indicates the filter mode. If null means
* use bicubic filtering.
**/
- virtual sk_sp<GrFragmentProcessor> createFragmentProcessor(
- const SkMatrix& textureMatrix,
- const SkRect& constraintRect,
- FilterConstraint filterConstraint,
- bool coordsLimitedToConstraintRect,
- const GrSamplerParams::FilterMode* filterOrNullForBicubic,
- SkColorSpace* dstColorSpace) = 0;
+ virtual std::unique_ptr<GrFragmentProcessor> createFragmentProcessor(
+ const SkMatrix& textureMatrix,
+ const SkRect& constraintRect,
+ FilterConstraint filterConstraint,
+ bool coordsLimitedToConstraintRect,
+ const GrSamplerParams::FilterMode* filterOrNullForBicubic,
+ SkColorSpace* dstColorSpace) = 0;
virtual ~GrTextureProducer() {}
@@ -130,13 +130,13 @@
const GrSamplerParams::FilterMode* filterModeOrNullForBicubic,
SkRect* domainRect);
- static sk_sp<GrFragmentProcessor> CreateFragmentProcessorForDomainAndFilter(
- sk_sp<GrTextureProxy> proxy,
- sk_sp<GrColorSpaceXform>,
- const SkMatrix& textureMatrix,
- DomainMode,
- const SkRect& domain,
- const GrSamplerParams::FilterMode* filterOrNullForBicubic);
+ static std::unique_ptr<GrFragmentProcessor> CreateFragmentProcessorForDomainAndFilter(
+ sk_sp<GrTextureProxy> proxy,
+ sk_sp<GrColorSpaceXform>,
+ const SkMatrix& textureMatrix,
+ DomainMode,
+ const SkRect& domain,
+ const GrSamplerParams::FilterMode* filterOrNullForBicubic);
private:
const int fWidth;
diff --git a/src/gpu/GrYUVProvider.cpp b/src/gpu/GrYUVProvider.cpp
index 12390aa..6b58d42 100644
--- a/src/gpu/GrYUVProvider.cpp
+++ b/src/gpu/GrYUVProvider.cpp
@@ -134,11 +134,11 @@
}
GrPaint paint;
- sk_sp<GrFragmentProcessor> yuvToRgbProcessor(
- GrYUVEffect::MakeYUVToRGB(yuvTextureContexts[0]->asTextureProxyRef(),
- yuvTextureContexts[1]->asTextureProxyRef(),
- yuvTextureContexts[2]->asTextureProxyRef(),
- yuvInfo.fSizeInfo.fSizes, yuvInfo.fColorSpace, false));
+ auto yuvToRgbProcessor =
+ GrYUVEffect::MakeYUVToRGB(yuvTextureContexts[0]->asTextureProxyRef(),
+ yuvTextureContexts[1]->asTextureProxyRef(),
+ yuvTextureContexts[2]->asTextureProxyRef(),
+ yuvInfo.fSizeInfo.fSizes, yuvInfo.fColorSpace, false);
paint.addColorFragmentProcessor(std::move(yuvToRgbProcessor));
// If we're decoding an sRGB image, the result of our linear math on the YUV planes is already
@@ -158,10 +158,10 @@
// If the caller expects the pixels in a different color space than the one from the image,
// apply a color conversion to do this.
- sk_sp<GrFragmentProcessor> colorConversionProcessor =
+ std::unique_ptr<GrFragmentProcessor> colorConversionProcessor =
GrNonlinearColorSpaceXformEffect::Make(srcColorSpace, dstColorSpace);
if (colorConversionProcessor) {
- paint.addColorFragmentProcessor(colorConversionProcessor);
+ paint.addColorFragmentProcessor(std::move(colorConversionProcessor));
}
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 607165c..b0ca549 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -1028,7 +1028,7 @@
// Construct a GrPaint by setting the bitmap texture as the first effect and then configuring
// the rest from the SkPaint.
- sk_sp<GrFragmentProcessor> fp;
+ std::unique_ptr<GrFragmentProcessor> fp;
if (needsTextureDomain && (SkCanvas::kStrict_SrcRectConstraint == constraint)) {
// Use a constrained texture domain to avoid color bleeding
@@ -1132,9 +1132,8 @@
sk_sp<GrColorSpaceXform> colorSpaceXform =
GrColorSpaceXform::Make(result->getColorSpace(), fRenderTargetContext->getColorSpace());
- sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(std::move(proxy),
- std::move(colorSpaceXform),
- SkMatrix::I()));
+ auto fp = GrSimpleTextureEffect::Make(std::move(proxy), std::move(colorSpaceXform),
+ SkMatrix::I());
if (GrPixelConfigIsAlphaOnly(config)) {
fp = GrFragmentProcessor::MakeInputPremulAndMulByOutput(std::move(fp));
} else {
@@ -1416,11 +1415,10 @@
}
static const GrSamplerParams::FilterMode kMode = GrSamplerParams::kNone_FilterMode;
- sk_sp<GrFragmentProcessor> fp(
- producer->createFragmentProcessor(SkMatrix::I(),
- SkRect::MakeIWH(producer->width(), producer->height()),
- GrTextureProducer::kNo_FilterConstraint, true,
- &kMode, fRenderTargetContext->getColorSpace()));
+ auto fp = producer->createFragmentProcessor(
+ SkMatrix::I(), SkRect::MakeIWH(producer->width(), producer->height()),
+ GrTextureProducer::kNo_FilterConstraint, true, &kMode,
+ fRenderTargetContext->getColorSpace());
if (!fp) {
return;
}
@@ -1474,11 +1472,10 @@
CHECK_SHOULD_DRAW();
static const GrSamplerParams::FilterMode kMode = GrSamplerParams::kNone_FilterMode;
- sk_sp<GrFragmentProcessor> fp(
- producer->createFragmentProcessor(SkMatrix::I(),
- SkRect::MakeIWH(producer->width(), producer->height()),
- GrTextureProducer::kNo_FilterConstraint, true,
- &kMode, fRenderTargetContext->getColorSpace()));
+ std::unique_ptr<GrFragmentProcessor> fp(producer->createFragmentProcessor(
+ SkMatrix::I(), SkRect::MakeIWH(producer->width(), producer->height()),
+ GrTextureProducer::kNo_FilterConstraint, true, &kMode,
+ fRenderTargetContext->getColorSpace()));
if (!fp) {
return;
}
diff --git a/src/gpu/SkGpuDevice_drawTexture.cpp b/src/gpu/SkGpuDevice_drawTexture.cpp
index 48015a3..6fa1711 100644
--- a/src/gpu/SkGpuDevice_drawTexture.cpp
+++ b/src/gpu/SkGpuDevice_drawTexture.cpp
@@ -201,16 +201,16 @@
}
textureMatrix = &tempMatrix;
}
- sk_sp<GrFragmentProcessor> fp(producer->createFragmentProcessor(
- *textureMatrix, clippedSrcRect, constraintMode, coordsAllInsideSrcRect, filterMode,
- fRenderTargetContext->getColorSpace()));
+ auto fp = producer->createFragmentProcessor(*textureMatrix, clippedSrcRect, constraintMode,
+ coordsAllInsideSrcRect, filterMode,
+ fRenderTargetContext->getColorSpace());
if (!fp) {
return;
}
GrPaint grPaint;
if (!SkPaintToGrPaintWithTexture(fContext.get(), fRenderTargetContext.get(), paint, viewMatrix,
- fp, producer->isAlphaOnly(), &grPaint)) {
+ std::move(fp), producer->isAlphaOnly(), &grPaint)) {
return;
}
GrAA aa = GrBoolToAA(paint.isAntiAlias());
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index e426b95..c1fb262 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -404,7 +404,7 @@
GrRenderTargetContext* rtc,
const SkPaint& skPaint,
const SkMatrix& viewM,
- sk_sp<GrFragmentProcessor>* shaderProcessor,
+ std::unique_ptr<GrFragmentProcessor>* shaderProcessor,
SkBlendMode* primColorMode,
GrPaint* grPaint) {
grPaint->setAllowSRGBInputs(rtc->isGammaCorrect());
@@ -415,10 +415,10 @@
// Setup the initial color considering the shader, the SkPaint color, and the presence or not
// of per-vertex colors.
- sk_sp<GrFragmentProcessor> shaderFP;
+ std::unique_ptr<GrFragmentProcessor> shaderFP;
if (!primColorMode || blend_requires_shader(*primColorMode)) {
if (shaderProcessor) {
- shaderFP = *shaderProcessor;
+ shaderFP = std::move(*shaderProcessor);
} else if (const auto* shader = as_SB(skPaint.getShader())) {
shaderFP = shader->asFragmentProcessor(
SkShaderBase::AsFPArgs(context, &viewM, nullptr, skPaint.getFilterQuality(),
@@ -443,7 +443,7 @@
// the GrPaint color will be ignored.
GrColor4f shaderInput = origColor.opaque();
- shaderFP = GrFragmentProcessor::OverrideInput(shaderFP, shaderInput);
+ shaderFP = GrFragmentProcessor::OverrideInput(std::move(shaderFP), shaderInput);
shaderFP = GrXfermodeFragmentProcessor::MakeFromSrcProcessor(std::move(shaderFP),
*primColorMode);
@@ -470,9 +470,8 @@
if (primColorMode) {
// There is a blend between the primitive color and the paint color. The blend considers
// the opaque paint color. The paint's alpha is applied to the post-blended color.
- sk_sp<GrFragmentProcessor> processor(
- GrConstColorProcessor::Make(origColor.opaque(),
- GrConstColorProcessor::kIgnore_InputMode));
+ auto processor = GrConstColorProcessor::Make(origColor.opaque(),
+ GrConstColorProcessor::kIgnore_InputMode);
processor = GrXfermodeFragmentProcessor::MakeFromSrcProcessor(std::move(processor),
*primColorMode);
if (processor) {
@@ -510,8 +509,7 @@
colorFilter->filterColor(skPaint.getColor()), nullptr, nullptr));
}
} else {
- sk_sp<GrFragmentProcessor> cfFP(colorFilter->asFragmentProcessor(context,
- rtc->getColorSpace()));
+ auto cfFP = colorFilter->asFragmentProcessor(context, rtc->getColorSpace());
if (cfFP) {
grPaint->addColorFragmentProcessor(std::move(cfFP));
} else {
@@ -524,7 +522,7 @@
if (maskFilter) {
GrFragmentProcessor* mfFP;
if (maskFilter->asFragmentProcessor(&mfFP)) {
- grPaint->addCoverageFragmentProcessor(sk_sp<GrFragmentProcessor>(mfFP));
+ grPaint->addCoverageFragmentProcessor(std::unique_ptr<GrFragmentProcessor>(mfFP));
}
}
@@ -559,7 +557,7 @@
bool SkPaintToGrPaintReplaceShader(GrContext* context,
GrRenderTargetContext* rtc,
const SkPaint& skPaint,
- sk_sp<GrFragmentProcessor> shaderFP,
+ std::unique_ptr<GrFragmentProcessor> shaderFP,
GrPaint* grPaint) {
if (!shaderFP) {
return false;
@@ -574,8 +572,8 @@
const SkPaint& skPaint,
GrPaint* grPaint) {
// Use a ptr to a nullptr to to indicate that the SkShader is ignored and not replaced.
- static sk_sp<GrFragmentProcessor> kNullShaderFP(nullptr);
- static sk_sp<GrFragmentProcessor>* kIgnoreShader = &kNullShaderFP;
+ static std::unique_ptr<GrFragmentProcessor> kNullShaderFP(nullptr);
+ static std::unique_ptr<GrFragmentProcessor>* kIgnoreShader = &kNullShaderFP;
return skpaint_to_grpaint_impl(context, rtc, skPaint, SkMatrix::I(), kIgnoreShader, nullptr,
grPaint);
}
@@ -596,10 +594,10 @@
GrRenderTargetContext* rtc,
const SkPaint& paint,
const SkMatrix& viewM,
- sk_sp<GrFragmentProcessor> fp,
+ std::unique_ptr<GrFragmentProcessor> fp,
bool textureIsAlphaOnly,
GrPaint* grPaint) {
- sk_sp<GrFragmentProcessor> shaderFP;
+ std::unique_ptr<GrFragmentProcessor> shaderFP;
if (textureIsAlphaOnly) {
if (const auto* shader = as_SB(paint.getShader())) {
shaderFP = shader->asFragmentProcessor(
@@ -608,13 +606,13 @@
if (!shaderFP) {
return false;
}
- sk_sp<GrFragmentProcessor> fpSeries[] = { std::move(shaderFP), std::move(fp) };
+ std::unique_ptr<GrFragmentProcessor> fpSeries[] = { std::move(shaderFP), std::move(fp) };
shaderFP = GrFragmentProcessor::RunInSeries(fpSeries, 2);
} else {
- shaderFP = GrFragmentProcessor::MakeInputPremulAndMulByOutput(fp);
+ shaderFP = GrFragmentProcessor::MakeInputPremulAndMulByOutput(std::move(fp));
}
} else {
- shaderFP = GrFragmentProcessor::MulOutputByInputAlpha(fp);
+ shaderFP = GrFragmentProcessor::MulOutputByInputAlpha(std::move(fp));
}
return SkPaintToGrPaintReplaceShader(context, rtc, paint, std::move(shaderFP), grPaint);
diff --git a/src/gpu/SkGr.h b/src/gpu/SkGr.h
index 1f7f2ad..126dc4c 100644
--- a/src/gpu/SkGr.h
+++ b/src/gpu/SkGr.h
@@ -115,7 +115,7 @@
bool SkPaintToGrPaintReplaceShader(GrContext*,
GrRenderTargetContext*,
const SkPaint& skPaint,
- sk_sp<GrFragmentProcessor> shaderFP,
+ std::unique_ptr<GrFragmentProcessor> shaderFP,
GrPaint* grPaint);
/** Blends the SkPaint's shader (or color if no shader) with the color which specified via a
@@ -143,7 +143,7 @@
GrRenderTargetContext* rtc,
const SkPaint& paint,
const SkMatrix& viewM,
- sk_sp<GrFragmentProcessor> fp,
+ std::unique_ptr<GrFragmentProcessor> fp,
bool textureIsAlphaOnly,
GrPaint* grPaint);
diff --git a/src/gpu/effects/GrBicubicEffect.cpp b/src/gpu/effects/GrBicubicEffect.cpp
index 28fcd9e..c8b302c 100644
--- a/src/gpu/effects/GrBicubicEffect.cpp
+++ b/src/gpu/effects/GrBicubicEffect.cpp
@@ -188,7 +188,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrBicubicEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrBicubicEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrBicubicEffect::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
: GrProcessorUnitTest::kAlphaTextureIdx;
sk_sp<GrColorSpaceXform> colorSpaceXform = GrTest::TestColorXform(d->fRandom);
diff --git a/src/gpu/effects/GrBicubicEffect.h b/src/gpu/effects/GrBicubicEffect.h
index 65e2c3d..7812f3f 100644
--- a/src/gpu/effects/GrBicubicEffect.h
+++ b/src/gpu/effects/GrBicubicEffect.h
@@ -22,8 +22,8 @@
const char* name() const override { return "Bicubic"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new GrBicubicEffect(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new GrBicubicEffect(*this));
}
const GrTextureDomain& domain() const { return fDomain; }
@@ -33,25 +33,23 @@
/**
* Create a Mitchell filter effect with specified texture matrix and x/y tile modes.
*/
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
- sk_sp<GrColorSpaceXform> colorSpaceXform,
- const SkMatrix& matrix,
- const SkShader::TileMode tileModes[2]) {
- return sk_sp<GrFragmentProcessor>(new GrBicubicEffect(std::move(proxy),
- std::move(colorSpaceXform),
- matrix, tileModes));
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
+ sk_sp<GrColorSpaceXform> colorSpaceXform,
+ const SkMatrix& matrix,
+ const SkShader::TileMode tileModes[2]) {
+ return std::unique_ptr<GrFragmentProcessor>(new GrBicubicEffect(
+ std::move(proxy), std::move(colorSpaceXform), matrix, tileModes));
}
/**
* Create a Mitchell filter effect with a texture matrix and a domain.
*/
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
- sk_sp<GrColorSpaceXform> colorSpaceXform,
- const SkMatrix& matrix,
- const SkRect& domain) {
- return sk_sp<GrFragmentProcessor>(new GrBicubicEffect(std::move(proxy),
- std::move(colorSpaceXform),
- matrix, domain));
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
+ sk_sp<GrColorSpaceXform> colorSpaceXform,
+ const SkMatrix& matrix,
+ const SkRect& domain) {
+ return std::unique_ptr<GrFragmentProcessor>(
+ new GrBicubicEffect(std::move(proxy), std::move(colorSpaceXform), matrix, domain));
}
/**
diff --git a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp
index 8c0ff64..1b5ea60 100644
--- a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp
+++ b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp
@@ -55,7 +55,7 @@
: INHERITED(src.optimizationFlags()), fMode(src.fMode) {
this->initClassID<GrBlurredEdgeFragmentProcessor>();
}
-sk_sp<GrFragmentProcessor> GrBlurredEdgeFragmentProcessor::clone() const {
- return sk_sp<GrFragmentProcessor>(new GrBlurredEdgeFragmentProcessor(*this));
+std::unique_ptr<GrFragmentProcessor> GrBlurredEdgeFragmentProcessor::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(new GrBlurredEdgeFragmentProcessor(*this));
}
#endif
diff --git a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.h b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.h
index 677c285..61cc53b 100644
--- a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.h
+++ b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.h
@@ -19,11 +19,11 @@
public:
enum Mode { kGaussian_Mode = 0, kSmoothStep_Mode = 1 };
int mode() const { return fMode; }
- static sk_sp<GrFragmentProcessor> Make(int mode) {
- return sk_sp<GrFragmentProcessor>(new GrBlurredEdgeFragmentProcessor(mode));
+ static std::unique_ptr<GrFragmentProcessor> Make(int mode) {
+ return std::unique_ptr<GrFragmentProcessor>(new GrBlurredEdgeFragmentProcessor(mode));
}
GrBlurredEdgeFragmentProcessor(const GrBlurredEdgeFragmentProcessor& src);
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
const char* name() const override { return "BlurredEdgeFragmentProcessor"; }
private:
diff --git a/src/gpu/effects/GrCircleEffect.cpp b/src/gpu/effects/GrCircleEffect.cpp
index 6fc4755..b764559 100644
--- a/src/gpu/effects/GrCircleEffect.cpp
+++ b/src/gpu/effects/GrCircleEffect.cpp
@@ -95,12 +95,12 @@
, fRadius(src.fRadius) {
this->initClassID<GrCircleEffect>();
}
-sk_sp<GrFragmentProcessor> GrCircleEffect::clone() const {
- return sk_sp<GrFragmentProcessor>(new GrCircleEffect(*this));
+std::unique_ptr<GrFragmentProcessor> GrCircleEffect::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(new GrCircleEffect(*this));
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrCircleEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrCircleEffect::TestCreate(GrProcessorTestData* testData) {
+std::unique_ptr<GrFragmentProcessor> GrCircleEffect::TestCreate(GrProcessorTestData* testData) {
SkPoint center;
center.fX = testData->fRandom->nextRangeScalar(0.f, 1000.f);
center.fY = testData->fRandom->nextRangeScalar(0.f, 1000.f);
diff --git a/src/gpu/effects/GrCircleEffect.h b/src/gpu/effects/GrCircleEffect.h
index 46e46f9..0d88dcb 100644
--- a/src/gpu/effects/GrCircleEffect.h
+++ b/src/gpu/effects/GrCircleEffect.h
@@ -20,11 +20,11 @@
int edgeType() const { return fEdgeType; }
SkPoint center() const { return fCenter; }
float radius() const { return fRadius; }
- static sk_sp<GrFragmentProcessor> Make(int edgeType, SkPoint center, float radius) {
- return sk_sp<GrFragmentProcessor>(new GrCircleEffect(edgeType, center, radius));
+ static std::unique_ptr<GrFragmentProcessor> Make(int edgeType, SkPoint center, float radius) {
+ return std::unique_ptr<GrFragmentProcessor>(new GrCircleEffect(edgeType, center, radius));
}
GrCircleEffect(const GrCircleEffect& src);
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
const char* name() const override { return "CircleEffect"; }
private:
diff --git a/src/gpu/effects/GrConfigConversionEffect.cpp b/src/gpu/effects/GrConfigConversionEffect.cpp
index 8806481..e784ed7 100644
--- a/src/gpu/effects/GrConfigConversionEffect.cpp
+++ b/src/gpu/effects/GrConfigConversionEffect.cpp
@@ -70,8 +70,8 @@
this->initClassID<GrConfigConversionEffect>();
}
-sk_sp<GrFragmentProcessor> GrConfigConversionEffect::clone() const {
- return sk_sp<GrFragmentProcessor>(new GrConfigConversionEffect(fPMConversion));
+std::unique_ptr<GrFragmentProcessor> GrConfigConversionEffect::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(new GrConfigConversionEffect(fPMConversion));
}
bool GrConfigConversionEffect::onIsEqual(const GrFragmentProcessor& s) const {
@@ -84,9 +84,9 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConfigConversionEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrConfigConversionEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrConfigConversionEffect::TestCreate(GrProcessorTestData* d) {
PMConversion pmConv = static_cast<PMConversion>(d->fRandom->nextULessThan(kPMConversionCnt));
- return sk_sp<GrFragmentProcessor>(new GrConfigConversionEffect(pmConv));
+ return std::unique_ptr<GrFragmentProcessor>(new GrConfigConversionEffect(pmConv));
}
#endif
@@ -158,11 +158,13 @@
GrPaint paint1;
GrPaint paint2;
GrPaint paint3;
- sk_sp<GrFragmentProcessor> pmToUPM(new GrConfigConversionEffect(kToUnpremul_PMConversion));
- sk_sp<GrFragmentProcessor> upmToPM(new GrConfigConversionEffect(kToPremul_PMConversion));
+ std::unique_ptr<GrFragmentProcessor> pmToUPM(
+ new GrConfigConversionEffect(kToUnpremul_PMConversion));
+ std::unique_ptr<GrFragmentProcessor> upmToPM(
+ new GrConfigConversionEffect(kToPremul_PMConversion));
paint1.addColorTextureProcessor(dataProxy, nullptr, SkMatrix::I());
- paint1.addColorFragmentProcessor(pmToUPM);
+ paint1.addColorFragmentProcessor(pmToUPM->clone());
paint1.setPorterDuffXPFactory(SkBlendMode::kSrc);
readRTC->fillRectToRect(GrNoClip(), std::move(paint1), GrAA::kNo, SkMatrix::I(), kRect, kRect);
@@ -199,12 +201,12 @@
return true;
}
-sk_sp<GrFragmentProcessor> GrConfigConversionEffect::Make(sk_sp<GrFragmentProcessor> fp,
- PMConversion pmConversion) {
+std::unique_ptr<GrFragmentProcessor> GrConfigConversionEffect::Make(
+ std::unique_ptr<GrFragmentProcessor> fp, PMConversion pmConversion) {
if (!fp) {
return nullptr;
}
- sk_sp<GrFragmentProcessor> ccFP(new GrConfigConversionEffect(pmConversion));
- sk_sp<GrFragmentProcessor> fpPipeline[] = { fp, ccFP };
+ std::unique_ptr<GrFragmentProcessor> ccFP(new GrConfigConversionEffect(pmConversion));
+ std::unique_ptr<GrFragmentProcessor> fpPipeline[] = { std::move(fp), std::move(ccFP) };
return GrFragmentProcessor::RunInSeries(fpPipeline, 2);
}
diff --git a/src/gpu/effects/GrConfigConversionEffect.h b/src/gpu/effects/GrConfigConversionEffect.h
index fe8f50b..690fbd5 100644
--- a/src/gpu/effects/GrConfigConversionEffect.h
+++ b/src/gpu/effects/GrConfigConversionEffect.h
@@ -29,11 +29,12 @@
* Returns a fragment processor that calls the passed in fragment processor, and then performs
* the requested premul or unpremul conversion.
*/
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrFragmentProcessor>, PMConversion);
+ static std::unique_ptr<GrFragmentProcessor> Make(std::unique_ptr<GrFragmentProcessor>,
+ PMConversion);
const char* name() const override { return "Config Conversion"; }
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
PMConversion pmConversion() const { return fPMConversion; }
diff --git a/src/gpu/effects/GrConstColorProcessor.cpp b/src/gpu/effects/GrConstColorProcessor.cpp
index d5f4e35..0859224 100644
--- a/src/gpu/effects/GrConstColorProcessor.cpp
+++ b/src/gpu/effects/GrConstColorProcessor.cpp
@@ -62,7 +62,9 @@
///////////////////////////////////////////////////////////////////////////////
-sk_sp<GrFragmentProcessor> GrConstColorProcessor::clone() const { return Make(fColor, fMode); }
+std::unique_ptr<GrFragmentProcessor> GrConstColorProcessor::clone() const {
+ return Make(fColor, fMode);
+}
GrColor4f GrConstColorProcessor::constantOutputForConstantInput(GrColor4f input) const {
switch (fMode) {
@@ -96,7 +98,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConstColorProcessor);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrConstColorProcessor::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrConstColorProcessor::TestCreate(GrProcessorTestData* d) {
GrColor4f color;
int colorPicker = d->fRandom->nextULessThan(3);
switch (colorPicker) {
diff --git a/src/gpu/effects/GrConstColorProcessor.h b/src/gpu/effects/GrConstColorProcessor.h
index baf405a..7079a8d 100644
--- a/src/gpu/effects/GrConstColorProcessor.h
+++ b/src/gpu/effects/GrConstColorProcessor.h
@@ -26,8 +26,8 @@
};
static const int kInputModeCnt = kLastInputMode + 1;
- static sk_sp<GrFragmentProcessor> Make(GrColor4f color, InputMode mode) {
- return sk_sp<GrFragmentProcessor>(new GrConstColorProcessor(color, mode));
+ static std::unique_ptr<GrFragmentProcessor> Make(GrColor4f color, InputMode mode) {
+ return std::unique_ptr<GrFragmentProcessor>(new GrConstColorProcessor(color, mode));
}
const char* name() const override { return "Color"; }
@@ -38,7 +38,7 @@
return str;
}
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
GrColor4f color() const { return fColor; }
diff --git a/src/gpu/effects/GrConvexPolyEffect.cpp b/src/gpu/effects/GrConvexPolyEffect.cpp
index bb61cc1..e61923c 100644
--- a/src/gpu/effects/GrConvexPolyEffect.cpp
+++ b/src/gpu/effects/GrConvexPolyEffect.cpp
@@ -19,15 +19,16 @@
public:
const SkRect& getRect() const { return fRect; }
- static sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType edgeType, const SkRect& rect) {
- return sk_sp<GrFragmentProcessor>(new AARectEffect(edgeType, rect));
+ static std::unique_ptr<GrFragmentProcessor> Make(GrPrimitiveEdgeType edgeType,
+ const SkRect& rect) {
+ return std::unique_ptr<GrFragmentProcessor>(new AARectEffect(edgeType, rect));
}
GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
const char* name() const override { return "AARect"; }
- sk_sp<GrFragmentProcessor> clone() const override { return Make(fEdgeType, fRect); }
+ std::unique_ptr<GrFragmentProcessor> clone() const override { return Make(fEdgeType, fRect); }
private:
void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
@@ -58,12 +59,12 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(AARectEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> AARectEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> AARectEffect::TestCreate(GrProcessorTestData* d) {
SkRect rect = SkRect::MakeLTRB(d->fRandom->nextSScalar1(),
d->fRandom->nextSScalar1(),
d->fRandom->nextSScalar1(),
d->fRandom->nextSScalar1());
- sk_sp<GrFragmentProcessor> fp;
+ std::unique_ptr<GrFragmentProcessor> fp;
do {
GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>(
d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt));
@@ -236,7 +237,8 @@
//////////////////////////////////////////////////////////////////////////////
-sk_sp<GrFragmentProcessor> GrConvexPolyEffect::Make(GrPrimitiveEdgeType type, const SkPath& path) {
+std::unique_ptr<GrFragmentProcessor> GrConvexPolyEffect::Make(GrPrimitiveEdgeType type,
+ const SkPath& path) {
if (kHairlineAA_GrProcessorEdgeType == type) {
return nullptr;
}
@@ -306,8 +308,8 @@
return Make(type, n, edges);
}
-sk_sp<GrFragmentProcessor> GrConvexPolyEffect::Make(GrPrimitiveEdgeType edgeType,
- const SkRect& rect) {
+std::unique_ptr<GrFragmentProcessor> GrConvexPolyEffect::Make(GrPrimitiveEdgeType edgeType,
+ const SkRect& rect) {
if (kHairlineAA_GrProcessorEdgeType == edgeType){
return nullptr;
}
@@ -348,8 +350,8 @@
memcpy(fEdges, that.fEdges, 3 * that.fEdgeCount * sizeof(SkScalar));
}
-sk_sp<GrFragmentProcessor> GrConvexPolyEffect::clone() const {
- return sk_sp<GrFragmentProcessor>(new GrConvexPolyEffect(*this));
+std::unique_ptr<GrFragmentProcessor> GrConvexPolyEffect::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(new GrConvexPolyEffect(*this));
}
bool GrConvexPolyEffect::onIsEqual(const GrFragmentProcessor& other) const {
@@ -364,14 +366,14 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConvexPolyEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrConvexPolyEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrConvexPolyEffect::TestCreate(GrProcessorTestData* d) {
int count = d->fRandom->nextULessThan(kMaxEdges) + 1;
SkScalar edges[kMaxEdges * 3];
for (int i = 0; i < 3 * count; ++i) {
edges[i] = d->fRandom->nextSScalar1();
}
- sk_sp<GrFragmentProcessor> fp;
+ std::unique_ptr<GrFragmentProcessor> fp;
do {
GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>(
d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt));
diff --git a/src/gpu/effects/GrConvexPolyEffect.h b/src/gpu/effects/GrConvexPolyEffect.h
index f1f6ab0..abb718e 100644
--- a/src/gpu/effects/GrConvexPolyEffect.h
+++ b/src/gpu/effects/GrConvexPolyEffect.h
@@ -38,30 +38,30 @@
* have to modify the effect/shaderbuilder interface to make it possible (e.g. give access
* to the view matrix or untransformed positions in the fragment shader).
*/
- static sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType edgeType, int n,
- const SkScalar edges[]) {
+ static std::unique_ptr<GrFragmentProcessor> Make(GrPrimitiveEdgeType edgeType, int n,
+ const SkScalar edges[]) {
if (n <= 0 || n > kMaxEdges || kHairlineAA_GrProcessorEdgeType == edgeType) {
return nullptr;
}
- return sk_sp<GrFragmentProcessor>(new GrConvexPolyEffect(edgeType, n, edges));
+ return std::unique_ptr<GrFragmentProcessor>(new GrConvexPolyEffect(edgeType, n, edges));
}
/**
* Creates an effect that clips against the path. If the path is not a convex polygon, is
* inverse filled, or has too many edges, this will return nullptr.
*/
- static sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkPath&);
+ static std::unique_ptr<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkPath&);
/**
* Creates an effect that fills inside the rect with AA edges..
*/
- static sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkRect&);
+ static std::unique_ptr<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkRect&);
~GrConvexPolyEffect() override;
const char* name() const override { return "ConvexPoly"; }
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
diff --git a/src/gpu/effects/GrDitherEffect.cpp b/src/gpu/effects/GrDitherEffect.cpp
index f2fc678..d78af4e 100644
--- a/src/gpu/effects/GrDitherEffect.cpp
+++ b/src/gpu/effects/GrDitherEffect.cpp
@@ -62,14 +62,14 @@
: INHERITED(src.optimizationFlags()), fRangeType(src.fRangeType) {
this->initClassID<GrDitherEffect>();
}
-sk_sp<GrFragmentProcessor> GrDitherEffect::clone() const {
- return sk_sp<GrFragmentProcessor>(new GrDitherEffect(*this));
+std::unique_ptr<GrFragmentProcessor> GrDitherEffect::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(new GrDitherEffect(*this));
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDitherEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrDitherEffect::TestCreate(GrProcessorTestData* testData) {
+std::unique_ptr<GrFragmentProcessor> GrDitherEffect::TestCreate(GrProcessorTestData* testData) {
float range = testData->fRandom->nextRangeF(0.001f, 0.05f);
- return sk_sp<GrFragmentProcessor>(new GrDitherEffect(range));
+ return std::unique_ptr<GrFragmentProcessor>(new GrDitherEffect(range));
}
#endif
#endif
diff --git a/src/gpu/effects/GrDitherEffect.fp b/src/gpu/effects/GrDitherEffect.fp
index 7ec852e..fe641c6 100644
--- a/src/gpu/effects/GrDitherEffect.fp
+++ b/src/gpu/effects/GrDitherEffect.fp
@@ -2,7 +2,7 @@
layout(key) in int rangeType;
@make {
- static sk_sp<GrFragmentProcessor> Make(GrPixelConfig dstConfig) {
+ static std::unique_ptr<GrFragmentProcessor> Make(GrPixelConfig dstConfig) {
int rangeType;
switch (dstConfig) {
case kGray_8_GrPixelConfig:
@@ -27,7 +27,7 @@
case kAlpha_8_GrPixelConfig:
return nullptr;
}
- return sk_sp<GrFragmentProcessor>(new GrDitherEffect(rangeType));
+ return std::unique_ptr<GrFragmentProcessor>(new GrDitherEffect(rangeType));
}
}
@@ -68,5 +68,5 @@
@test(testData) {
float range = testData->fRandom->nextRangeF(0.001f, 0.05f);
- return sk_sp<GrFragmentProcessor>(new GrDitherEffect(range));
+ return std::unique_ptr<GrFragmentProcessor>(new GrDitherEffect(range));
}
diff --git a/src/gpu/effects/GrDitherEffect.h b/src/gpu/effects/GrDitherEffect.h
index 529b5ec..d428c3c 100644
--- a/src/gpu/effects/GrDitherEffect.h
+++ b/src/gpu/effects/GrDitherEffect.h
@@ -19,7 +19,7 @@
public:
int rangeType() const { return fRangeType; }
- static sk_sp<GrFragmentProcessor> Make(GrPixelConfig dstConfig) {
+ static std::unique_ptr<GrFragmentProcessor> Make(GrPixelConfig dstConfig) {
int rangeType;
switch (dstConfig) {
case kGray_8_GrPixelConfig:
@@ -44,10 +44,10 @@
case kAlpha_8_GrPixelConfig:
return nullptr;
}
- return sk_sp<GrFragmentProcessor>(new GrDitherEffect(rangeType));
+ return std::unique_ptr<GrFragmentProcessor>(new GrDitherEffect(rangeType));
}
GrDitherEffect(const GrDitherEffect& src);
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
const char* name() const override { return "DitherEffect"; }
private:
diff --git a/src/gpu/effects/GrEllipseEffect.cpp b/src/gpu/effects/GrEllipseEffect.cpp
index edf12d2..e9443a8 100644
--- a/src/gpu/effects/GrEllipseEffect.cpp
+++ b/src/gpu/effects/GrEllipseEffect.cpp
@@ -120,12 +120,12 @@
, fRadii(src.fRadii) {
this->initClassID<GrEllipseEffect>();
}
-sk_sp<GrFragmentProcessor> GrEllipseEffect::clone() const {
- return sk_sp<GrFragmentProcessor>(new GrEllipseEffect(*this));
+std::unique_ptr<GrFragmentProcessor> GrEllipseEffect::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(new GrEllipseEffect(*this));
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrEllipseEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrEllipseEffect::TestCreate(GrProcessorTestData* testData) {
+std::unique_ptr<GrFragmentProcessor> GrEllipseEffect::TestCreate(GrProcessorTestData* testData) {
SkPoint center;
center.fX = testData->fRandom->nextRangeScalar(0.f, 1000.f);
center.fY = testData->fRandom->nextRangeScalar(0.f, 1000.f);
diff --git a/src/gpu/effects/GrEllipseEffect.h b/src/gpu/effects/GrEllipseEffect.h
index 2858656..1425f39 100644
--- a/src/gpu/effects/GrEllipseEffect.h
+++ b/src/gpu/effects/GrEllipseEffect.h
@@ -20,11 +20,11 @@
int edgeType() const { return fEdgeType; }
SkPoint center() const { return fCenter; }
SkPoint radii() const { return fRadii; }
- static sk_sp<GrFragmentProcessor> Make(int edgeType, SkPoint center, SkPoint radii) {
- return sk_sp<GrFragmentProcessor>(new GrEllipseEffect(edgeType, center, radii));
+ static std::unique_ptr<GrFragmentProcessor> Make(int edgeType, SkPoint center, SkPoint radii) {
+ return std::unique_ptr<GrFragmentProcessor>(new GrEllipseEffect(edgeType, center, radii));
}
GrEllipseEffect(const GrEllipseEffect& src);
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
const char* name() const override { return "EllipseEffect"; }
private:
diff --git a/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp b/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp
index ac22a8c..b54ca53 100644
--- a/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp
+++ b/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp
@@ -255,7 +255,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrGaussianConvolutionFragmentProcessor);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrGaussianConvolutionFragmentProcessor::TestCreate(
+std::unique_ptr<GrFragmentProcessor> GrGaussianConvolutionFragmentProcessor::TestCreate(
GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
: GrProcessorUnitTest::kAlphaTextureIdx;
diff --git a/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.h b/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.h
index 74e9a94..9850e60 100644
--- a/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.h
+++ b/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.h
@@ -22,14 +22,14 @@
enum class Direction { kX, kY };
/// Convolve with a Gaussian kernel
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
- Direction dir,
- int halfWidth,
- float gaussianSigma,
- GrTextureDomain::Mode mode,
- int* bounds) {
- return sk_sp<GrFragmentProcessor>(new GrGaussianConvolutionFragmentProcessor(
- std::move(proxy), dir, halfWidth, gaussianSigma, mode, bounds));
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
+ Direction dir,
+ int halfWidth,
+ float gaussianSigma,
+ GrTextureDomain::Mode mode,
+ int* bounds) {
+ return std::unique_ptr<GrFragmentProcessor>(new GrGaussianConvolutionFragmentProcessor(
+ std::move(proxy), dir, halfWidth, gaussianSigma, mode, bounds));
}
const float* kernel() const { return fKernel; }
@@ -44,8 +44,9 @@
const char* name() const override { return "GaussianConvolution"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new GrGaussianConvolutionFragmentProcessor(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(
+ new GrGaussianConvolutionFragmentProcessor(*this));
}
// This was decided based on the min allowed value for the max texture
diff --git a/src/gpu/effects/GrMatrixConvolutionEffect.cpp b/src/gpu/effects/GrMatrixConvolutionEffect.cpp
index 030a926..9d9a03e 100644
--- a/src/gpu/effects/GrMatrixConvolutionEffect.cpp
+++ b/src/gpu/effects/GrMatrixConvolutionEffect.cpp
@@ -194,8 +194,8 @@
memcpy(fKernelOffset, that.fKernelOffset, sizeof(fKernelOffset));
}
-sk_sp<GrFragmentProcessor> GrMatrixConvolutionEffect::clone() const {
- return sk_sp<GrFragmentProcessor>(new GrMatrixConvolutionEffect(*this));
+std::unique_ptr<GrFragmentProcessor> GrMatrixConvolutionEffect::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(new GrMatrixConvolutionEffect(*this));
}
void GrMatrixConvolutionEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
@@ -248,30 +248,30 @@
}
// Static function to create a 2D convolution
-sk_sp<GrFragmentProcessor> GrMatrixConvolutionEffect::MakeGaussian(
- sk_sp<GrTextureProxy> proxy,
- const SkIRect& bounds,
- const SkISize& kernelSize,
- SkScalar gain,
- SkScalar bias,
- const SkIPoint& kernelOffset,
- GrTextureDomain::Mode tileMode,
- bool convolveAlpha,
- SkScalar sigmaX,
- SkScalar sigmaY) {
+std::unique_ptr<GrFragmentProcessor> GrMatrixConvolutionEffect::MakeGaussian(
+ sk_sp<GrTextureProxy> proxy,
+ const SkIRect& bounds,
+ const SkISize& kernelSize,
+ SkScalar gain,
+ SkScalar bias,
+ const SkIPoint& kernelOffset,
+ GrTextureDomain::Mode tileMode,
+ bool convolveAlpha,
+ SkScalar sigmaX,
+ SkScalar sigmaY) {
float kernel[MAX_KERNEL_SIZE];
fill_in_2D_gaussian_kernel(kernel, kernelSize.width(), kernelSize.height(), sigmaX, sigmaY);
- return sk_sp<GrFragmentProcessor>(
- new GrMatrixConvolutionEffect(std::move(proxy), bounds, kernelSize,
- kernel, gain, bias, kernelOffset, tileMode, convolveAlpha));
+ return std::unique_ptr<GrFragmentProcessor>(
+ new GrMatrixConvolutionEffect(std::move(proxy), bounds, kernelSize, kernel, gain, bias,
+ kernelOffset, tileMode, convolveAlpha));
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMatrixConvolutionEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrMatrixConvolutionEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrMatrixConvolutionEffect::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
: GrProcessorUnitTest::kAlphaTextureIdx;
sk_sp<GrTextureProxy> proxy = d->textureProxy(texIdx);
diff --git a/src/gpu/effects/GrMatrixConvolutionEffect.h b/src/gpu/effects/GrMatrixConvolutionEffect.h
index 9ece00e..2e859b1 100644
--- a/src/gpu/effects/GrMatrixConvolutionEffect.h
+++ b/src/gpu/effects/GrMatrixConvolutionEffect.h
@@ -16,30 +16,30 @@
class GrMatrixConvolutionEffect : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
- const SkIRect& bounds,
- const SkISize& kernelSize,
- const SkScalar* kernel,
- SkScalar gain,
- SkScalar bias,
- const SkIPoint& kernelOffset,
- GrTextureDomain::Mode tileMode,
- bool convolveAlpha) {
- return sk_sp<GrFragmentProcessor>(
- new GrMatrixConvolutionEffect(std::move(proxy), bounds, kernelSize,
- kernel, gain, bias, kernelOffset, tileMode, convolveAlpha));
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
+ const SkIRect& bounds,
+ const SkISize& kernelSize,
+ const SkScalar* kernel,
+ SkScalar gain,
+ SkScalar bias,
+ const SkIPoint& kernelOffset,
+ GrTextureDomain::Mode tileMode,
+ bool convolveAlpha) {
+ return std::unique_ptr<GrFragmentProcessor>(
+ new GrMatrixConvolutionEffect(std::move(proxy), bounds, kernelSize, kernel, gain,
+ bias, kernelOffset, tileMode, convolveAlpha));
}
- static sk_sp<GrFragmentProcessor> MakeGaussian(sk_sp<GrTextureProxy> proxy,
- const SkIRect& bounds,
- const SkISize& kernelSize,
- SkScalar gain,
- SkScalar bias,
- const SkIPoint& kernelOffset,
- GrTextureDomain::Mode tileMode,
- bool convolveAlpha,
- SkScalar sigmaX,
- SkScalar sigmaY);
+ static std::unique_ptr<GrFragmentProcessor> MakeGaussian(sk_sp<GrTextureProxy> proxy,
+ const SkIRect& bounds,
+ const SkISize& kernelSize,
+ SkScalar gain,
+ SkScalar bias,
+ const SkIPoint& kernelOffset,
+ GrTextureDomain::Mode tileMode,
+ bool convolveAlpha,
+ SkScalar sigmaX,
+ SkScalar sigmaY);
const SkIRect& bounds() const { return fBounds; }
const SkISize& kernelSize() const { return fKernelSize; }
@@ -52,7 +52,7 @@
const char* name() const override { return "MatrixConvolution"; }
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
private:
GrMatrixConvolutionEffect(sk_sp<GrTextureProxy> proxy,
diff --git a/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp b/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp
index 6ae770b..b30746a 100644
--- a/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp
+++ b/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp
@@ -173,8 +173,8 @@
memcpy(fDstTransferFnCoeffs, that.fDstTransferFnCoeffs, sizeof(fDstTransferFnCoeffs));
}
-sk_sp<GrFragmentProcessor> GrNonlinearColorSpaceXformEffect::clone() const {
- return sk_sp<GrFragmentProcessor>(new GrNonlinearColorSpaceXformEffect(*this));
+std::unique_ptr<GrFragmentProcessor> GrNonlinearColorSpaceXformEffect::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(new GrNonlinearColorSpaceXformEffect(*this));
}
bool GrNonlinearColorSpaceXformEffect::onIsEqual(const GrFragmentProcessor& s) const {
@@ -201,7 +201,8 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrNonlinearColorSpaceXformEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrNonlinearColorSpaceXformEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrNonlinearColorSpaceXformEffect::TestCreate(
+ GrProcessorTestData* d) {
// TODO: Generate a random variety of color spaces for this effect (it can handle wacky
// transfer functions, etc...)
sk_sp<SkColorSpace> srcSpace = SkColorSpace::MakeSRGBLinear();
@@ -221,8 +222,8 @@
return new GrGLNonlinearColorSpaceXformEffect();
}
-sk_sp<GrFragmentProcessor> GrNonlinearColorSpaceXformEffect::Make(const SkColorSpace* src,
- const SkColorSpace* dst) {
+std::unique_ptr<GrFragmentProcessor> GrNonlinearColorSpaceXformEffect::Make(
+ const SkColorSpace* src, const SkColorSpace* dst) {
if (!src || !dst || SkColorSpace::Equals(src, dst)) {
// No conversion possible (or necessary)
return nullptr;
@@ -257,6 +258,6 @@
}
}
- return sk_sp<GrFragmentProcessor>(new GrNonlinearColorSpaceXformEffect(
- ops, srcTransferFn, dstTransferFn, srcToDstMtx));
+ return std::unique_ptr<GrFragmentProcessor>(
+ new GrNonlinearColorSpaceXformEffect(ops, srcTransferFn, dstTransferFn, srcToDstMtx));
}
diff --git a/src/gpu/effects/GrNonlinearColorSpaceXformEffect.h b/src/gpu/effects/GrNonlinearColorSpaceXformEffect.h
index f57c64b..109ec10 100644
--- a/src/gpu/effects/GrNonlinearColorSpaceXformEffect.h
+++ b/src/gpu/effects/GrNonlinearColorSpaceXformEffect.h
@@ -27,11 +27,12 @@
* This will return nullptr if either space is nullptr, if both spaces are equal, or if either
* space has a non-parametric transfer funcion (e.g. lookup table or A2B).
*/
- static sk_sp<GrFragmentProcessor> Make(const SkColorSpace* src, const SkColorSpace* dst);
+ static std::unique_ptr<GrFragmentProcessor> Make(const SkColorSpace* src,
+ const SkColorSpace* dst);
const char* name() const override { return "NonlinearColorSpaceXform"; }
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
static const int kNumTransferFnCoeffs = 7;
diff --git a/src/gpu/effects/GrOvalEffect.cpp b/src/gpu/effects/GrOvalEffect.cpp
index 3180533..efc86a4 100644
--- a/src/gpu/effects/GrOvalEffect.cpp
+++ b/src/gpu/effects/GrOvalEffect.cpp
@@ -11,7 +11,8 @@
#include "GrEllipseEffect.h"
#include "SkRect.h"
-sk_sp<GrFragmentProcessor> GrOvalEffect::Make(GrPrimitiveEdgeType edgeType, const SkRect& oval) {
+std::unique_ptr<GrFragmentProcessor> GrOvalEffect::Make(GrPrimitiveEdgeType edgeType,
+ const SkRect& oval) {
if (kHairlineAA_GrProcessorEdgeType == edgeType) {
return nullptr;
}
diff --git a/src/gpu/effects/GrOvalEffect.h b/src/gpu/effects/GrOvalEffect.h
index 3ff241a..1372f23 100644
--- a/src/gpu/effects/GrOvalEffect.h
+++ b/src/gpu/effects/GrOvalEffect.h
@@ -16,10 +16,12 @@
struct SkRect;
namespace GrOvalEffect {
- /**
- * Creates an effect that performs clipping against an oval.
- */
- sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkRect&);
+
+/**
+ * Creates an effect that performs clipping against an oval.
+ */
+std::unique_ptr<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkRect&);
+
};
#endif
diff --git a/src/gpu/effects/GrRRectEffect.cpp b/src/gpu/effects/GrRRectEffect.cpp
index 8dde914..f253dfe 100644
--- a/src/gpu/effects/GrRRectEffect.cpp
+++ b/src/gpu/effects/GrRRectEffect.cpp
@@ -45,14 +45,14 @@
// The flags are used to indicate which corners are circluar (unflagged corners are assumed to
// be square).
- static sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType, uint32_t circularCornerFlags,
- const SkRRect&);
+ static std::unique_ptr<GrFragmentProcessor> Make(GrPrimitiveEdgeType,
+ uint32_t circularCornerFlags, const SkRRect&);
~CircularRRectEffect() override {}
const char* name() const override { return "CircularRRect"; }
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
const SkRRect& getRRect() const { return fRRect; }
@@ -78,14 +78,14 @@
typedef GrFragmentProcessor INHERITED;
};
-sk_sp<GrFragmentProcessor> CircularRRectEffect::Make(GrPrimitiveEdgeType edgeType,
- uint32_t circularCornerFlags,
- const SkRRect& rrect) {
+std::unique_ptr<GrFragmentProcessor> CircularRRectEffect::Make(GrPrimitiveEdgeType edgeType,
+ uint32_t circularCornerFlags,
+ const SkRRect& rrect) {
if (kFillAA_GrProcessorEdgeType != edgeType && kInverseFillAA_GrProcessorEdgeType != edgeType) {
return nullptr;
}
- return sk_sp<GrFragmentProcessor>(
- new CircularRRectEffect(edgeType, circularCornerFlags, rrect));
+ return std::unique_ptr<GrFragmentProcessor>(
+ new CircularRRectEffect(edgeType, circularCornerFlags, rrect));
}
CircularRRectEffect::CircularRRectEffect(GrPrimitiveEdgeType edgeType, uint32_t circularCornerFlags,
@@ -97,8 +97,8 @@
this->initClassID<CircularRRectEffect>();
}
-sk_sp<GrFragmentProcessor> CircularRRectEffect::clone() const {
- return sk_sp<GrFragmentProcessor>(
+std::unique_ptr<GrFragmentProcessor> CircularRRectEffect::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(
new CircularRRectEffect(fEdgeType, fCircularCornerFlags, fRRect));
}
@@ -113,13 +113,13 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircularRRectEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> CircularRRectEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> CircularRRectEffect::TestCreate(GrProcessorTestData* d) {
SkScalar w = d->fRandom->nextRangeScalar(20.f, 1000.f);
SkScalar h = d->fRandom->nextRangeScalar(20.f, 1000.f);
SkScalar r = d->fRandom->nextRangeF(kRadiusMin, 9.f);
SkRRect rrect;
rrect.setRectXY(SkRect::MakeWH(w, h), r, r);
- sk_sp<GrFragmentProcessor> fp;
+ std::unique_ptr<GrFragmentProcessor> fp;
do {
GrPrimitiveEdgeType et =
(GrPrimitiveEdgeType)d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt);
@@ -391,13 +391,13 @@
class EllipticalRRectEffect : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkRRect&);
+ static std::unique_ptr<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkRRect&);
~EllipticalRRectEffect() override {}
const char* name() const override { return "EllipticalRRect"; }
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
const SkRRect& getRRect() const { return fRRect; }
@@ -420,12 +420,12 @@
typedef GrFragmentProcessor INHERITED;
};
-sk_sp<GrFragmentProcessor>
-EllipticalRRectEffect::Make(GrPrimitiveEdgeType edgeType, const SkRRect& rrect) {
+std::unique_ptr<GrFragmentProcessor> EllipticalRRectEffect::Make(GrPrimitiveEdgeType edgeType,
+ const SkRRect& rrect) {
if (kFillAA_GrProcessorEdgeType != edgeType && kInverseFillAA_GrProcessorEdgeType != edgeType) {
return nullptr;
}
- return sk_sp<GrFragmentProcessor>(new EllipticalRRectEffect(edgeType, rrect));
+ return std::unique_ptr<GrFragmentProcessor>(new EllipticalRRectEffect(edgeType, rrect));
}
EllipticalRRectEffect::EllipticalRRectEffect(GrPrimitiveEdgeType edgeType, const SkRRect& rrect)
@@ -435,8 +435,8 @@
this->initClassID<EllipticalRRectEffect>();
}
-sk_sp<GrFragmentProcessor> EllipticalRRectEffect::clone() const {
- return sk_sp<GrFragmentProcessor>(new EllipticalRRectEffect(fEdgeType, fRRect));
+std::unique_ptr<GrFragmentProcessor> EllipticalRRectEffect::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(new EllipticalRRectEffect(fEdgeType, fRRect));
}
bool EllipticalRRectEffect::onIsEqual(const GrFragmentProcessor& other) const {
@@ -449,7 +449,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(EllipticalRRectEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> EllipticalRRectEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> EllipticalRRectEffect::TestCreate(GrProcessorTestData* d) {
SkScalar w = d->fRandom->nextRangeScalar(20.f, 1000.f);
SkScalar h = d->fRandom->nextRangeScalar(20.f, 1000.f);
SkVector r[4];
@@ -476,7 +476,7 @@
rrect.setRectXY(SkRect::MakeWH(w, h), r[SkRRect::kUpperLeft_Corner].fX,
r[SkRRect::kUpperLeft_Corner].fY);
}
- sk_sp<GrFragmentProcessor> fp;
+ std::unique_ptr<GrFragmentProcessor> fp;
do {
GrPrimitiveEdgeType et =
(GrPrimitiveEdgeType)d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt);
@@ -684,7 +684,8 @@
//////////////////////////////////////////////////////////////////////////////
-sk_sp<GrFragmentProcessor> GrRRectEffect::Make(GrPrimitiveEdgeType edgeType, const SkRRect& rrect) {
+std::unique_ptr<GrFragmentProcessor> GrRRectEffect::Make(GrPrimitiveEdgeType edgeType,
+ const SkRRect& rrect) {
if (rrect.isRect()) {
return GrConvexPolyEffect::Make(edgeType, rrect.getBounds());
}
diff --git a/src/gpu/effects/GrRRectEffect.h b/src/gpu/effects/GrRRectEffect.h
index 6ff2cc9..fcd600a 100644
--- a/src/gpu/effects/GrRRectEffect.h
+++ b/src/gpu/effects/GrRRectEffect.h
@@ -17,11 +17,13 @@
class SkRRect;
namespace GrRRectEffect {
- /**
- * Creates an effect that performs anti-aliased clipping against a SkRRect. It doesn't support
- * all varieties of SkRRect so the caller must check for a nullptr return.
- */
- sk_sp<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkRRect&);
+
+/**
+ * Creates an effect that performs anti-aliased clipping against a SkRRect. It doesn't support
+ * all varieties of SkRRect so the caller must check for a nullptr return.
+ */
+std::unique_ptr<GrFragmentProcessor> Make(GrPrimitiveEdgeType, const SkRRect&);
+
};
#endif
diff --git a/src/gpu/effects/GrSRGBEffect.cpp b/src/gpu/effects/GrSRGBEffect.cpp
index 1cffb9e..f415a6c 100644
--- a/src/gpu/effects/GrSRGBEffect.cpp
+++ b/src/gpu/effects/GrSRGBEffect.cpp
@@ -85,7 +85,7 @@
this->initClassID<GrSRGBEffect>();
}
-sk_sp<GrFragmentProcessor> GrSRGBEffect::clone() const { return Make(fMode, fAlpha); }
+std::unique_ptr<GrFragmentProcessor> GrSRGBEffect::clone() const { return Make(fMode, fAlpha); }
bool GrSRGBEffect::onIsEqual(const GrFragmentProcessor& s) const {
const GrSRGBEffect& other = s.cast<GrSRGBEffect>();
@@ -119,7 +119,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSRGBEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrSRGBEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrSRGBEffect::TestCreate(GrProcessorTestData* d) {
Mode testMode = static_cast<Mode>(d->fRandom->nextRangeU(0, 1));
return GrSRGBEffect::Make(testMode, Alpha::kPremul);
}
diff --git a/src/gpu/effects/GrSRGBEffect.h b/src/gpu/effects/GrSRGBEffect.h
index ef6fd28..9b51fca 100644
--- a/src/gpu/effects/GrSRGBEffect.h
+++ b/src/gpu/effects/GrSRGBEffect.h
@@ -25,8 +25,8 @@
/**
* Creates an effect that applies the sRGB transfer function (or its inverse)
*/
- static sk_sp<GrFragmentProcessor> Make(Mode mode, Alpha alpha) {
- return sk_sp<GrFragmentProcessor>(new GrSRGBEffect(mode, alpha));
+ static std::unique_ptr<GrFragmentProcessor> Make(Mode mode, Alpha alpha) {
+ return std::unique_ptr<GrFragmentProcessor>(new GrSRGBEffect(mode, alpha));
}
const char* name() const override { return "sRGB"; }
@@ -34,7 +34,7 @@
Mode mode() const { return fMode; }
Alpha alpha() const { return fAlpha; }
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
private:
GrSRGBEffect(Mode mode, Alpha);
diff --git a/src/gpu/effects/GrSimpleTextureEffect.cpp b/src/gpu/effects/GrSimpleTextureEffect.cpp
index bd2b805..9a0017c 100644
--- a/src/gpu/effects/GrSimpleTextureEffect.cpp
+++ b/src/gpu/effects/GrSimpleTextureEffect.cpp
@@ -80,12 +80,13 @@
this->addTextureSampler(&fImage);
this->addCoordTransform(&fImageCoordTransform);
}
-sk_sp<GrFragmentProcessor> GrSimpleTextureEffect::clone() const {
- return sk_sp<GrFragmentProcessor>(new GrSimpleTextureEffect(*this));
+std::unique_ptr<GrFragmentProcessor> GrSimpleTextureEffect::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(new GrSimpleTextureEffect(*this));
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSimpleTextureEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrSimpleTextureEffect::TestCreate(GrProcessorTestData* testData) {
+std::unique_ptr<GrFragmentProcessor> GrSimpleTextureEffect::TestCreate(
+ GrProcessorTestData* testData) {
int texIdx = testData->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
: GrProcessorUnitTest::kAlphaTextureIdx;
static const SkShader::TileMode kTileModes[] = {
diff --git a/src/gpu/effects/GrSimpleTextureEffect.fp b/src/gpu/effects/GrSimpleTextureEffect.fp
index 6f7c818..80824fe 100644
--- a/src/gpu/effects/GrSimpleTextureEffect.fp
+++ b/src/gpu/effects/GrSimpleTextureEffect.fp
@@ -22,29 +22,29 @@
}
@make {
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
- sk_sp<GrColorSpaceXform> colorSpaceXform,
- const SkMatrix& matrix) {
- return sk_sp<GrFragmentProcessor>(
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
+ sk_sp<GrColorSpaceXform> colorSpaceXform,
+ const SkMatrix& matrix) {
+ return std::unique_ptr<GrFragmentProcessor>(
new GrSimpleTextureEffect(std::move(proxy), std::move(colorSpaceXform), matrix,
GrSamplerParams(SkShader::kClamp_TileMode, GrSamplerParams::kNone_FilterMode)));
}
/* clamp mode */
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
- sk_sp<GrColorSpaceXform> colorSpaceXform,
- const SkMatrix& matrix,
- GrSamplerParams::FilterMode filterMode) {
- return sk_sp<GrFragmentProcessor>(
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
+ sk_sp<GrColorSpaceXform> colorSpaceXform,
+ const SkMatrix& matrix,
+ GrSamplerParams::FilterMode filterMode) {
+ return std::unique_ptr<GrFragmentProcessor>(
new GrSimpleTextureEffect(std::move(proxy), std::move(colorSpaceXform), matrix,
GrSamplerParams(SkShader::kClamp_TileMode, filterMode)));
}
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
- sk_sp<GrColorSpaceXform> colorSpaceXform,
- const SkMatrix& matrix,
- const GrSamplerParams& p) {
- return sk_sp<GrFragmentProcessor>(
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
+ sk_sp<GrColorSpaceXform> colorSpaceXform,
+ const SkMatrix& matrix,
+ const GrSamplerParams& p) {
+ return std::unique_ptr<GrFragmentProcessor>(
new GrSimpleTextureEffect(std::move(proxy), std::move(colorSpaceXform), matrix, p));
}
}
diff --git a/src/gpu/effects/GrSimpleTextureEffect.h b/src/gpu/effects/GrSimpleTextureEffect.h
index 25ef1c5..11564bb 100644
--- a/src/gpu/effects/GrSimpleTextureEffect.h
+++ b/src/gpu/effects/GrSimpleTextureEffect.h
@@ -20,35 +20,35 @@
sk_sp<GrColorSpaceXform> colorXform() const { return fColorXform; }
SkMatrix44 matrix() const { return fMatrix; }
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
- sk_sp<GrColorSpaceXform>
- colorSpaceXform,
- const SkMatrix& matrix) {
- return sk_sp<GrFragmentProcessor>(new GrSimpleTextureEffect(
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
+ sk_sp<GrColorSpaceXform>
+ colorSpaceXform,
+ const SkMatrix& matrix) {
+ return std::unique_ptr<GrFragmentProcessor>(new GrSimpleTextureEffect(
std::move(proxy), std::move(colorSpaceXform), matrix,
GrSamplerParams(SkShader::kClamp_TileMode, GrSamplerParams::kNone_FilterMode)));
}
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
- sk_sp<GrColorSpaceXform>
- colorSpaceXform,
- const SkMatrix& matrix,
- GrSamplerParams::FilterMode filterMode) {
- return sk_sp<GrFragmentProcessor>(
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
+ sk_sp<GrColorSpaceXform>
+ colorSpaceXform,
+ const SkMatrix& matrix,
+ GrSamplerParams::FilterMode filterMode) {
+ return std::unique_ptr<GrFragmentProcessor>(
new GrSimpleTextureEffect(std::move(proxy), std::move(colorSpaceXform), matrix,
GrSamplerParams(SkShader::kClamp_TileMode, filterMode)));
}
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
- sk_sp<GrColorSpaceXform>
- colorSpaceXform,
- const SkMatrix& matrix,
- const GrSamplerParams& p) {
- return sk_sp<GrFragmentProcessor>(
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> proxy,
+ sk_sp<GrColorSpaceXform>
+ colorSpaceXform,
+ const SkMatrix& matrix,
+ const GrSamplerParams& p) {
+ return std::unique_ptr<GrFragmentProcessor>(
new GrSimpleTextureEffect(std::move(proxy), std::move(colorSpaceXform), matrix, p));
}
GrSimpleTextureEffect(const GrSimpleTextureEffect& src);
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
const char* name() const override { return "SimpleTextureEffect"; }
private:
diff --git a/src/gpu/effects/GrTextureDomain.cpp b/src/gpu/effects/GrTextureDomain.cpp
index ee7985c..5101762 100644
--- a/src/gpu/effects/GrTextureDomain.cpp
+++ b/src/gpu/effects/GrTextureDomain.cpp
@@ -206,21 +206,20 @@
}
}
-sk_sp<GrFragmentProcessor> GrTextureDomainEffect::Make(sk_sp<GrTextureProxy> proxy,
- sk_sp<GrColorSpaceXform> colorSpaceXform,
- const SkMatrix& matrix,
- const SkRect& domain,
- GrTextureDomain::Mode mode,
- GrSamplerParams::FilterMode filterMode) {
+std::unique_ptr<GrFragmentProcessor> GrTextureDomainEffect::Make(
+ sk_sp<GrTextureProxy> proxy,
+ sk_sp<GrColorSpaceXform> colorSpaceXform,
+ const SkMatrix& matrix,
+ const SkRect& domain,
+ GrTextureDomain::Mode mode,
+ GrSamplerParams::FilterMode filterMode) {
if (GrTextureDomain::kIgnore_Mode == mode ||
(GrTextureDomain::kClamp_Mode == mode && can_ignore_rect(proxy.get(), domain))) {
return GrSimpleTextureEffect::Make(std::move(proxy),
std::move(colorSpaceXform), matrix, filterMode);
} else {
- return sk_sp<GrFragmentProcessor>(
- new GrTextureDomainEffect(std::move(proxy),
- std::move(colorSpaceXform),
- matrix, domain, mode, filterMode));
+ return std::unique_ptr<GrFragmentProcessor>(new GrTextureDomainEffect(
+ std::move(proxy), std::move(colorSpaceXform), matrix, domain, mode, filterMode));
}
}
@@ -312,7 +311,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrTextureDomainEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrTextureDomainEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrTextureDomainEffect::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
: GrProcessorUnitTest::kAlphaTextureIdx;
sk_sp<GrTextureProxy> proxy = d->textureProxy(texIdx);
@@ -337,11 +336,9 @@
#endif
///////////////////////////////////////////////////////////////////////////////
-sk_sp<GrFragmentProcessor> GrDeviceSpaceTextureDecalFragmentProcessor::Make(
- sk_sp<GrTextureProxy> proxy,
- const SkIRect& subset,
- const SkIPoint& deviceSpaceOffset) {
- return sk_sp<GrFragmentProcessor>(new GrDeviceSpaceTextureDecalFragmentProcessor(
+std::unique_ptr<GrFragmentProcessor> GrDeviceSpaceTextureDecalFragmentProcessor::Make(
+ sk_sp<GrTextureProxy> proxy, const SkIRect& subset, const SkIPoint& deviceSpaceOffset) {
+ return std::unique_ptr<GrFragmentProcessor>(new GrDeviceSpaceTextureDecalFragmentProcessor(
std::move(proxy), subset, deviceSpaceOffset));
}
@@ -369,8 +366,9 @@
this->addTextureSampler(&fTextureSampler);
}
-sk_sp<GrFragmentProcessor> GrDeviceSpaceTextureDecalFragmentProcessor::clone() const {
- return sk_sp<GrFragmentProcessor>(new GrDeviceSpaceTextureDecalFragmentProcessor(*this));
+std::unique_ptr<GrFragmentProcessor> GrDeviceSpaceTextureDecalFragmentProcessor::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(
+ new GrDeviceSpaceTextureDecalFragmentProcessor(*this));
}
GrGLSLFragmentProcessor* GrDeviceSpaceTextureDecalFragmentProcessor::onCreateGLSLInstance() const {
@@ -441,7 +439,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDeviceSpaceTextureDecalFragmentProcessor);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrDeviceSpaceTextureDecalFragmentProcessor::TestCreate(
+std::unique_ptr<GrFragmentProcessor> GrDeviceSpaceTextureDecalFragmentProcessor::TestCreate(
GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
: GrProcessorUnitTest::kAlphaTextureIdx;
diff --git a/src/gpu/effects/GrTextureDomain.h b/src/gpu/effects/GrTextureDomain.h
index 10c2e56..0db7d2c 100644
--- a/src/gpu/effects/GrTextureDomain.h
+++ b/src/gpu/effects/GrTextureDomain.h
@@ -153,17 +153,17 @@
*/
class GrTextureDomainEffect : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy>,
- sk_sp<GrColorSpaceXform>,
- const SkMatrix&,
- const SkRect& domain,
- GrTextureDomain::Mode,
- GrSamplerParams::FilterMode filterMode);
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy>,
+ sk_sp<GrColorSpaceXform>,
+ const SkMatrix&,
+ const SkRect& domain,
+ GrTextureDomain::Mode,
+ GrSamplerParams::FilterMode filterMode);
const char* name() const override { return "TextureDomain"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new GrTextureDomainEffect(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new GrTextureDomainEffect(*this));
}
SkString dumpInfo() const override {
@@ -207,9 +207,9 @@
class GrDeviceSpaceTextureDecalFragmentProcessor : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy>,
- const SkIRect& subset,
- const SkIPoint& deviceSpaceOffset);
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy>,
+ const SkIRect& subset,
+ const SkIPoint& deviceSpaceOffset);
const char* name() const override { return "GrDeviceSpaceTextureDecalFragmentProcessor"; }
@@ -223,7 +223,7 @@
return str;
}
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
private:
TextureSampler fTextureSampler;
diff --git a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
index 490cb39..f2c026f 100644
--- a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
+++ b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
@@ -29,11 +29,11 @@
class ComposeTwoFragmentProcessor : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrFragmentProcessor> src,
- sk_sp<GrFragmentProcessor> dst,
- SkBlendMode mode) {
- return sk_sp<GrFragmentProcessor>(new ComposeTwoFragmentProcessor(std::move(src),
- std::move(dst), mode));
+ static std::unique_ptr<GrFragmentProcessor> Make(std::unique_ptr<GrFragmentProcessor> src,
+ std::unique_ptr<GrFragmentProcessor> dst,
+ SkBlendMode mode) {
+ return std::unique_ptr<GrFragmentProcessor>(
+ new ComposeTwoFragmentProcessor(std::move(src), std::move(dst), mode));
}
const char* name() const override { return "ComposeTwo"; }
@@ -50,16 +50,15 @@
return str;
}
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
SkBlendMode getMode() const { return fMode; }
private:
- ComposeTwoFragmentProcessor(sk_sp<GrFragmentProcessor> src,
- sk_sp<GrFragmentProcessor> dst,
+ ComposeTwoFragmentProcessor(std::unique_ptr<GrFragmentProcessor> src,
+ std::unique_ptr<GrFragmentProcessor> dst,
SkBlendMode mode)
- : INHERITED(OptFlags(src.get(), dst.get(), mode))
- , fMode(mode) {
+ : INHERITED(OptFlags(src.get(), dst.get(), mode)), fMode(mode) {
this->initClassID<ComposeTwoFragmentProcessor>();
SkDEBUGCODE(int shaderAChildIndex = )this->registerChildProcessor(std::move(src));
SkDEBUGCODE(int shaderBChildIndex = )this->registerChildProcessor(std::move(dst));
@@ -182,24 +181,25 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ComposeTwoFragmentProcessor);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> ComposeTwoFragmentProcessor::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> ComposeTwoFragmentProcessor::TestCreate(
+ GrProcessorTestData* d) {
// Create two random frag procs.
- sk_sp<GrFragmentProcessor> fpA(GrProcessorUnitTest::MakeChildFP(d));
- sk_sp<GrFragmentProcessor> fpB(GrProcessorUnitTest::MakeChildFP(d));
+ std::unique_ptr<GrFragmentProcessor> fpA(GrProcessorUnitTest::MakeChildFP(d));
+ std::unique_ptr<GrFragmentProcessor> fpB(GrProcessorUnitTest::MakeChildFP(d));
SkBlendMode mode;
do {
mode = static_cast<SkBlendMode>(d->fRandom->nextRangeU(0, (int)SkBlendMode::kLastMode));
} while (SkBlendMode::kClear == mode || SkBlendMode::kSrc == mode || SkBlendMode::kDst == mode);
- return sk_sp<GrFragmentProcessor>(
- new ComposeTwoFragmentProcessor(std::move(fpA), std::move(fpB), mode));
+ return std::unique_ptr<GrFragmentProcessor>(
+ new ComposeTwoFragmentProcessor(std::move(fpA), std::move(fpB), mode));
}
#endif
-sk_sp<GrFragmentProcessor> ComposeTwoFragmentProcessor::clone() const {
+std::unique_ptr<GrFragmentProcessor> ComposeTwoFragmentProcessor::clone() const {
auto src = this->childProcessor(0).clone();
auto dst = this->childProcessor(1).clone();
- return sk_sp<GrFragmentProcessor>(
+ return std::unique_ptr<GrFragmentProcessor>(
new ComposeTwoFragmentProcessor(std::move(src), std::move(dst), fMode));
}
@@ -242,8 +242,10 @@
}
}
-sk_sp<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromTwoProcessors(
- sk_sp<GrFragmentProcessor> src, sk_sp<GrFragmentProcessor> dst, SkBlendMode mode) {
+std::unique_ptr<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromTwoProcessors(
+ std::unique_ptr<GrFragmentProcessor> src,
+ std::unique_ptr<GrFragmentProcessor> dst,
+ SkBlendMode mode) {
switch (mode) {
case SkBlendMode::kClear:
return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(),
@@ -266,13 +268,13 @@
kSrc_Child,
};
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrFragmentProcessor> fp, SkBlendMode mode,
- Child child) {
+ static std::unique_ptr<GrFragmentProcessor> Make(std::unique_ptr<GrFragmentProcessor> fp,
+ SkBlendMode mode, Child child) {
if (!fp) {
return nullptr;
}
- return sk_sp<GrFragmentProcessor>(new ComposeOneFragmentProcessor(std::move(fp),
- mode, child));
+ return std::unique_ptr<GrFragmentProcessor>(
+ new ComposeOneFragmentProcessor(std::move(fp), mode, child));
}
const char* name() const override { return "ComposeOne"; }
@@ -290,7 +292,7 @@
return str;
}
- sk_sp<GrFragmentProcessor> clone() const override;
+ std::unique_ptr<GrFragmentProcessor> clone() const override;
SkBlendMode mode() const { return fMode; }
@@ -417,10 +419,9 @@
}
private:
- ComposeOneFragmentProcessor(sk_sp<GrFragmentProcessor> fp, SkBlendMode mode, Child child)
- : INHERITED(OptFlags(fp.get(), mode, child))
- , fMode(mode)
- , fChild(child) {
+ ComposeOneFragmentProcessor(std::unique_ptr<GrFragmentProcessor> fp, SkBlendMode mode,
+ Child child)
+ : INHERITED(OptFlags(fp.get(), mode, child)), fMode(mode), fChild(child) {
this->initClassID<ComposeOneFragmentProcessor>();
SkDEBUGCODE(int dstIndex =) this->registerChildProcessor(std::move(fp));
SkASSERT(0 == dstIndex);
@@ -474,11 +475,12 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ComposeOneFragmentProcessor);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> ComposeOneFragmentProcessor::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> ComposeOneFragmentProcessor::TestCreate(
+ GrProcessorTestData* d) {
// Create one random frag procs.
// For now, we'll prevent either children from being a shader with children to prevent the
// possibility of an arbitrarily large tree of procs.
- sk_sp<GrFragmentProcessor> dst(GrProcessorUnitTest::MakeChildFP(d));
+ std::unique_ptr<GrFragmentProcessor> dst(GrProcessorUnitTest::MakeChildFP(d));
SkBlendMode mode;
ComposeOneFragmentProcessor::Child child;
do {
@@ -486,7 +488,8 @@
child = d->fRandom->nextBool() ? kDst_Child : kSrc_Child;
} while (SkBlendMode::kClear == mode || (SkBlendMode::kDst == mode && child == kSrc_Child) ||
(SkBlendMode::kSrc == mode && child == kDst_Child));
- return sk_sp<GrFragmentProcessor>(new ComposeOneFragmentProcessor(std::move(dst), mode, child));
+ return std::unique_ptr<GrFragmentProcessor>(
+ new ComposeOneFragmentProcessor(std::move(dst), mode, child));
}
#endif
@@ -494,8 +497,8 @@
return new GLComposeOneFragmentProcessor;
}
-sk_sp<GrFragmentProcessor> ComposeOneFragmentProcessor::clone() const {
- return sk_sp<GrFragmentProcessor>(
+std::unique_ptr<GrFragmentProcessor> ComposeOneFragmentProcessor::clone() const {
+ return std::unique_ptr<GrFragmentProcessor>(
new ComposeOneFragmentProcessor(this->childProcessor(0).clone(), fMode, fChild));
}
@@ -507,8 +510,8 @@
// ignore the original input. This could be implemented as:
// RunInSeries(ConstColor(GrColor_WHITE, kIgnoreInput), inputFP).
-sk_sp<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromDstProcessor(
- sk_sp<GrFragmentProcessor> dst, SkBlendMode mode) {
+std::unique_ptr<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromDstProcessor(
+ std::unique_ptr<GrFragmentProcessor> dst, SkBlendMode mode) {
switch (mode) {
case SkBlendMode::kClear:
return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(),
@@ -521,8 +524,8 @@
}
}
-sk_sp<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromSrcProcessor(
- sk_sp<GrFragmentProcessor> src, SkBlendMode mode) {
+std::unique_ptr<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromSrcProcessor(
+ std::unique_ptr<GrFragmentProcessor> src, SkBlendMode mode) {
switch (mode) {
case SkBlendMode::kClear:
return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(),
diff --git a/src/gpu/effects/GrXfermodeFragmentProcessor.h b/src/gpu/effects/GrXfermodeFragmentProcessor.h
index edc5ae7..c5d0c59 100644
--- a/src/gpu/effects/GrXfermodeFragmentProcessor.h
+++ b/src/gpu/effects/GrXfermodeFragmentProcessor.h
@@ -14,22 +14,24 @@
class GrFragmentProcessor;
namespace GrXfermodeFragmentProcessor {
- /** The color input to the returned processor is treated as the src and the passed in processor
- is the dst. */
- sk_sp<GrFragmentProcessor> MakeFromDstProcessor(sk_sp<GrFragmentProcessor> dst,
- SkBlendMode mode);
- /** The color input to the returned processor is treated as the dst and the passed in processor
- is the src. */
- sk_sp<GrFragmentProcessor> MakeFromSrcProcessor(sk_sp<GrFragmentProcessor> src,
- SkBlendMode mode);
+/** The color input to the returned processor is treated as the src and the passed in processor is
+ the dst. */
+std::unique_ptr<GrFragmentProcessor> MakeFromDstProcessor(std::unique_ptr<GrFragmentProcessor> dst,
+ SkBlendMode mode);
- /** Takes the input color, which is assumed to be unpremultiplied, passes it as an opaque color
- to both src and dst. The outputs of a src and dst are blended using mode and the original
- input's alpha is applied to the blended color to produce a premul output. */
- sk_sp<GrFragmentProcessor> MakeFromTwoProcessors(sk_sp<GrFragmentProcessor> src,
- sk_sp<GrFragmentProcessor> dst,
- SkBlendMode mode);
+/** The color input to the returned processor is treated as the dst and the passed in processor is
+ the src. */
+std::unique_ptr<GrFragmentProcessor> MakeFromSrcProcessor(std::unique_ptr<GrFragmentProcessor> src,
+ SkBlendMode mode);
+
+/** Takes the input color, which is assumed to be unpremultiplied, passes it as an opaque color
+ to both src and dst. The outputs of a src and dst are blended using mode and the original
+ input's alpha is applied to the blended color to produce a premul output. */
+std::unique_ptr<GrFragmentProcessor> MakeFromTwoProcessors(std::unique_ptr<GrFragmentProcessor> src,
+ std::unique_ptr<GrFragmentProcessor> dst,
+ SkBlendMode mode);
+
};
#endif
diff --git a/src/gpu/effects/GrYUVEffect.cpp b/src/gpu/effects/GrYUVEffect.cpp
index 5b2eb7e..80e87c2 100644
--- a/src/gpu/effects/GrYUVEffect.cpp
+++ b/src/gpu/effects/GrYUVEffect.cpp
@@ -62,10 +62,11 @@
class YUVtoRGBEffect : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> yProxy,
- sk_sp<GrTextureProxy> uProxy,
- sk_sp<GrTextureProxy> vProxy, const SkISize sizes[3],
- SkYUVColorSpace colorSpace, bool nv12) {
+ static std::unique_ptr<GrFragmentProcessor> Make(sk_sp<GrTextureProxy> yProxy,
+ sk_sp<GrTextureProxy> uProxy,
+ sk_sp<GrTextureProxy> vProxy,
+ const SkISize sizes[3],
+ SkYUVColorSpace colorSpace, bool nv12) {
SkScalar w[3], h[3];
w[0] = SkIntToScalar(sizes[0].fWidth);
h[0] = SkIntToScalar(sizes[0].fHeight);
@@ -85,15 +86,15 @@
(sizes[2].fHeight != sizes[0].fHeight)) ?
GrSamplerParams::kBilerp_FilterMode :
GrSamplerParams::kNone_FilterMode;
- return sk_sp<GrFragmentProcessor>(new YUVtoRGBEffect(
- std::move(yProxy), std::move(uProxy), std::move(vProxy),
- yuvMatrix, uvFilterMode, colorSpace, nv12));
+ return std::unique_ptr<GrFragmentProcessor>(
+ new YUVtoRGBEffect(std::move(yProxy), std::move(uProxy), std::move(vProxy),
+ yuvMatrix, uvFilterMode, colorSpace, nv12));
}
const char* name() const override { return "YUV to RGB"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new YUVtoRGBEffect(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new YUVtoRGBEffect(*this));
}
SkYUVColorSpace getColorSpace() const { return fColorSpace; }
@@ -241,15 +242,16 @@
kV_OutputChannels
};
- static sk_sp<GrFragmentProcessor> Make(sk_sp<GrFragmentProcessor> rgbFP,
- SkYUVColorSpace colorSpace,
- OutputChannels output) {
- return sk_sp<GrFragmentProcessor>(new RGBToYUVEffect(std::move(rgbFP), colorSpace, output));
+ static std::unique_ptr<GrFragmentProcessor> Make(std::unique_ptr<GrFragmentProcessor> rgbFP,
+ SkYUVColorSpace colorSpace,
+ OutputChannels output) {
+ return std::unique_ptr<GrFragmentProcessor>(
+ new RGBToYUVEffect(std::move(rgbFP), colorSpace, output));
}
const char* name() const override { return "RGBToYUV"; }
- sk_sp<GrFragmentProcessor> clone() const override {
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
return Make(this->childProcessor(0).clone(), fColorSpace, fOutputChannels);
}
@@ -353,7 +355,7 @@
};
private:
- RGBToYUVEffect(sk_sp<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace,
+ RGBToYUVEffect(std::unique_ptr<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace,
OutputChannels output)
// This could advertise kConstantOutputForConstantInput, but doesn't seem useful.
: INHERITED(kPreservesOpaqueInput_OptimizationFlag)
@@ -393,42 +395,40 @@
//////////////////////////////////////////////////////////////////////////////
-sk_sp<GrFragmentProcessor> GrYUVEffect::MakeYUVToRGB(sk_sp<GrTextureProxy> yProxy,
- sk_sp<GrTextureProxy> uProxy,
- sk_sp<GrTextureProxy> vProxy,
- const SkISize sizes[3],
- SkYUVColorSpace colorSpace, bool nv12) {
+std::unique_ptr<GrFragmentProcessor> GrYUVEffect::MakeYUVToRGB(
+ sk_sp<GrTextureProxy> yProxy, sk_sp<GrTextureProxy> uProxy, sk_sp<GrTextureProxy> vProxy,
+ const SkISize sizes[3], SkYUVColorSpace colorSpace, bool nv12) {
SkASSERT(yProxy && uProxy && vProxy && sizes);
return YUVtoRGBEffect::Make(std::move(yProxy), std::move(uProxy), std::move(vProxy),
sizes, colorSpace, nv12);
}
-sk_sp<GrFragmentProcessor>
-GrYUVEffect::MakeRGBToYUV(sk_sp<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
+std::unique_ptr<GrFragmentProcessor> GrYUVEffect::MakeRGBToYUV(
+ std::unique_ptr<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
SkASSERT(rgbFP);
return RGBToYUVEffect::Make(std::move(rgbFP), colorSpace, RGBToYUVEffect::kYUV_OutputChannels);
}
-sk_sp<GrFragmentProcessor>
-GrYUVEffect::MakeRGBToY(sk_sp<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
+std::unique_ptr<GrFragmentProcessor> GrYUVEffect::MakeRGBToY(
+ std::unique_ptr<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
SkASSERT(rgbFP);
return RGBToYUVEffect::Make(std::move(rgbFP), colorSpace, RGBToYUVEffect::kY_OutputChannels);
}
-sk_sp<GrFragmentProcessor>
-GrYUVEffect::MakeRGBToUV(sk_sp<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
+std::unique_ptr<GrFragmentProcessor> GrYUVEffect::MakeRGBToUV(
+ std::unique_ptr<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
SkASSERT(rgbFP);
return RGBToYUVEffect::Make(std::move(rgbFP), colorSpace, RGBToYUVEffect::kUV_OutputChannels);
}
-sk_sp<GrFragmentProcessor>
-GrYUVEffect::MakeRGBToU(sk_sp<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
+std::unique_ptr<GrFragmentProcessor> GrYUVEffect::MakeRGBToU(
+ std::unique_ptr<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
SkASSERT(rgbFP);
return RGBToYUVEffect::Make(std::move(rgbFP), colorSpace, RGBToYUVEffect::kU_OutputChannels);
}
-sk_sp<GrFragmentProcessor>
-GrYUVEffect::MakeRGBToV(sk_sp<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
+std::unique_ptr<GrFragmentProcessor> GrYUVEffect::MakeRGBToV(
+ std::unique_ptr<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace) {
SkASSERT(rgbFP);
return RGBToYUVEffect::Make(std::move(rgbFP), colorSpace, RGBToYUVEffect::kV_OutputChannels);
}
diff --git a/src/gpu/effects/GrYUVEffect.h b/src/gpu/effects/GrYUVEffect.h
index ae62a16..2ea41bf 100644
--- a/src/gpu/effects/GrYUVEffect.h
+++ b/src/gpu/effects/GrYUVEffect.h
@@ -18,32 +18,38 @@
* Creates an effect that performs color conversion from YUV to RGB. The input textures are
* assumed to be kA8_GrPixelConfig.
*/
- sk_sp<GrFragmentProcessor> MakeYUVToRGB(sk_sp<GrTextureProxy> yProxy,
- sk_sp<GrTextureProxy> uProxy,
- sk_sp<GrTextureProxy> vProxy, const SkISize sizes[3],
- SkYUVColorSpace colorSpace, bool nv12);
+std::unique_ptr<GrFragmentProcessor> MakeYUVToRGB(sk_sp<GrTextureProxy> yProxy,
+ sk_sp<GrTextureProxy> uProxy,
+ sk_sp<GrTextureProxy> vProxy,
+ const SkISize sizes[3],
+ SkYUVColorSpace colorSpace, bool nv12);
- /**
- * Creates a processor that performs color conversion from the passed in processor's RGB
- * channels to Y, U ,and V channels. The output color is (y, u, v, a) where a is the passed in
- * processor's alpha output.
- */
- sk_sp<GrFragmentProcessor> MakeRGBToYUV(sk_sp<GrFragmentProcessor>, SkYUVColorSpace);
+/**
+ * Creates a processor that performs color conversion from the passed in processor's RGB
+ * channels to Y, U ,and V channels. The output color is (y, u, v, a) where a is the passed in
+ * processor's alpha output.
+ */
+std::unique_ptr<GrFragmentProcessor> MakeRGBToYUV(std::unique_ptr<GrFragmentProcessor>,
+ SkYUVColorSpace);
- /**
- * Creates a processor that performs color conversion from the passed in processor's RGB
- * channels to U and V channels. The output color is (u, v, 0, a) where a is the passed in
- * processor's alpha output.
- */
- sk_sp<GrFragmentProcessor> MakeRGBToUV(sk_sp<GrFragmentProcessor>, SkYUVColorSpace);
- /**
- * Creates a processor that performs color conversion from the passed in fragment processors's
- * RGB channels to Y, U, or V (replicated across all four output color channels). The alpha
- * output of the passed in fragment processor is ignored.
- */
- sk_sp<GrFragmentProcessor> MakeRGBToY(sk_sp<GrFragmentProcessor>, SkYUVColorSpace);
- sk_sp<GrFragmentProcessor> MakeRGBToU(sk_sp<GrFragmentProcessor>, SkYUVColorSpace);
- sk_sp<GrFragmentProcessor> MakeRGBToV(sk_sp<GrFragmentProcessor>, SkYUVColorSpace);
+/**
+ * Creates a processor that performs color conversion from the passed in processor's RGB
+ * channels to U and V channels. The output color is (u, v, 0, a) where a is the passed in
+ * processor's alpha output.
+ */
+std::unique_ptr<GrFragmentProcessor> MakeRGBToUV(std::unique_ptr<GrFragmentProcessor>,
+ SkYUVColorSpace);
+/**
+ * Creates a processor that performs color conversion from the passed in fragment processors's
+ * RGB channels to Y, U, or V (replicated across all four output color channels). The alpha
+ * output of the passed in fragment processor is ignored.
+ */
+std::unique_ptr<GrFragmentProcessor> MakeRGBToY(std::unique_ptr<GrFragmentProcessor>,
+ SkYUVColorSpace);
+std::unique_ptr<GrFragmentProcessor> MakeRGBToU(std::unique_ptr<GrFragmentProcessor>,
+ SkYUVColorSpace);
+std::unique_ptr<GrFragmentProcessor> MakeRGBToV(std::unique_ptr<GrFragmentProcessor>,
+ SkYUVColorSpace);
};
#endif
diff --git a/src/shaders/SkColorFilterShader.cpp b/src/shaders/SkColorFilterShader.cpp
index a2d5433..bacfc37 100644
--- a/src/shaders/SkColorFilterShader.cpp
+++ b/src/shaders/SkColorFilterShader.cpp
@@ -56,20 +56,19 @@
#if SK_SUPPORT_GPU
/////////////////////////////////////////////////////////////////////
-sk_sp<GrFragmentProcessor> SkColorFilterShader::asFragmentProcessor(const AsFPArgs& args) const {
-
- sk_sp<GrFragmentProcessor> fp1(as_SB(fShader)->asFragmentProcessor(args));
+std::unique_ptr<GrFragmentProcessor> SkColorFilterShader::asFragmentProcessor(
+ const AsFPArgs& args) const {
+ auto fp1 = as_SB(fShader)->asFragmentProcessor(args);
if (!fp1) {
return nullptr;
}
- sk_sp<GrFragmentProcessor> fp2(fFilter->asFragmentProcessor(args.fContext,
- args.fDstColorSpace));
+ auto fp2 = fFilter->asFragmentProcessor(args.fContext, args.fDstColorSpace);
if (!fp2) {
return fp1;
}
- sk_sp<GrFragmentProcessor> fpSeries[] = { std::move(fp1), std::move(fp2) };
+ std::unique_ptr<GrFragmentProcessor> fpSeries[] = { std::move(fp1), std::move(fp2) };
return GrFragmentProcessor::RunInSeries(fpSeries, 2);
}
#endif
diff --git a/src/shaders/SkColorFilterShader.h b/src/shaders/SkColorFilterShader.h
index 3a1878f..9cd199e 100644
--- a/src/shaders/SkColorFilterShader.h
+++ b/src/shaders/SkColorFilterShader.h
@@ -18,7 +18,7 @@
SkColorFilterShader(sk_sp<SkShader> shader, sk_sp<SkColorFilter> filter);
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
#endif
SK_TO_STRING_OVERRIDE()
diff --git a/src/shaders/SkColorShader.cpp b/src/shaders/SkColorShader.cpp
index e718cb0..33ebc53 100644
--- a/src/shaders/SkColorShader.cpp
+++ b/src/shaders/SkColorShader.cpp
@@ -89,7 +89,8 @@
#include "SkGr.h"
#include "effects/GrConstColorProcessor.h"
-sk_sp<GrFragmentProcessor> SkColorShader::asFragmentProcessor(const AsFPArgs& args) const {
+std::unique_ptr<GrFragmentProcessor> SkColorShader::asFragmentProcessor(
+ const AsFPArgs& args) const {
GrColor4f color = SkColorToPremulGrColor4f(fColor, args.fDstColorSpace);
return GrConstColorProcessor::Make(color, GrConstColorProcessor::kModulateA_InputMode);
}
@@ -206,7 +207,8 @@
#include "SkGr.h"
#include "effects/GrConstColorProcessor.h"
#include "GrColorSpaceXform.h"
-sk_sp<GrFragmentProcessor> SkColor4Shader::asFragmentProcessor(const AsFPArgs& args) const {
+std::unique_ptr<GrFragmentProcessor> SkColor4Shader::asFragmentProcessor(
+ const AsFPArgs& args) const {
sk_sp<GrColorSpaceXform> colorSpaceXform = GrColorSpaceXform::Make(fColorSpace.get(),
args.fDstColorSpace);
GrColor4f color = GrColor4f::FromSkColor4f(fColor4);
diff --git a/src/shaders/SkColorShader.h b/src/shaders/SkColorShader.h
index f1bd478..7d035f5 100644
--- a/src/shaders/SkColorShader.h
+++ b/src/shaders/SkColorShader.h
@@ -47,7 +47,7 @@
GradientType asAGradient(GradientInfo* info) const override;
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
#endif
SK_TO_STRING_OVERRIDE()
@@ -104,7 +104,7 @@
GradientType asAGradient(GradientInfo* info) const override;
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
#endif
SK_TO_STRING_OVERRIDE()
diff --git a/src/shaders/SkComposeShader.cpp b/src/shaders/SkComposeShader.cpp
index 7b37140..9799a1c 100644
--- a/src/shaders/SkComposeShader.cpp
+++ b/src/shaders/SkComposeShader.cpp
@@ -125,7 +125,8 @@
/////////////////////////////////////////////////////////////////////
-sk_sp<GrFragmentProcessor> SkComposeShader::asFragmentProcessor(const AsFPArgs& args) const {
+std::unique_ptr<GrFragmentProcessor> SkComposeShader::asFragmentProcessor(
+ const AsFPArgs& args) const {
if (this->isJustMode()) {
SkASSERT(fMode != SkBlendMode::kSrc && fMode != SkBlendMode::kDst); // caught in factory
if (fMode == SkBlendMode::kClear) {
@@ -134,11 +135,11 @@
}
}
- sk_sp<GrFragmentProcessor> fpA(as_SB(fDst)->asFragmentProcessor(args));
+ std::unique_ptr<GrFragmentProcessor> fpA(as_SB(fDst)->asFragmentProcessor(args));
if (!fpA) {
return nullptr;
}
- sk_sp<GrFragmentProcessor> fpB(as_SB(fSrc)->asFragmentProcessor(args));
+ std::unique_ptr<GrFragmentProcessor> fpB(as_SB(fSrc)->asFragmentProcessor(args));
if (!fpB) {
return nullptr;
}
diff --git a/src/shaders/SkComposeShader.h b/src/shaders/SkComposeShader.h
index 1389742..34abf62 100644
--- a/src/shaders/SkComposeShader.h
+++ b/src/shaders/SkComposeShader.h
@@ -23,7 +23,7 @@
}
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
#endif
#ifdef SK_DEBUGx
diff --git a/src/shaders/SkImageShader.cpp b/src/shaders/SkImageShader.cpp
index 609ad4b..edd1f41 100644
--- a/src/shaders/SkImageShader.cpp
+++ b/src/shaders/SkImageShader.cpp
@@ -167,8 +167,8 @@
#include "effects/GrBicubicEffect.h"
#include "effects/GrSimpleTextureEffect.h"
-sk_sp<GrFragmentProcessor> SkImageShader::asFragmentProcessor(const AsFPArgs& args) const {
-
+std::unique_ptr<GrFragmentProcessor> SkImageShader::asFragmentProcessor(
+ const AsFPArgs& args) const {
SkMatrix lmInverse;
if (!this->getLocalMatrix().invert(&lmInverse)) {
return nullptr;
@@ -207,7 +207,7 @@
sk_sp<GrColorSpaceXform> colorSpaceXform = GrColorSpaceXform::Make(texColorSpace.get(),
args.fDstColorSpace);
- sk_sp<GrFragmentProcessor> inner;
+ std::unique_ptr<GrFragmentProcessor> inner;
if (doBicubic) {
inner = GrBicubicEffect::Make(std::move(proxy),
std::move(colorSpaceXform), lmInverse, tm);
@@ -219,7 +219,7 @@
if (isAlphaOnly) {
return inner;
}
- return sk_sp<GrFragmentProcessor>(GrFragmentProcessor::MulOutputByInputAlpha(std::move(inner)));
+ return GrFragmentProcessor::MulOutputByInputAlpha(std::move(inner));
}
#endif
diff --git a/src/shaders/SkImageShader.h b/src/shaders/SkImageShader.h
index b499b92..8e592e5 100644
--- a/src/shaders/SkImageShader.h
+++ b/src/shaders/SkImageShader.h
@@ -24,7 +24,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkImageShader)
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
#endif
SkImageShader(sk_sp<SkImage>, TileMode tx, TileMode ty, const SkMatrix* localMatrix);
diff --git a/src/shaders/SkLocalMatrixShader.cpp b/src/shaders/SkLocalMatrixShader.cpp
index e21e4a8..254092d 100644
--- a/src/shaders/SkLocalMatrixShader.cpp
+++ b/src/shaders/SkLocalMatrixShader.cpp
@@ -12,7 +12,8 @@
#endif
#if SK_SUPPORT_GPU
-sk_sp<GrFragmentProcessor> SkLocalMatrixShader::asFragmentProcessor(const AsFPArgs& args) const {
+std::unique_ptr<GrFragmentProcessor> SkLocalMatrixShader::asFragmentProcessor(
+ const AsFPArgs& args) const {
SkMatrix tmp = this->getLocalMatrix();
if (args.fLocalMatrix) {
tmp.preConcat(*args.fLocalMatrix);
diff --git a/src/shaders/SkLocalMatrixShader.h b/src/shaders/SkLocalMatrixShader.h
index 3ae44cf..407c30d 100644
--- a/src/shaders/SkLocalMatrixShader.h
+++ b/src/shaders/SkLocalMatrixShader.h
@@ -28,7 +28,7 @@
}
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
#endif
sk_sp<SkShader> makeAsALocalMatrixShader(SkMatrix* localMatrix) const override {
diff --git a/src/shaders/SkPerlinNoiseShader.cpp b/src/shaders/SkPerlinNoiseShader.cpp
index 0ce007a..cc9a569 100644
--- a/src/shaders/SkPerlinNoiseShader.cpp
+++ b/src/shaders/SkPerlinNoiseShader.cpp
@@ -350,7 +350,7 @@
};
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
#endif
SK_TO_STRING_OVERRIDE()
@@ -693,22 +693,20 @@
class GrPerlinNoise2Effect : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(SkPerlinNoiseShaderImpl::Type type,
- int numOctaves, bool stitchTiles,
- std::unique_ptr<SkPerlinNoiseShaderImpl::PaintingData> paintingData,
- sk_sp<GrTextureProxy> permutationsProxy,
- sk_sp<GrTextureProxy> noiseProxy,
- const SkMatrix& matrix) {
- return sk_sp<GrFragmentProcessor>(
- new GrPerlinNoise2Effect(type, numOctaves, stitchTiles,
- std::move(paintingData),
- std::move(permutationsProxy), std::move(noiseProxy), matrix));
+ static std::unique_ptr<GrFragmentProcessor> Make(
+ SkPerlinNoiseShaderImpl::Type type, int numOctaves, bool stitchTiles,
+ std::unique_ptr<SkPerlinNoiseShaderImpl::PaintingData> paintingData,
+ sk_sp<GrTextureProxy> permutationsProxy, sk_sp<GrTextureProxy> noiseProxy,
+ const SkMatrix& matrix) {
+ return std::unique_ptr<GrFragmentProcessor>(new GrPerlinNoise2Effect(
+ type, numOctaves, stitchTiles, std::move(paintingData),
+ std::move(permutationsProxy), std::move(noiseProxy), matrix));
}
const char* name() const override { return "PerlinNoise"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new GrPerlinNoise2Effect(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new GrPerlinNoise2Effect(*this));
}
const SkPerlinNoiseShaderImpl::StitchData& stitchData() const { return fPaintingData->fStitchDataInit; }
@@ -789,7 +787,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrPerlinNoise2Effect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrPerlinNoise2Effect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrPerlinNoise2Effect::TestCreate(GrProcessorTestData* d) {
int numOctaves = d->fRandom->nextRangeU(2, 10);
bool stitchTiles = d->fRandom->nextBool();
SkScalar seed = SkIntToScalar(d->fRandom->nextU());
@@ -1128,21 +1126,20 @@
class GrImprovedPerlinNoiseEffect : public GrFragmentProcessor {
public:
- static sk_sp<GrFragmentProcessor> Make(int octaves, SkScalar z,
- std::unique_ptr<SkPerlinNoiseShaderImpl::PaintingData> paintingData,
- sk_sp<GrTextureProxy> permutationsProxy,
- sk_sp<GrTextureProxy> gradientProxy,
- const SkMatrix& matrix) {
- return sk_sp<GrFragmentProcessor>(
- new GrImprovedPerlinNoiseEffect(octaves, z, std::move(paintingData),
- std::move(permutationsProxy),
- std::move(gradientProxy), matrix));
+ static std::unique_ptr<GrFragmentProcessor> Make(
+ int octaves, SkScalar z,
+ std::unique_ptr<SkPerlinNoiseShaderImpl::PaintingData> paintingData,
+ sk_sp<GrTextureProxy> permutationsProxy, sk_sp<GrTextureProxy> gradientProxy,
+ const SkMatrix& matrix) {
+ return std::unique_ptr<GrFragmentProcessor>(new GrImprovedPerlinNoiseEffect(
+ octaves, z, std::move(paintingData), std::move(permutationsProxy),
+ std::move(gradientProxy), matrix));
}
const char* name() const override { return "ImprovedPerlinNoise"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new GrImprovedPerlinNoiseEffect(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new GrImprovedPerlinNoiseEffect(*this));
}
const SkVector& baseFrequency() const { return fPaintingData->fBaseFrequency; }
@@ -1213,7 +1210,8 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrImprovedPerlinNoiseEffect);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrImprovedPerlinNoiseEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrImprovedPerlinNoiseEffect::TestCreate(
+ GrProcessorTestData* d) {
SkScalar baseFrequencyX = d->fRandom->nextRangeScalar(0.01f,
0.99f);
SkScalar baseFrequencyY = d->fRandom->nextRangeScalar(0.01f,
@@ -1387,7 +1385,8 @@
}
/////////////////////////////////////////////////////////////////////
-sk_sp<GrFragmentProcessor> SkPerlinNoiseShaderImpl::asFragmentProcessor(const AsFPArgs& args) const {
+std::unique_ptr<GrFragmentProcessor> SkPerlinNoiseShaderImpl::asFragmentProcessor(
+ const AsFPArgs& args) const {
SkASSERT(args.fContext);
SkMatrix localMatrix = this->getLocalMatrix();
@@ -1434,9 +1433,9 @@
// TODO: Either treat the output of this shader as sRGB or allow client to specify a
// color space of the noise. Either way, this case (and the GLSL) need to convert to
// the destination.
- sk_sp<GrFragmentProcessor> inner(
- GrConstColorProcessor::Make(GrColor4f::FromGrColor(0x80404040),
- GrConstColorProcessor::kModulateRGBA_InputMode));
+ auto inner =
+ GrConstColorProcessor::Make(GrColor4f::FromGrColor(0x80404040),
+ GrConstColorProcessor::kModulateRGBA_InputMode);
return GrFragmentProcessor::MulOutputByInputAlpha(std::move(inner));
}
// Emit zero.
@@ -1451,14 +1450,13 @@
paintingData->getNoiseBitmap());
if (permutationsProxy && noiseProxy) {
- sk_sp<GrFragmentProcessor> inner(
- GrPerlinNoise2Effect::Make(fType,
- fNumOctaves,
- fStitchTiles,
- std::move(paintingData),
- std::move(permutationsProxy),
- std::move(noiseProxy),
- m));
+ auto inner = GrPerlinNoise2Effect::Make(fType,
+ fNumOctaves,
+ fStitchTiles,
+ std::move(paintingData),
+ std::move(permutationsProxy),
+ std::move(noiseProxy),
+ m);
return GrFragmentProcessor::MulOutputByInputAlpha(std::move(inner));
}
return nullptr;
diff --git a/src/shaders/SkPictureShader.cpp b/src/shaders/SkPictureShader.cpp
index 4c746ee..a14c211 100644
--- a/src/shaders/SkPictureShader.cpp
+++ b/src/shaders/SkPictureShader.cpp
@@ -373,7 +373,8 @@
#endif
#if SK_SUPPORT_GPU
-sk_sp<GrFragmentProcessor> SkPictureShader::asFragmentProcessor(const AsFPArgs& args) const {
+std::unique_ptr<GrFragmentProcessor> SkPictureShader::asFragmentProcessor(
+ const AsFPArgs& args) const {
int maxTextureSize = 0;
if (args.fContext) {
maxTextureSize = args.fContext->caps()->maxTextureSize();
diff --git a/src/shaders/SkPictureShader.h b/src/shaders/SkPictureShader.h
index 3d58d6d..ee1ffb5 100644
--- a/src/shaders/SkPictureShader.h
+++ b/src/shaders/SkPictureShader.h
@@ -32,7 +32,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPictureShader)
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
#endif
protected:
diff --git a/src/shaders/SkShader.cpp b/src/shaders/SkShader.cpp
index 5540b2d..d288054 100644
--- a/src/shaders/SkShader.cpp
+++ b/src/shaders/SkShader.cpp
@@ -163,7 +163,7 @@
}
#if SK_SUPPORT_GPU
-sk_sp<GrFragmentProcessor> SkShaderBase::asFragmentProcessor(const AsFPArgs&) const {
+std::unique_ptr<GrFragmentProcessor> SkShaderBase::asFragmentProcessor(const AsFPArgs&) const {
return nullptr;
}
#endif
diff --git a/src/shaders/SkShaderBase.h b/src/shaders/SkShaderBase.h
index 99cace2..8f64efe 100644
--- a/src/shaders/SkShaderBase.h
+++ b/src/shaders/SkShaderBase.h
@@ -167,7 +167,7 @@
* The returned GrFragmentProcessor should expect an unpremultiplied input color and
* produce a premultiplied output.
*/
- virtual sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const;
+ virtual std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const;
#endif
/**
diff --git a/src/shaders/gradients/SkLinearGradient.cpp b/src/shaders/gradients/SkLinearGradient.cpp
index 0ed5350..551368b 100644
--- a/src/shaders/gradients/SkLinearGradient.cpp
+++ b/src/shaders/gradients/SkLinearGradient.cpp
@@ -333,15 +333,15 @@
public:
class GLSLLinearProcessor;
- static sk_sp<GrFragmentProcessor> Make(const CreateArgs& args) {
- auto processor = sk_sp<GrLinearGradient>(new GrLinearGradient(args));
+ static std::unique_ptr<GrFragmentProcessor> Make(const CreateArgs& args) {
+ auto processor = std::unique_ptr<GrLinearGradient>(new GrLinearGradient(args));
return processor->isValid() ? std::move(processor) : nullptr;
}
const char* name() const override { return "Linear Gradient"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new GrLinearGradient(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new GrLinearGradient(*this));
}
private:
@@ -396,7 +396,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrLinearGradient);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrLinearGradient::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrLinearGradient::TestCreate(GrProcessorTestData* d) {
SkPoint points[] = {{d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()},
{d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()}};
@@ -407,7 +407,7 @@
SkGradientShader::MakeLinear(points, params.fColors, params.fStops,
params.fColorCount, params.fTileMode);
GrTest::TestAsFPArgs asFPArgs(d);
- sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
+ std::unique_ptr<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
GrAlwaysAssert(fp);
return fp;
}
@@ -432,7 +432,8 @@
/////////////////////////////////////////////////////////////////////
-sk_sp<GrFragmentProcessor> SkLinearGradient::asFragmentProcessor(const AsFPArgs& args) const {
+std::unique_ptr<GrFragmentProcessor> SkLinearGradient::asFragmentProcessor(
+ const AsFPArgs& args) const {
SkASSERT(args.fContext);
SkMatrix matrix;
@@ -450,9 +451,9 @@
sk_sp<GrColorSpaceXform> colorSpaceXform = GrColorSpaceXform::Make(fColorSpace.get(),
args.fDstColorSpace);
- sk_sp<GrFragmentProcessor> inner(GrLinearGradient::Make(
- GrGradientEffect::CreateArgs(args.fContext, this, &matrix, fTileMode,
- std::move(colorSpaceXform), SkToBool(args.fDstColorSpace))));
+ auto inner = GrLinearGradient::Make(GrGradientEffect::CreateArgs(
+ args.fContext, this, &matrix, fTileMode, std::move(colorSpaceXform),
+ SkToBool(args.fDstColorSpace)));
if (!inner) {
return nullptr;
}
diff --git a/src/shaders/gradients/SkLinearGradient.h b/src/shaders/gradients/SkLinearGradient.h
index c0ba7f4..64db9dc 100644
--- a/src/shaders/gradients/SkLinearGradient.h
+++ b/src/shaders/gradients/SkLinearGradient.h
@@ -52,7 +52,7 @@
GradientType asAGradient(GradientInfo* info) const override;
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
#endif
SK_TO_STRING_OVERRIDE()
diff --git a/src/shaders/gradients/SkRadialGradient.cpp b/src/shaders/gradients/SkRadialGradient.cpp
index 02086ea..94d823c 100644
--- a/src/shaders/gradients/SkRadialGradient.cpp
+++ b/src/shaders/gradients/SkRadialGradient.cpp
@@ -68,15 +68,15 @@
public:
class GLSLRadialProcessor;
- static sk_sp<GrFragmentProcessor> Make(const CreateArgs& args) {
- auto processor = sk_sp<GrRadialGradient>(new GrRadialGradient(args));
+ static std::unique_ptr<GrFragmentProcessor> Make(const CreateArgs& args) {
+ auto processor = std::unique_ptr<GrRadialGradient>(new GrRadialGradient(args));
return processor->isValid() ? std::move(processor) : nullptr;
}
const char* name() const override { return "Radial Gradient"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new GrRadialGradient(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new GrRadialGradient(*this));
}
private:
@@ -132,7 +132,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRadialGradient);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrRadialGradient::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrRadialGradient::TestCreate(GrProcessorTestData* d) {
sk_sp<SkShader> shader;
do {
RandomGradientParams params(d->fRandom);
@@ -147,7 +147,7 @@
params.fTileMode);
} while (!shader);
GrTest::TestAsFPArgs asFPArgs(d);
- sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
+ std::unique_ptr<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
GrAlwaysAssert(fp);
return fp;
}
@@ -172,7 +172,8 @@
/////////////////////////////////////////////////////////////////////
-sk_sp<GrFragmentProcessor> SkRadialGradient::asFragmentProcessor(const AsFPArgs& args) const {
+std::unique_ptr<GrFragmentProcessor> SkRadialGradient::asFragmentProcessor(
+ const AsFPArgs& args) const {
SkASSERT(args.fContext);
SkMatrix matrix;
@@ -189,9 +190,9 @@
matrix.postConcat(fPtsToUnit);
sk_sp<GrColorSpaceXform> colorSpaceXform = GrColorSpaceXform::Make(fColorSpace.get(),
args.fDstColorSpace);
- sk_sp<GrFragmentProcessor> inner(GrRadialGradient::Make(
- GrGradientEffect::CreateArgs(args.fContext, this, &matrix, fTileMode,
- std::move(colorSpaceXform), SkToBool(args.fDstColorSpace))));
+ auto inner = GrRadialGradient::Make(GrGradientEffect::CreateArgs(
+ args.fContext, this, &matrix, fTileMode, std::move(colorSpaceXform),
+ SkToBool(args.fDstColorSpace)));
if (!inner) {
return nullptr;
}
diff --git a/src/shaders/gradients/SkRadialGradient.h b/src/shaders/gradients/SkRadialGradient.h
index 8cd7df2..6a6dadf 100644
--- a/src/shaders/gradients/SkRadialGradient.h
+++ b/src/shaders/gradients/SkRadialGradient.h
@@ -16,7 +16,7 @@
GradientType asAGradient(GradientInfo* info) const override;
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
#endif
SK_TO_STRING_OVERRIDE()
diff --git a/src/shaders/gradients/SkSweepGradient.cpp b/src/shaders/gradients/SkSweepGradient.cpp
index 011474c..87b82fd 100644
--- a/src/shaders/gradients/SkSweepGradient.cpp
+++ b/src/shaders/gradients/SkSweepGradient.cpp
@@ -74,16 +74,16 @@
public:
class GLSLSweepProcessor;
- static sk_sp<GrFragmentProcessor> Make(const CreateArgs& args, SkScalar tBias,
- SkScalar tScale) {
- auto processor = sk_sp<GrSweepGradient>(new GrSweepGradient(args, tBias, tScale));
+ static std::unique_ptr<GrFragmentProcessor> Make(const CreateArgs& args, SkScalar tBias,
+ SkScalar tScale) {
+ auto processor = std::unique_ptr<GrSweepGradient>(new GrSweepGradient(args, tBias, tScale));
return processor->isValid() ? std::move(processor) : nullptr;
}
const char* name() const override { return "Sweep Gradient"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new GrSweepGradient(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new GrSweepGradient(*this));
}
private:
@@ -176,7 +176,7 @@
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSweepGradient);
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> GrSweepGradient::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> GrSweepGradient::TestCreate(GrProcessorTestData* d) {
SkPoint center = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
RandomGradientParams params(d->fRandom);
@@ -186,7 +186,7 @@
SkGradientShader::MakeSweep(center.fX, center.fY, params.fColors,
params.fStops, params.fColorCount);
GrTest::TestAsFPArgs asFPArgs(d);
- sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
+ std::unique_ptr<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
GrAlwaysAssert(fp);
return fp;
}
@@ -229,8 +229,8 @@
/////////////////////////////////////////////////////////////////////
-sk_sp<GrFragmentProcessor> SkSweepGradient::asFragmentProcessor(const AsFPArgs& args) const {
-
+std::unique_ptr<GrFragmentProcessor> SkSweepGradient::asFragmentProcessor(
+ const AsFPArgs& args) const {
SkMatrix matrix;
if (!this->getLocalMatrix().invert(&matrix)) {
return nullptr;
@@ -246,10 +246,10 @@
sk_sp<GrColorSpaceXform> colorSpaceXform = GrColorSpaceXform::Make(fColorSpace.get(),
args.fDstColorSpace);
- sk_sp<GrFragmentProcessor> inner(GrSweepGradient::Make(
- GrGradientEffect::CreateArgs(args.fContext, this, &matrix, fTileMode,
- std::move(colorSpaceXform), SkToBool(args.fDstColorSpace)),
- fTBias, fTScale));
+ auto inner = GrSweepGradient::Make(
+ GrGradientEffect::CreateArgs(args.fContext, this, &matrix, fTileMode,
+ std::move(colorSpaceXform), SkToBool(args.fDstColorSpace)),
+ fTBias, fTScale);
if (!inner) {
return nullptr;
}
diff --git a/src/shaders/gradients/SkSweepGradient.h b/src/shaders/gradients/SkSweepGradient.h
index b42f270..061d699 100644
--- a/src/shaders/gradients/SkSweepGradient.h
+++ b/src/shaders/gradients/SkSweepGradient.h
@@ -17,7 +17,7 @@
GradientType asAGradient(GradientInfo* info) const override;
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
#endif
SK_TO_STRING_OVERRIDE()
diff --git a/src/shaders/gradients/SkTwoPointConicalGradient.cpp b/src/shaders/gradients/SkTwoPointConicalGradient.cpp
index 0bee74f..a163472 100644
--- a/src/shaders/gradients/SkTwoPointConicalGradient.cpp
+++ b/src/shaders/gradients/SkTwoPointConicalGradient.cpp
@@ -133,14 +133,14 @@
#include "SkGr.h"
#include "SkTwoPointConicalGradient_gpu.h"
-sk_sp<GrFragmentProcessor> SkTwoPointConicalGradient::asFragmentProcessor(
+std::unique_ptr<GrFragmentProcessor> SkTwoPointConicalGradient::asFragmentProcessor(
const AsFPArgs& args) const {
SkASSERT(args.fContext);
sk_sp<GrColorSpaceXform> colorSpaceXform = GrColorSpaceXform::Make(fColorSpace.get(),
args.fDstColorSpace);
- sk_sp<GrFragmentProcessor> inner(Gr2PtConicalGradientEffect::Make(
- GrGradientEffect::CreateArgs(args.fContext, this, args.fLocalMatrix, fTileMode,
- std::move(colorSpaceXform), SkToBool(args.fDstColorSpace))));
+ auto inner = Gr2PtConicalGradientEffect::Make(GrGradientEffect::CreateArgs(
+ args.fContext, this, args.fLocalMatrix, fTileMode, std::move(colorSpaceXform),
+ SkToBool(args.fDstColorSpace)));
if (!inner) {
return nullptr;
}
diff --git a/src/shaders/gradients/SkTwoPointConicalGradient.h b/src/shaders/gradients/SkTwoPointConicalGradient.h
index 408f31d..4b28271 100644
--- a/src/shaders/gradients/SkTwoPointConicalGradient.h
+++ b/src/shaders/gradients/SkTwoPointConicalGradient.h
@@ -19,7 +19,7 @@
SkShader::GradientType asAGradient(GradientInfo* info) const override;
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
#endif
bool isOpaque() const override;
diff --git a/src/shaders/gradients/SkTwoPointConicalGradient_gpu.cpp b/src/shaders/gradients/SkTwoPointConicalGradient_gpu.cpp
index 8263f88..caada92 100644
--- a/src/shaders/gradients/SkTwoPointConicalGradient_gpu.cpp
+++ b/src/shaders/gradients/SkTwoPointConicalGradient_gpu.cpp
@@ -61,8 +61,8 @@
public:
class GLSLEdge2PtConicalProcessor;
- static sk_sp<GrFragmentProcessor> Make(const CreateArgs& args) {
- auto processor = sk_sp<Edge2PtConicalEffect>(new Edge2PtConicalEffect(args));
+ static std::unique_ptr<GrFragmentProcessor> Make(const CreateArgs& args) {
+ auto processor = std::unique_ptr<Edge2PtConicalEffect>(new Edge2PtConicalEffect(args));
return processor->isValid() ? std::move(processor) : nullptr;
}
@@ -75,8 +75,8 @@
SkScalar diffRadius() const { return fDiffRadius; }
SkScalar radius() const { return fRadius0; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new Edge2PtConicalEffect(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new Edge2PtConicalEffect(*this));
}
private:
@@ -193,7 +193,7 @@
* All Two point conical gradient test create functions may occasionally create edge case shaders
*/
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> Edge2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> Edge2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
SkScalar radius1 = d->fRandom->nextUScalar1();
SkPoint center2;
@@ -219,7 +219,7 @@
params.fColors, params.fStops,
params.fColorCount, params.fTileMode);
GrTest::TestAsFPArgs asFPArgs(d);
- sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
+ std::unique_ptr<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
GrAlwaysAssert(fp);
return fp;
}
@@ -381,9 +381,9 @@
public:
class GLSLFocalOutside2PtConicalProcessor;
- static sk_sp<GrFragmentProcessor> Make(const CreateArgs& args, SkScalar focalX) {
- auto processor =
- sk_sp<FocalOutside2PtConicalEffect>(new FocalOutside2PtConicalEffect(args, focalX));
+ static std::unique_ptr<GrFragmentProcessor> Make(const CreateArgs& args, SkScalar focalX) {
+ auto processor = std::unique_ptr<FocalOutside2PtConicalEffect>(
+ new FocalOutside2PtConicalEffect(args, focalX));
return processor->isValid() ? std::move(processor) : nullptr;
}
@@ -391,8 +391,8 @@
return "Two-Point Conical Gradient Focal Outside";
}
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new FocalOutside2PtConicalEffect(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new FocalOutside2PtConicalEffect(*this));
}
bool isFlipped() const { return fIsFlipped; }
@@ -481,7 +481,8 @@
* All Two point conical gradient test create functions may occasionally create edge case shaders
*/
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> FocalOutside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> FocalOutside2PtConicalEffect::TestCreate(
+ GrProcessorTestData* d) {
SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
SkScalar radius1 = 0.f;
SkPoint center2;
@@ -505,7 +506,7 @@
params.fColors, params.fStops,
params.fColorCount, params.fTileMode);
GrTest::TestAsFPArgs asFPArgs(d);
- sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
+ std::unique_ptr<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
GrAlwaysAssert(fp);
return fp;
}
@@ -601,9 +602,9 @@
public:
class GLSLFocalInside2PtConicalProcessor;
- static sk_sp<GrFragmentProcessor> Make(const CreateArgs& args, SkScalar focalX) {
- auto processor =
- sk_sp<FocalInside2PtConicalEffect>(new FocalInside2PtConicalEffect(args, focalX));
+ static std::unique_ptr<GrFragmentProcessor> Make(const CreateArgs& args, SkScalar focalX) {
+ auto processor = std::unique_ptr<FocalInside2PtConicalEffect>(
+ new FocalInside2PtConicalEffect(args, focalX));
return processor->isValid() ? std::move(processor) : nullptr;
}
@@ -611,8 +612,8 @@
return "Two-Point Conical Gradient Focal Inside";
}
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new FocalInside2PtConicalEffect(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new FocalInside2PtConicalEffect(*this));
}
SkScalar focal() const { return fFocalX; }
@@ -691,7 +692,8 @@
* All Two point conical gradient test create functions may occasionally create edge case shaders
*/
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> FocalInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> FocalInside2PtConicalEffect::TestCreate(
+ GrProcessorTestData* d) {
SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
SkScalar radius1 = 0.f;
SkPoint center2;
@@ -716,7 +718,7 @@
params.fColors, params.fStops,
params.fColorCount, params.fTileMode);
GrTest::TestAsFPArgs asFPArgs(d);
- sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
+ std::unique_ptr<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
GrAlwaysAssert(fp);
return fp;
}
@@ -846,16 +848,17 @@
public:
class GLSLCircleInside2PtConicalProcessor;
- static sk_sp<GrFragmentProcessor> Make(const CreateArgs& args, const CircleConicalInfo& info) {
- auto processor =
- sk_sp<CircleInside2PtConicalEffect>(new CircleInside2PtConicalEffect(args, info));
+ static std::unique_ptr<GrFragmentProcessor> Make(const CreateArgs& args,
+ const CircleConicalInfo& info) {
+ auto processor = std::unique_ptr<CircleInside2PtConicalEffect>(
+ new CircleInside2PtConicalEffect(args, info));
return processor->isValid() ? std::move(processor) : nullptr;
}
const char* name() const override { return "Two-Point Conical Gradient Inside"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new CircleInside2PtConicalEffect(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new CircleInside2PtConicalEffect(*this));
}
SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
@@ -945,7 +948,8 @@
* All Two point conical gradient test create functions may occasionally create edge case shaders
*/
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> CircleInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> CircleInside2PtConicalEffect::TestCreate(
+ GrProcessorTestData* d) {
SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
SkScalar radius1 = d->fRandom->nextUScalar1() + 0.0001f; // make sure radius1 != 0
SkPoint center2;
@@ -969,7 +973,7 @@
params.fColors, params.fStops,
params.fColorCount, params.fTileMode);
GrTest::TestAsFPArgs asFPArgs(d);
- sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
+ std::unique_ptr<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
GrAlwaysAssert(fp);
return fp;
}
@@ -1068,15 +1072,15 @@
public:
class GLSLCircleOutside2PtConicalProcessor;
- static sk_sp<GrFragmentProcessor> Make(const CreateArgs& args, const CircleConicalInfo& info) {
- return sk_sp<GrFragmentProcessor>(
- new CircleOutside2PtConicalEffect(args, info));
+ static std::unique_ptr<GrFragmentProcessor> Make(const CreateArgs& args,
+ const CircleConicalInfo& info) {
+ return std::unique_ptr<GrFragmentProcessor>(new CircleOutside2PtConicalEffect(args, info));
}
const char* name() const override { return "Two-Point Conical Gradient Outside"; }
- sk_sp<GrFragmentProcessor> clone() const override {
- return sk_sp<GrFragmentProcessor>(new CircleOutside2PtConicalEffect(*this));
+ std::unique_ptr<GrFragmentProcessor> clone() const override {
+ return std::unique_ptr<GrFragmentProcessor>(new CircleOutside2PtConicalEffect(*this));
}
SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
@@ -1187,7 +1191,8 @@
* All Two point conical gradient test create functions may occasionally create edge case shaders
*/
#if GR_TEST_UTILS
-sk_sp<GrFragmentProcessor> CircleOutside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
+std::unique_ptr<GrFragmentProcessor> CircleOutside2PtConicalEffect::TestCreate(
+ GrProcessorTestData* d) {
SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
SkScalar radius1 = d->fRandom->nextUScalar1() + 0.0001f; // make sure radius1 != 0
SkPoint center2;
@@ -1212,7 +1217,7 @@
params.fColors, params.fStops,
params.fColorCount, params.fTileMode);
GrTest::TestAsFPArgs asFPArgs(d);
- sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
+ std::unique_ptr<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
GrAlwaysAssert(fp);
return fp;
}
@@ -1334,8 +1339,8 @@
//////////////////////////////////////////////////////////////////////////////
-sk_sp<GrFragmentProcessor> Gr2PtConicalGradientEffect::Make(
- const GrGradientEffect::CreateArgs& args) {
+std::unique_ptr<GrFragmentProcessor> Gr2PtConicalGradientEffect::Make(
+ const GrGradientEffect::CreateArgs& args) {
const SkTwoPointConicalGradient& shader =
*static_cast<const SkTwoPointConicalGradient*>(args.fShader);
diff --git a/src/shaders/gradients/SkTwoPointConicalGradient_gpu.h b/src/shaders/gradients/SkTwoPointConicalGradient_gpu.h
index 46edb1f..e7eac07 100644
--- a/src/shaders/gradients/SkTwoPointConicalGradient_gpu.h
+++ b/src/shaders/gradients/SkTwoPointConicalGradient_gpu.h
@@ -14,11 +14,12 @@
class SkTwoPointConicalGradient;
namespace Gr2PtConicalGradientEffect {
- /**
- * Creates an effect that produces a two point conical gradient based on the
- * shader passed in.
- */
- sk_sp<GrFragmentProcessor> Make(const GrGradientEffect::CreateArgs& args);
+
+/**
+ * Creates an effect that produces a two point conical gradient based on the shader passed in.
+ */
+std::unique_ptr<GrFragmentProcessor> Make(const GrGradientEffect::CreateArgs& args);
+
};
#endif
diff --git a/src/sksl/SkSLCPPCodeGenerator.cpp b/src/sksl/SkSLCPPCodeGenerator.cpp
index 76faef9..bc47ff0 100644
--- a/src/sksl/SkSLCPPCodeGenerator.cpp
+++ b/src/sksl/SkSLCPPCodeGenerator.cpp
@@ -543,8 +543,10 @@
this->writef(" this->addCoordTransform(&%sCoordTransform);\n", field.c_str());
}
this->write("}\n");
- this->writef("sk_sp<GrFragmentProcessor> %s::clone() const {\n", fFullName.c_str());
- this->writef(" return sk_sp<GrFragmentProcessor>(new %s(*this));\n", fFullName.c_str());
+ this->writef("std::unique_ptr<GrFragmentProcessor> %s::clone() const {\n",
+ fFullName.c_str());
+ this->writef(" return std::unique_ptr<GrFragmentProcessor>(new %s(*this));\n",
+ fFullName.c_str());
this->write("}\n");
}
}
@@ -552,12 +554,13 @@
void CPPCodeGenerator::writeTest() {
const Section* test = fSectionAndParameterHelper.getSection(TEST_CODE_SECTION);
if (test) {
- this->writef("GR_DEFINE_FRAGMENT_PROCESSOR_TEST(%s);\n"
- "#if GR_TEST_UTILS\n"
- "sk_sp<GrFragmentProcessor> %s::TestCreate(GrProcessorTestData* %s) {\n",
- fFullName.c_str(),
- fFullName.c_str(),
- test->fArgument.c_str());
+ this->writef(
+ "GR_DEFINE_FRAGMENT_PROCESSOR_TEST(%s);\n"
+ "#if GR_TEST_UTILS\n"
+ "std::unique_ptr<GrFragmentProcessor> %s::TestCreate(GrProcessorTestData* %s) {\n",
+ fFullName.c_str(),
+ fFullName.c_str(),
+ test->fArgument.c_str());
this->writeSection(TEST_CODE_SECTION);
this->write("}\n"
"#endif\n");
diff --git a/src/sksl/SkSLHCodeGenerator.cpp b/src/sksl/SkSLHCodeGenerator.cpp
index 22f4fd8..50d2428 100644
--- a/src/sksl/SkSLHCodeGenerator.cpp
+++ b/src/sksl/SkSLHCodeGenerator.cpp
@@ -123,7 +123,7 @@
void HCodeGenerator::writeMake() {
const char* separator;
if (!this->writeSection(MAKE_SECTION)) {
- this->writef(" static sk_sp<GrFragmentProcessor> Make(");
+ this->writef(" static std::unique_ptr<GrFragmentProcessor> Make(");
separator = "";
for (const auto& param : fSectionAndParameterHelper.getParameters()) {
this->writef("%s%s %s", separator, ParameterType(param->fType).c_str(),
@@ -132,7 +132,7 @@
}
this->writeSection(CONSTRUCTOR_PARAMS_SECTION, separator);
this->writef(") {\n"
- " return sk_sp<GrFragmentProcessor>(new %s(",
+ " return std::unique_ptr<GrFragmentProcessor>(new %s(",
fFullName.c_str());
separator = "";
for (const auto& param : fSectionAndParameterHelper.getParameters()) {
@@ -251,7 +251,7 @@
}
this->writeMake();
this->writef(" %s(const %s& src);\n"
- " sk_sp<GrFragmentProcessor> clone() const override;\n"
+ " std::unique_ptr<GrFragmentProcessor> clone() const override;\n"
" const char* name() const override { return \"%s\"; }\n"
"private:\n",
fFullName.c_str(), fFullName.c_str(), fName.c_str());
diff --git a/src/utils/SkShadowUtils.cpp b/src/utils/SkShadowUtils.cpp
index b6c57f3..e95668a 100644
--- a/src/utils/SkShadowUtils.cpp
+++ b/src/utils/SkShadowUtils.cpp
@@ -38,7 +38,8 @@
}
#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(GrContext*, SkColorSpace*) const override;
+ std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(GrContext*,
+ SkColorSpace*) const override;
#endif
SK_TO_STRING_OVERRIDE()
@@ -68,8 +69,8 @@
#if SK_SUPPORT_GPU
-sk_sp<GrFragmentProcessor> SkGaussianColorFilter::asFragmentProcessor(GrContext*,
- SkColorSpace*) const {
+std::unique_ptr<GrFragmentProcessor> SkGaussianColorFilter::asFragmentProcessor(
+ GrContext*, SkColorSpace*) const {
return GrBlurredEdgeFragmentProcessor::Make(GrBlurredEdgeFragmentProcessor::kGaussian_Mode);
}
#endif