From aff329b8e9b239bca1d93b13a914fbef45ccf7fe Mon Sep 17 00:00:00 2001 From: Brian Salomon Date: Fri, 11 Aug 2017 09:40:37 -0400 Subject: 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 Reviewed-by: Brian Osman --- src/core/SkColorFilter.cpp | 16 +-- src/core/SkColorMatrixFilterRowMajor255.cpp | 12 +- src/core/SkColorMatrixFilterRowMajor255.h | 3 +- src/core/SkGpuBlurUtils.cpp | 33 +++--- src/core/SkImageFilter.cpp | 2 +- src/core/SkModeColorFilter.cpp | 12 +- src/core/SkModeColorFilter.h | 3 +- src/effects/GrAlphaThresholdFragmentProcessor.cpp | 6 +- src/effects/GrAlphaThresholdFragmentProcessor.fp | 22 ++-- src/effects/GrAlphaThresholdFragmentProcessor.h | 20 ++-- src/effects/GrCircleBlurFragmentProcessor.cpp | 13 +- src/effects/GrCircleBlurFragmentProcessor.fp | 19 ++- src/effects/GrCircleBlurFragmentProcessor.h | 6 +- src/effects/SkAlphaThresholdFilter.cpp | 13 +- src/effects/SkArithmeticImageFilter.cpp | 28 ++--- src/effects/SkBlurMaskFilter.cpp | 47 ++++---- src/effects/SkColorMatrixFilter.cpp | 4 +- src/effects/SkDisplacementMapEffect.cpp | 28 ++--- src/effects/SkHighContrastFilter.cpp | 12 +- src/effects/SkLightingImageFilter.cpp | 93 ++++++++------- src/effects/SkLumaColorFilter.cpp | 9 +- src/effects/SkMagnifierImageFilter.cpp | 64 +++++----- src/effects/SkMatrixConvolutionImageFilter.cpp | 18 +-- src/effects/SkMorphologyImageFilter.cpp | 20 ++-- src/effects/SkOverdrawColorFilter.cpp | 14 +-- src/effects/SkOverdrawColorFilter.h | 3 +- src/effects/SkRRectsGaussianEdgeMaskFilter.cpp | 11 +- src/effects/SkTableColorFilter.cpp | 24 ++-- src/effects/SkToSRGBColorFilter.cpp | 4 +- src/effects/SkXfermodeImageFilter.cpp | 21 ++-- src/gpu/GrAppliedClip.h | 8 +- src/gpu/GrClipStackClip.cpp | 10 +- src/gpu/GrContext.cpp | 14 +-- src/gpu/GrFragmentProcessor.cpp | 132 +++++++++++---------- src/gpu/GrFragmentProcessor.h | 44 ++++--- src/gpu/GrPaint.h | 8 +- src/gpu/GrPipeline.cpp | 12 +- src/gpu/GrPipeline.h | 3 +- src/gpu/GrProcessorSet.cpp | 30 ++--- src/gpu/GrProcessorSet.h | 19 ++- src/gpu/GrProcessorUnitTest.cpp | 4 +- src/gpu/GrProcessorUnitTest.h | 8 +- src/gpu/GrRenderTargetContext.cpp | 4 +- src/gpu/GrRenderTargetContext.h | 4 +- src/gpu/GrTextureAdjuster.cpp | 15 ++- src/gpu/GrTextureAdjuster.h | 14 +-- src/gpu/GrTextureMaker.cpp | 15 ++- src/gpu/GrTextureMaker.h | 14 +-- src/gpu/GrTextureProducer.cpp | 14 +-- src/gpu/GrTextureProducer.h | 28 ++--- src/gpu/GrYUVProvider.cpp | 14 +-- src/gpu/SkGpuDevice.cpp | 25 ++-- src/gpu/SkGpuDevice_drawTexture.cpp | 8 +- src/gpu/SkGr.cpp | 34 +++--- src/gpu/SkGr.h | 4 +- src/gpu/effects/GrBicubicEffect.cpp | 2 +- src/gpu/effects/GrBicubicEffect.h | 30 +++-- src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp | 4 +- src/gpu/effects/GrBlurredEdgeFragmentProcessor.h | 6 +- src/gpu/effects/GrCircleEffect.cpp | 6 +- src/gpu/effects/GrCircleEffect.h | 6 +- src/gpu/effects/GrConfigConversionEffect.cpp | 24 ++-- src/gpu/effects/GrConfigConversionEffect.h | 5 +- src/gpu/effects/GrConstColorProcessor.cpp | 6 +- src/gpu/effects/GrConstColorProcessor.h | 6 +- src/gpu/effects/GrConvexPolyEffect.cpp | 26 ++-- src/gpu/effects/GrConvexPolyEffect.h | 12 +- src/gpu/effects/GrDitherEffect.cpp | 8 +- src/gpu/effects/GrDitherEffect.fp | 6 +- src/gpu/effects/GrDitherEffect.h | 6 +- src/gpu/effects/GrEllipseEffect.cpp | 6 +- src/gpu/effects/GrEllipseEffect.h | 6 +- .../GrGaussianConvolutionFragmentProcessor.cpp | 2 +- .../GrGaussianConvolutionFragmentProcessor.h | 21 ++-- src/gpu/effects/GrMatrixConvolutionEffect.cpp | 34 +++--- src/gpu/effects/GrMatrixConvolutionEffect.h | 46 +++---- .../effects/GrNonlinearColorSpaceXformEffect.cpp | 15 +-- src/gpu/effects/GrNonlinearColorSpaceXformEffect.h | 5 +- src/gpu/effects/GrOvalEffect.cpp | 3 +- src/gpu/effects/GrOvalEffect.h | 10 +- src/gpu/effects/GrRRectEffect.cpp | 45 +++---- src/gpu/effects/GrRRectEffect.h | 12 +- src/gpu/effects/GrSRGBEffect.cpp | 4 +- src/gpu/effects/GrSRGBEffect.h | 6 +- src/gpu/effects/GrSimpleTextureEffect.cpp | 7 +- src/gpu/effects/GrSimpleTextureEffect.fp | 28 ++--- src/gpu/effects/GrSimpleTextureEffect.h | 36 +++--- src/gpu/effects/GrTextureDomain.cpp | 36 +++--- src/gpu/effects/GrTextureDomain.h | 24 ++-- src/gpu/effects/GrXfermodeFragmentProcessor.cpp | 77 ++++++------ src/gpu/effects/GrXfermodeFragmentProcessor.h | 34 +++--- src/gpu/effects/GrYUVEffect.cpp | 60 +++++----- src/gpu/effects/GrYUVEffect.h | 54 +++++---- src/shaders/SkColorFilterShader.cpp | 11 +- src/shaders/SkColorFilterShader.h | 2 +- src/shaders/SkColorShader.cpp | 6 +- src/shaders/SkColorShader.h | 4 +- src/shaders/SkComposeShader.cpp | 7 +- src/shaders/SkComposeShader.h | 2 +- src/shaders/SkImageShader.cpp | 8 +- src/shaders/SkImageShader.h | 2 +- src/shaders/SkLocalMatrixShader.cpp | 3 +- src/shaders/SkLocalMatrixShader.h | 2 +- src/shaders/SkPerlinNoiseShader.cpp | 74 ++++++------ src/shaders/SkPictureShader.cpp | 3 +- src/shaders/SkPictureShader.h | 2 +- src/shaders/SkShader.cpp | 2 +- src/shaders/SkShaderBase.h | 2 +- src/shaders/gradients/SkLinearGradient.cpp | 21 ++-- src/shaders/gradients/SkLinearGradient.h | 2 +- src/shaders/gradients/SkRadialGradient.cpp | 21 ++-- src/shaders/gradients/SkRadialGradient.h | 2 +- src/shaders/gradients/SkSweepGradient.cpp | 26 ++-- src/shaders/gradients/SkSweepGradient.h | 2 +- .../gradients/SkTwoPointConicalGradient.cpp | 8 +- src/shaders/gradients/SkTwoPointConicalGradient.h | 2 +- .../gradients/SkTwoPointConicalGradient_gpu.cpp | 77 ++++++------ .../gradients/SkTwoPointConicalGradient_gpu.h | 11 +- src/sksl/SkSLCPPCodeGenerator.cpp | 19 +-- src/sksl/SkSLHCodeGenerator.cpp | 6 +- src/utils/SkShadowUtils.cpp | 7 +- 121 files changed, 1070 insertions(+), 1053 deletions(-) (limited to 'src') diff --git a/src/core/SkColorFilter.cpp b/src/core/SkColorFilter.cpp index 4291644506..22b8221506 100644 --- a/src/core/SkColorFilter.cpp +++ b/src/core/SkColorFilter.cpp @@ -36,7 +36,8 @@ bool SkColorFilter::asComponentTable(SkBitmap*) const { } #if SK_SUPPORT_GPU -sk_sp SkColorFilter::asFragmentProcessor(GrContext*, SkColorSpace*) const { +std::unique_ptr SkColorFilter::asFragmentProcessor(GrContext*, + SkColorSpace*) const { return nullptr; } #endif @@ -119,14 +120,14 @@ public: } #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(GrContext* context, - SkColorSpace* dstColorSpace) const override { - sk_sp innerFP(fInner->asFragmentProcessor(context, dstColorSpace)); - sk_sp outerFP(fOuter->asFragmentProcessor(context, dstColorSpace)); + std::unique_ptr 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 series[] = { std::move(innerFP), std::move(outerFP) }; + std::unique_ptr series[] = { std::move(innerFP), std::move(outerFP) }; return GrFragmentProcessor::RunInSeries(series, 2); } #endif @@ -215,7 +216,8 @@ public: SkSRGBGammaColorFilter(Direction dir) : fDir(dir) {} #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(GrContext* x, SkColorSpace* cs) const override { + std::unique_ptr 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 9262e5bf5d..e2d6c37118 100644 --- a/src/core/SkColorMatrixFilterRowMajor255.cpp +++ b/src/core/SkColorMatrixFilterRowMajor255.cpp @@ -183,15 +183,15 @@ SkColorMatrixFilterRowMajor255::makeComposed(sk_sp innerFilter) c class ColorMatrixEffect : public GrFragmentProcessor { public: - static sk_sp Make(const SkScalar matrix[20]) { - return sk_sp(new ColorMatrixEffect(matrix)); + static std::unique_ptr Make(const SkScalar matrix[20]) { + return std::unique_ptr(new ColorMatrixEffect(matrix)); } const char* name() const override { return "Color Matrix"; } GR_DECLARE_FRAGMENT_PROCESSOR_TEST - sk_sp clone() const override { return Make(fMatrix); } + std::unique_ptr clone() const override { return Make(fMatrix); } private: class GLSLProcessor : public GrGLSLFragmentProcessor { @@ -284,7 +284,7 @@ private: GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ColorMatrixEffect); #if GR_TEST_UTILS -sk_sp ColorMatrixEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr 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 @@ sk_sp ColorMatrixEffect::TestCreate(GrProcessorTestData* d) #endif -sk_sp SkColorMatrixFilterRowMajor255::asFragmentProcessor( - GrContext*, SkColorSpace*) const { +std::unique_ptr SkColorMatrixFilterRowMajor255::asFragmentProcessor( + GrContext*, SkColorSpace*) const { return ColorMatrixEffect::Make(fMatrix); } diff --git a/src/core/SkColorMatrixFilterRowMajor255.h b/src/core/SkColorMatrixFilterRowMajor255.h index 7a1471ae23..7767646d2d 100644 --- a/src/core/SkColorMatrixFilterRowMajor255.h +++ b/src/core/SkColorMatrixFilterRowMajor255.h @@ -23,7 +23,8 @@ public: sk_sp makeComposed(sk_sp) const override; #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(GrContext*, SkColorSpace*) const override; + std::unique_ptr asFragmentProcessor(GrContext*, + SkColorSpace*) const override; #endif SK_TO_STRING_OVERRIDE() diff --git a/src/core/SkGpuBlurUtils.cpp b/src/core/SkGpuBlurUtils.cpp index 5121cc53ec..b328eea75a 100644 --- a/src/core/SkGpuBlurUtils.cpp +++ b/src/core/SkGpuBlurUtils.cpp @@ -81,7 +81,7 @@ static void convolve_gaussian_1d(GrRenderTargetContext* renderTargetContext, GrPaint paint; paint.setGammaCorrect(renderTargetContext->isGammaCorrect()); - sk_sp conv(GrGaussianConvolutionFragmentProcessor::Make( + std::unique_ptr conv(GrGaussianConvolutionFragmentProcessor::Make( std::move(proxy), direction, radius, sigma, mode, bounds)); paint.addColorFragmentProcessor(std::move(conv)); paint.setPorterDuffXPFactory(SkBlendMode::kSrc); @@ -109,9 +109,8 @@ static void convolve_gaussian_2d(GrRenderTargetContext* renderTargetContext, GrPaint paint; paint.setGammaCorrect(renderTargetContext->isGammaCorrect()); - sk_sp 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 @@ sk_sp GaussianBlur(GrContext* context, SkRect domain = SkRect::Make(localSrcBounds); domain.inset((i < scaleFactorX) ? SK_ScalarHalf : 0.0f, (i < scaleFactorY) ? SK_ScalarHalf : 0.0f); - sk_sp 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 @@ sk_sp GaussianBlur(GrContext* context, if (GrTextureDomain::kIgnore_Mode != mode) { SkRect domain = SkRect::Make(localSrcBounds); - sk_sp 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 cc0f1e9f81..7301442d81 100644 --- a/src/core/SkImageFilter.cpp +++ b/src/core/SkImageFilter.cpp @@ -291,7 +291,7 @@ bool SkImageFilter::canComputeFastBounds() const { #if SK_SUPPORT_GPU sk_sp SkImageFilter::DrawWithFP(GrContext* context, - sk_sp fp, + std::unique_ptr fp, const SkIRect& bounds, const OutputProperties& outputProperties) { GrPaint paint; diff --git a/src/core/SkModeColorFilter.cpp b/src/core/SkModeColorFilter.cpp index 2d2fa93933..1e2e8de73b 100644 --- a/src/core/SkModeColorFilter.cpp +++ b/src/core/SkModeColorFilter.cpp @@ -97,17 +97,15 @@ sk_sp SkModeColorFilter::onMakeColorSpace(SkColorSpaceXformer* xf #include "effects/GrConstColorProcessor.h" #include "SkGr.h" -sk_sp SkModeColorFilter::asFragmentProcessor( - GrContext*, SkColorSpace* dstColorSpace) const { +std::unique_ptr SkModeColorFilter::asFragmentProcessor( + GrContext*, SkColorSpace* dstColorSpace) const { if (SkBlendMode::kDst == fMode) { return nullptr; } - sk_sp constFP( - GrConstColorProcessor::Make(SkColorToPremulGrColor4f(fColor, dstColorSpace), - GrConstColorProcessor::kIgnore_InputMode)); - sk_sp 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 ea503ac0d6..c5bd785c99 100644 --- a/src/core/SkModeColorFilter.h +++ b/src/core/SkModeColorFilter.h @@ -27,7 +27,8 @@ public: #endif #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(GrContext*, SkColorSpace*) const override; + std::unique_ptr 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 731ca99d3b..8c3afb7aff 100644 --- a/src/effects/GrAlphaThresholdFragmentProcessor.cpp +++ b/src/effects/GrAlphaThresholdFragmentProcessor.cpp @@ -123,12 +123,12 @@ GrAlphaThresholdFragmentProcessor::GrAlphaThresholdFragmentProcessor( this->addCoordTransform(&fImageCoordTransform); this->addCoordTransform(&fMaskCoordTransform); } -sk_sp GrAlphaThresholdFragmentProcessor::clone() const { - return sk_sp(new GrAlphaThresholdFragmentProcessor(*this)); +std::unique_ptr GrAlphaThresholdFragmentProcessor::clone() const { + return std::unique_ptr(new GrAlphaThresholdFragmentProcessor(*this)); } GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrAlphaThresholdFragmentProcessor); #if GR_TEST_UTILS -sk_sp GrAlphaThresholdFragmentProcessor::TestCreate( +std::unique_ptr GrAlphaThresholdFragmentProcessor::TestCreate( GrProcessorTestData* testData) { sk_sp bmpProxy = testData->textureProxy(GrProcessorUnitTest::kSkiaPMTextureIdx); sk_sp maskProxy = testData->textureProxy(GrProcessorUnitTest::kAlphaTextureIdx); diff --git a/src/effects/GrAlphaThresholdFragmentProcessor.fp b/src/effects/GrAlphaThresholdFragmentProcessor.fp index e930ed9a58..481549e6b5 100644 --- a/src/effects/GrAlphaThresholdFragmentProcessor.fp +++ b/src/effects/GrAlphaThresholdFragmentProcessor.fp @@ -13,18 +13,14 @@ in uniform float outerThreshold; } @make { - static sk_sp Make(sk_sp image, - sk_sp colorXform, - sk_sp mask, - float innerThreshold, - float outerThreshold, - const SkIRect& bounds) { - return sk_sp(new GrAlphaThresholdFragmentProcessor(image, - colorXform, - mask, - innerThreshold, - outerThreshold, - bounds)); + static std::unique_ptr Make(sk_sp image, + sk_sp colorXform, + sk_sp mask, + float innerThreshold, + float outerThreshold, + const SkIRect& bounds) { + return std::unique_ptr(new GrAlphaThresholdFragmentProcessor( + image, colorXform, mask, innerThreshold, outerThreshold, bounds)); } } @@ -89,4 +85,4 @@ void main() { 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 78424d0359..3b649516c1 100644 --- a/src/effects/GrAlphaThresholdFragmentProcessor.h +++ b/src/effects/GrAlphaThresholdFragmentProcessor.h @@ -24,19 +24,19 @@ public: float innerThreshold() const { return fInnerThreshold; } float outerThreshold() const { return fOuterThreshold; } - static sk_sp Make(sk_sp image, - sk_sp - colorXform, - sk_sp - mask, - float innerThreshold, - float outerThreshold, - const SkIRect& bounds) { - return sk_sp(new GrAlphaThresholdFragmentProcessor( + static std::unique_ptr Make(sk_sp image, + sk_sp + colorXform, + sk_sp + mask, + float innerThreshold, + float outerThreshold, + const SkIRect& bounds) { + return std::unique_ptr(new GrAlphaThresholdFragmentProcessor( image, colorXform, mask, innerThreshold, outerThreshold, bounds)); } GrAlphaThresholdFragmentProcessor(const GrAlphaThresholdFragmentProcessor& src); - sk_sp clone() const override; + std::unique_ptr clone() const override; const char* name() const override { return "AlphaThresholdFragmentProcessor"; } private: diff --git a/src/effects/GrCircleBlurFragmentProcessor.cpp b/src/effects/GrCircleBlurFragmentProcessor.cpp index 68ba0af0d4..7cec3cc431 100644 --- a/src/effects/GrCircleBlurFragmentProcessor.cpp +++ b/src/effects/GrCircleBlurFragmentProcessor.cpp @@ -206,9 +206,8 @@ static sk_sp create_profile_texture(GrResourceProvider* resource return blurProfile; } -sk_sp GrCircleBlurFragmentProcessor::Make(GrResourceProvider* resourceProvider, - const SkRect& circle, - float sigma) { +std::unique_ptr GrCircleBlurFragmentProcessor::Make( + GrResourceProvider* resourceProvider, const SkRect& circle, float sigma) { float solidRadius; float textureRadius; sk_sp profile( @@ -216,7 +215,7 @@ sk_sp GrCircleBlurFragmentProcessor::Make(GrResourceProvide if (!profile) { return nullptr; } - return sk_sp(new GrCircleBlurFragmentProcessor( + return std::unique_ptr(new GrCircleBlurFragmentProcessor( circle, textureRadius, solidRadius, std::move(profile), resourceProvider)); } #include "glsl/GrGLSLColorSpaceXformHelper.h" @@ -295,12 +294,12 @@ GrCircleBlurFragmentProcessor::GrCircleBlurFragmentProcessor( this->initClassID(); this->addTextureSampler(&fBlurProfileSampler); } -sk_sp GrCircleBlurFragmentProcessor::clone() const { - return sk_sp(new GrCircleBlurFragmentProcessor(*this)); +std::unique_ptr GrCircleBlurFragmentProcessor::clone() const { + return std::unique_ptr(new GrCircleBlurFragmentProcessor(*this)); } GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrCircleBlurFragmentProcessor); #if GR_TEST_UTILS -sk_sp GrCircleBlurFragmentProcessor::TestCreate( +std::unique_ptr 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 01e5426dc0..856a468b6c 100644 --- a/src/effects/GrCircleBlurFragmentProcessor.fp +++ b/src/effects/GrCircleBlurFragmentProcessor.fp @@ -18,8 +18,8 @@ uniform float4 circleData; } @make { - static sk_sp Make(GrResourceProvider* resourceProvider, - const SkRect& circle, float sigma); + static std::unique_ptr Make(GrResourceProvider* resourceProvider, + const SkRect& circle, float sigma); } @setData(data) { @@ -256,10 +256,8 @@ uniform float4 circleData; return blurProfile; } - sk_sp GrCircleBlurFragmentProcessor::Make( - GrResourceProvider* resourceProvider, - const SkRect& circle, - float sigma) { + std::unique_ptr GrCircleBlurFragmentProcessor::Make( + GrResourceProvider* resourceProvider, const SkRect& circle, float sigma) { float solidRadius; float textureRadius; sk_sp profile(create_profile_texture(resourceProvider, circle, sigma, @@ -267,11 +265,8 @@ uniform float4 circleData; if (!profile) { return nullptr; } - return sk_sp(new GrCircleBlurFragmentProcessor(circle, - textureRadius, - solidRadius, - std::move(profile), - resourceProvider)); + return std::unique_ptr(new GrCircleBlurFragmentProcessor( + circle, textureRadius, solidRadius, std::move(profile), resourceProvider)); } } @@ -289,4 +284,4 @@ void main() { 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 9ef204d403..e98714b4b0 100644 --- a/src/effects/GrCircleBlurFragmentProcessor.h +++ b/src/effects/GrCircleBlurFragmentProcessor.h @@ -21,10 +21,10 @@ public: float textureRadius() const { return fTextureRadius; } float solidRadius() const { return fSolidRadius; } - static sk_sp Make(GrResourceProvider* resourceProvider, - const SkRect& circle, float sigma); + static std::unique_ptr Make(GrResourceProvider* resourceProvider, + const SkRect& circle, float sigma); GrCircleBlurFragmentProcessor(const GrCircleBlurFragmentProcessor& src); - sk_sp clone() const override; + std::unique_ptr clone() const override; const char* name() const override { return "CircleBlurFragmentProcessor"; } private: diff --git a/src/effects/SkAlphaThresholdFilter.cpp b/src/effects/SkAlphaThresholdFilter.cpp index e46be12067..634e6ae08b 100644 --- a/src/effects/SkAlphaThresholdFilter.cpp +++ b/src/effects/SkAlphaThresholdFilter.cpp @@ -173,13 +173,12 @@ sk_sp SkAlphaThresholdFilterImpl::onFilterImage(SkSpecialImage* sk_sp colorSpaceXform = GrColorSpaceXform::Make(input->getColorSpace(), outProps.colorSpace()); - sk_sp 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 41bafb889c..34df27546c 100644 --- a/src/effects/SkArithmeticImageFilter.cpp +++ b/src/effects/SkArithmeticImageFilter.cpp @@ -207,9 +207,10 @@ sk_sp ArithmeticImageFilterImpl::onFilterImage(SkSpecialImage* s namespace { class ArithmeticFP : public GrFragmentProcessor { public: - static sk_sp Make(float k1, float k2, float k3, float k4, - bool enforcePMColor, sk_sp dst) { - return sk_sp( + static std::unique_ptr Make(float k1, float k2, float k3, float k4, + bool enforcePMColor, + std::unique_ptr dst) { + return std::unique_ptr( new ArithmeticFP(k1, k2, k3, k4, enforcePMColor, std::move(dst))); } @@ -223,7 +224,7 @@ public: return str; } - sk_sp clone() const override { + std::unique_ptr clone() const override { return Make(fK1, fK2, fK3, fK4, fEnforcePMColor, this->childProcessor(0).clone()); } @@ -291,7 +292,7 @@ private: // 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 dst) + std::unique_ptr dst) : INHERITED(kNone_OptimizationFlags) , fK1(k1) , fK2(k2) @@ -313,14 +314,14 @@ private: } #if GR_TEST_UTILS -sk_sp ArithmeticFP::TestCreate(GrProcessorTestData* d) { +std::unique_ptr 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 dst(GrProcessorUnitTest::MakeChildFP(d)); + std::unique_ptr dst(GrProcessorUnitTest::MakeChildFP(d)); return ArithmeticFP::Make(k1, k2, k3, k4, enforcePMColor, std::move(dst)); } #endif @@ -350,7 +351,7 @@ sk_sp ArithmeticImageFilterImpl::filterImageGPU( } GrPaint paint; - sk_sp bgFP; + std::unique_ptr bgFP; if (backgroundProxy) { SkMatrix backgroundMatrix = SkMatrix::MakeTrans(-SkIntToScalar(backgroundOffset.fX), @@ -371,14 +372,13 @@ sk_sp ArithmeticImageFilterImpl::filterImageGPU( -SkIntToScalar(foregroundOffset.fY)); sk_sp fgXform = GrColorSpaceXform::Make(foreground->getColorSpace(), outputProperties.colorSpace()); - sk_sp 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 xferFP = + std::unique_ptr 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 f927cc7470..2fc10ede40 100644 --- a/src/effects/SkBlurMaskFilter.cpp +++ b/src/effects/SkBlurMaskFilter.cpp @@ -769,8 +769,8 @@ public: const char* name() const override { return "RectBlur"; } - static sk_sp Make(GrResourceProvider* resourceProvider, - const SkRect& rect, float sigma) { + static std::unique_ptr Make(GrResourceProvider* resourceProvider, + const SkRect& rect, float sigma) { int doubleProfileSize = SkScalarCeilToInt(12*sigma); if (doubleProfileSize >= rect.width() || doubleProfileSize >= rect.height()) { @@ -803,12 +803,12 @@ public: precision = kDefault_GrSLPrecision; } - return sk_sp(new GrRectBlurEffect(rect, sigma, - std::move(blurProfile), precision)); + return std::unique_ptr( + new GrRectBlurEffect(rect, sigma, std::move(blurProfile), precision)); } - sk_sp clone() const override { - return sk_sp(new GrRectBlurEffect( + std::unique_ptr clone() const override { + return std::unique_ptr(new GrRectBlurEffect( fRect, fSigma, sk_ref_sp(fBlurProfileSampler.proxy()), fPrecision)); } @@ -1009,7 +1009,7 @@ bool GrRectBlurEffect::onIsEqual(const GrFragmentProcessor& sBase) const { GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRectBlurEffect); #if GR_TEST_UTILS -sk_sp GrRectBlurEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr 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 @@ bool SkBlurMaskFilterImpl::directFilterMaskGPU(GrContext* context, SkScalar xformedSigma = this->computeXformedSigma(viewMatrix); GrResourceProvider* resourceProvider = context->resourceProvider(); - sk_sp fp; + std::unique_ptr fp; SkRect rect; if (path.isRect(&rect)) { @@ -1076,9 +1076,9 @@ bool SkBlurMaskFilterImpl::directFilterMaskGPU(GrContext* context, class GrRRectBlurEffect : public GrFragmentProcessor { public: - static sk_sp Make(GrContext*, - float sigma, float xformedSigma, - const SkRRect& srcRRect, const SkRRect& devRRect); + static std::unique_ptr 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 @@ public: const SkRRect& getRRect() const { return fRRect; } float getSigma() const { return fSigma; } - sk_sp clone() const override; + std::unique_ptr clone() const override; private: GrGLSLFragmentProcessor* onCreateGLSLInstance() const override; @@ -1171,9 +1171,10 @@ static sk_sp find_or_create_rrect_blur_mask(GrContext* context, return mask; } -sk_sp GrRRectBlurEffect::Make(GrContext* context, - float sigma, float xformedSigma, - const SkRRect& srcRRect, const SkRRect& devRRect) { +std::unique_ptr 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 @@ sk_sp GrRRectBlurEffect::Make(GrContext* context, return nullptr; } - return sk_sp(new GrRRectBlurEffect(xformedSigma, - devRRect, - std::move(mask))); + return std::unique_ptr( + new GrRRectBlurEffect(xformedSigma, devRRect, std::move(mask))); } GrRRectBlurEffect::GrRRectBlurEffect(float sigma, const SkRRect& rrect, @@ -1223,8 +1223,8 @@ GrRRectBlurEffect::GrRRectBlurEffect(float sigma, const SkRRect& rrect, this->addTextureSampler(&fNinePatchSampler); } -sk_sp GrRRectBlurEffect::clone() const { - return sk_sp( +std::unique_ptr GrRRectBlurEffect::clone() const { + return std::unique_ptr( new GrRRectBlurEffect(fSigma, fRRect, sk_ref_sp(fNinePatchSampler.proxy()))); } @@ -1240,7 +1240,7 @@ bool GrRRectBlurEffect::onIsEqual(const GrFragmentProcessor& other) const { GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRRectBlurEffect); #if GR_TEST_UTILS -sk_sp GrRRectBlurEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr 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 @@ bool SkBlurMaskFilterImpl::directFilterRRectMaskGPU(GrContext* context, SkScalar xformedSigma = this->computeXformedSigma(viewMatrix); if (devRRect.isRect() || devRRect.isCircle()) { - sk_sp fp; + std::unique_ptr fp; if (devRRect.isRect()) { SkScalar pad = 3.0f * xformedSigma; const SkRect dstCoverageRect = devRRect.rect().makeOutset(pad, pad); @@ -1404,8 +1404,7 @@ bool SkBlurMaskFilterImpl::directFilterRRectMaskGPU(GrContext* context, return true; } - sk_sp 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 0bd6c2ca68..43a39413e1 100644 --- a/src/effects/SkColorMatrixFilter.cpp +++ b/src/effects/SkColorMatrixFilter.cpp @@ -66,8 +66,8 @@ public: Factory getFactory() const override { return fMatrixFilter->getFactory(); } #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(GrContext* ctx, - SkColorSpace* cs) const override { + std::unique_ptr 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 626ff9f8b6..ff17af1a48 100644 --- a/src/effects/SkDisplacementMapEffect.cpp +++ b/src/effects/SkDisplacementMapEffect.cpp @@ -164,17 +164,15 @@ void SkDisplacementMapEffect::flatten(SkWriteBuffer& buffer) const { #if SK_SUPPORT_GPU class GrDisplacementMapEffect : public GrFragmentProcessor { public: - static sk_sp Make( - SkDisplacementMapEffect::ChannelSelectorType xChannelSelector, - SkDisplacementMapEffect::ChannelSelectorType yChannelSelector, SkVector scale, - sk_sp displacement, const SkMatrix& offsetMatrix, - sk_sp color, - sk_sp colorSpaceXform, const SkISize& colorDimensions) { - return sk_sp( - new GrDisplacementMapEffect(xChannelSelector, yChannelSelector, scale, - std::move(displacement), - offsetMatrix, std::move(color), std::move(colorSpaceXform), - colorDimensions)); + static std::unique_ptr Make( + SkDisplacementMapEffect::ChannelSelectorType xChannelSelector, + SkDisplacementMapEffect::ChannelSelectorType yChannelSelector, SkVector scale, + sk_sp displacement, const SkMatrix& offsetMatrix, + sk_sp color, sk_sp colorSpaceXform, + const SkISize& colorDimensions) { + return std::unique_ptr(new GrDisplacementMapEffect( + xChannelSelector, yChannelSelector, scale, std::move(displacement), offsetMatrix, + std::move(color), std::move(colorSpaceXform), colorDimensions)); } ~GrDisplacementMapEffect() override; @@ -191,7 +189,7 @@ public: const GrTextureDomain& domain() const { return fDomain; } GrColorSpaceXform* colorSpaceXform() const { return fColorSpaceXform.get(); } - sk_sp clone() const override; + std::unique_ptr clone() const override; private: static OptimizationFlags OptimizationFlags(GrPixelConfig colorConfig); @@ -504,8 +502,8 @@ GrDisplacementMapEffect::GrDisplacementMapEffect(const GrDisplacementMapEffect& GrDisplacementMapEffect::~GrDisplacementMapEffect() {} -sk_sp GrDisplacementMapEffect::clone() const { - return sk_sp(new GrDisplacementMapEffect(*this)); +std::unique_ptr GrDisplacementMapEffect::clone() const { + return std::unique_ptr(new GrDisplacementMapEffect(*this)); } bool GrDisplacementMapEffect::onIsEqual(const GrFragmentProcessor& sBase) const { @@ -520,7 +518,7 @@ bool GrDisplacementMapEffect::onIsEqual(const GrFragmentProcessor& sBase) const GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDisplacementMapEffect); #if GR_TEST_UTILS -sk_sp GrDisplacementMapEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr 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 6d9853e556..3de7603c74 100644 --- a/src/effects/SkHighContrastFilter.cpp +++ b/src/effects/SkHighContrastFilter.cpp @@ -35,7 +35,8 @@ public: ~SkHighContrast_Filter() override {} #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(GrContext*, SkColorSpace*) const override; + std::unique_ptr asFragmentProcessor(GrContext*, + SkColorSpace*) const override; #endif void onAppendStages(SkRasterPipeline* p, @@ -166,15 +167,15 @@ SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END #if SK_SUPPORT_GPU class HighContrastFilterEffect : public GrFragmentProcessor { public: - static sk_sp Make(const SkHighContrastConfig& config) { - return sk_sp(new HighContrastFilterEffect(config)); + static std::unique_ptr Make(const SkHighContrastConfig& config) { + return std::unique_ptr(new HighContrastFilterEffect(config)); } const char* name() const override { return "HighContrastFilter"; } const SkHighContrastConfig& config() const { return fConfig; } - sk_sp clone() const override { return Make(fConfig); } + std::unique_ptr clone() const override { return Make(fConfig); } private: HighContrastFilterEffect(const SkHighContrastConfig& config) @@ -353,7 +354,8 @@ void GLHighContrastFilterEffect::emitCode(EmitArgs& args) { fragBuilder->codeAppendf("%s = color;", args.fOutputColor); } -sk_sp SkHighContrast_Filter::asFragmentProcessor(GrContext*, SkColorSpace*) const { +std::unique_ptr SkHighContrast_Filter::asFragmentProcessor( + GrContext*, SkColorSpace*) const { return HighContrastFilterEffect::Make(fConfig); } #endif diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp index 817f96fd15..fa02104627 100644 --- a/src/effects/SkLightingImageFilter.cpp +++ b/src/effects/SkLightingImageFilter.cpp @@ -411,10 +411,11 @@ protected: const SkIRect& bounds, const SkMatrix& matrix, const OutputProperties& outputProperties) const; - virtual sk_sp makeFragmentProcessor(sk_sp, - const SkMatrix&, - const SkIRect* srcBounds, - BoundaryMode boundaryMode) const = 0; + virtual std::unique_ptr makeFragmentProcessor( + sk_sp, + const SkMatrix&, + const SkIRect* srcBounds, + BoundaryMode boundaryMode) const = 0; #endif private: #if SK_SUPPORT_GPU @@ -442,9 +443,7 @@ void SkLightingImageFilterInternal::drawRect(GrRenderTargetContext* renderTarget SkRect srcRect = dstRect.makeOffset(SkIntToScalar(bounds.x()), SkIntToScalar(bounds.y())); GrPaint paint; paint.setGammaCorrect(renderTargetContext->isGammaCorrect()); - sk_sp 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 @@ protected: sk_sp onMakeColorSpace(SkColorSpaceXformer*) const override; #if SK_SUPPORT_GPU - sk_sp makeFragmentProcessor(sk_sp, - const SkMatrix&, const SkIRect* bounds, - BoundaryMode) const override; + std::unique_ptr makeFragmentProcessor(sk_sp, + const SkMatrix&, + const SkIRect* bounds, + BoundaryMode) const override; #endif private: @@ -578,9 +578,10 @@ protected: sk_sp onMakeColorSpace(SkColorSpaceXformer*) const override; #if SK_SUPPORT_GPU - sk_sp makeFragmentProcessor(sk_sp, - const SkMatrix&, const SkIRect* bounds, - BoundaryMode) const override; + std::unique_ptr makeFragmentProcessor(sk_sp, + const SkMatrix&, + const SkIRect* bounds, + BoundaryMode) const override; #endif private: @@ -623,22 +624,22 @@ private: class GrDiffuseLightingEffect : public GrLightingEffect { public: - static sk_sp Make(sk_sp proxy, - sk_sp light, - SkScalar surfaceScale, - const SkMatrix& matrix, - SkScalar kd, - BoundaryMode boundaryMode, - const SkIRect* srcBounds) { - return sk_sp( + static std::unique_ptr Make(sk_sp proxy, + sk_sp light, + SkScalar surfaceScale, + const SkMatrix& matrix, + SkScalar kd, + BoundaryMode boundaryMode, + const SkIRect* srcBounds) { + return std::unique_ptr( new GrDiffuseLightingEffect(std::move(proxy), std::move(light), surfaceScale, matrix, kd, boundaryMode, srcBounds)); } const char* name() const override { return "DiffuseLighting"; } - sk_sp clone() const override { - return sk_sp(new GrDiffuseLightingEffect(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new GrDiffuseLightingEffect(*this)); } SkScalar kd() const { return fKD; } @@ -668,23 +669,23 @@ private: class GrSpecularLightingEffect : public GrLightingEffect { public: - static sk_sp Make(sk_sp proxy, - sk_sp light, - SkScalar surfaceScale, - const SkMatrix& matrix, - SkScalar ks, - SkScalar shininess, - BoundaryMode boundaryMode, - const SkIRect* srcBounds) { - return sk_sp( + static std::unique_ptr Make(sk_sp proxy, + sk_sp light, + SkScalar surfaceScale, + const SkMatrix& matrix, + SkScalar ks, + SkScalar shininess, + BoundaryMode boundaryMode, + const SkIRect* srcBounds) { + return std::unique_ptr( new GrSpecularLightingEffect(std::move(proxy), std::move(light), surfaceScale, matrix, ks, shininess, boundaryMode, srcBounds)); } const char* name() const override { return "SpecularLighting"; } - sk_sp clone() const override { - return sk_sp(new GrSpecularLightingEffect(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new GrSpecularLightingEffect(*this)); } GrGLSLFragmentProcessor* onCreateGLSLInstance() const override; @@ -1373,11 +1374,11 @@ void SkDiffuseLightingImageFilter::toString(SkString* str) const { #endif #if SK_SUPPORT_GPU -sk_sp SkDiffuseLightingImageFilter::makeFragmentProcessor( - sk_sp proxy, - const SkMatrix& matrix, - const SkIRect* srcBounds, - BoundaryMode boundaryMode) const { +std::unique_ptr SkDiffuseLightingImageFilter::makeFragmentProcessor( + sk_sp 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 @@ void SkSpecularLightingImageFilter::toString(SkString* str) const { #endif #if SK_SUPPORT_GPU -sk_sp SkSpecularLightingImageFilter::makeFragmentProcessor( - sk_sp proxy, - const SkMatrix& matrix, - const SkIRect* srcBounds, - BoundaryMode boundaryMode) const { +std::unique_ptr SkSpecularLightingImageFilter::makeFragmentProcessor( + sk_sp 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 @@ static SkImageFilterLight* create_random_light(SkRandom* random) { } } -sk_sp GrDiffuseLightingEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr GrDiffuseLightingEffect::TestCreate(GrProcessorTestData* d) { int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx : GrProcessorUnitTest::kAlphaTextureIdx; sk_sp proxy = d->textureProxy(texIdx); @@ -2020,7 +2021,7 @@ GrGLSLFragmentProcessor* GrSpecularLightingEffect::onCreateGLSLInstance() const GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSpecularLightingEffect); #if GR_TEST_UTILS -sk_sp GrSpecularLightingEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr GrSpecularLightingEffect::TestCreate(GrProcessorTestData* d) { int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx : GrProcessorUnitTest::kAlphaTextureIdx; sk_sp proxy = d->textureProxy(texIdx); diff --git a/src/effects/SkLumaColorFilter.cpp b/src/effects/SkLumaColorFilter.cpp index 2a065b3720..4422733b61 100644 --- a/src/effects/SkLumaColorFilter.cpp +++ b/src/effects/SkLumaColorFilter.cpp @@ -45,13 +45,13 @@ void SkLumaColorFilter::toString(SkString* str) const { #if SK_SUPPORT_GPU class LumaColorFilterEffect : public GrFragmentProcessor { public: - static sk_sp Make() { - return sk_sp(new LumaColorFilterEffect); + static std::unique_ptr Make() { + return std::unique_ptr(new LumaColorFilterEffect); } const char* name() const override { return "Luminance-to-Alpha"; } - sk_sp clone() const override { return Make(); } + std::unique_ptr clone() const override { return Make(); } private: class GLSLProcessor : public GrGLSLFragmentProcessor { @@ -103,7 +103,8 @@ private: typedef GrFragmentProcessor INHERITED; }; -sk_sp SkLumaColorFilter::asFragmentProcessor(GrContext*, SkColorSpace*) const { +std::unique_ptr SkLumaColorFilter::asFragmentProcessor(GrContext*, + SkColorSpace*) const { return LumaColorFilterEffect::Make(); } #endif diff --git a/src/effects/SkMagnifierImageFilter.cpp b/src/effects/SkMagnifierImageFilter.cpp index 7b03307264..ba019699a0 100644 --- a/src/effects/SkMagnifierImageFilter.cpp +++ b/src/effects/SkMagnifierImageFilter.cpp @@ -49,27 +49,25 @@ sk_sp SkMagnifierImageFilter::Make(const SkRect& srcRect, SkScala #if SK_SUPPORT_GPU class GrMagnifierEffect : public GrFragmentProcessor { public: - static sk_sp Make(sk_sp proxy, - sk_sp colorSpaceXform, - const SkIRect& bounds, - const SkRect& srcRect, - float xInvZoom, - float yInvZoom, - float xInvInset, - float yInvInset) { - return sk_sp(new GrMagnifierEffect(std::move(proxy), - std::move(colorSpaceXform), - bounds, srcRect, - xInvZoom, yInvZoom, - xInvInset, yInvInset)); + static std::unique_ptr Make(sk_sp proxy, + sk_sp colorSpaceXform, + const SkIRect& bounds, + const SkRect& srcRect, + float xInvZoom, + float yInvZoom, + float xInvInset, + float yInvInset) { + return std::unique_ptr( + 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 clone() const override { - return sk_sp(new GrMagnifierEffect(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new GrMagnifierEffect(*this)); } SkString dumpInfo() const override { @@ -285,7 +283,7 @@ GrGLSLFragmentProcessor* GrMagnifierEffect::onCreateGLSLInstance() const { GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMagnifierEffect); #if GR_TEST_UTILS -sk_sp GrMagnifierEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr GrMagnifierEffect::TestCreate(GrProcessorTestData* d) { sk_sp proxy = d->textureProxy(0); const int kMaxWidth = 200; const int kMaxHeight = 200; @@ -298,15 +296,14 @@ sk_sp GrMagnifierEffect::TestCreate(GrProcessorTestData* d) SkIRect bounds = SkIRect::MakeWH(SkIntToScalar(kMaxWidth), SkIntToScalar(kMaxHeight)); SkRect srcRect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height)); - sk_sp 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 @@ sk_sp SkMagnifierImageFilter::onFilterImage(SkSpecialImage* sour SkColorSpace* dstColorSpace = ctx.outputProperties().colorSpace(); sk_sp colorSpaceXform = GrColorSpaceXform::Make(input->getColorSpace(), dstColorSpace); - sk_sp 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 b94ece514d..ce84f3ea10 100644 --- a/src/effects/SkMatrixConvolutionImageFilter.cpp +++ b/src/effects/SkMatrixConvolutionImageFilter.cpp @@ -316,15 +316,15 @@ sk_sp SkMatrixConvolutionImageFilter::onFilterImage(SkSpecialIma offset->fY = bounds.top(); bounds.offset(-inputOffset); - sk_sp 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 a29bca31e6..1585c9d352 100644 --- a/src/effects/SkMorphologyImageFilter.cpp +++ b/src/effects/SkMorphologyImageFilter.cpp @@ -142,16 +142,16 @@ public: enum class Direction { kX, kY }; enum class Type { kErode, kDilate }; - static sk_sp Make(sk_sp proxy, Direction dir, int radius, - Type type) { - return sk_sp( + static std::unique_ptr Make(sk_sp proxy, Direction dir, + int radius, Type type) { + return std::unique_ptr( new GrMorphologyEffect(std::move(proxy), dir, radius, type, nullptr)); } - static sk_sp Make(sk_sp proxy, Direction dir, int radius, - Type type, const float bounds[2]) { - return sk_sp(new GrMorphologyEffect(std::move(proxy), - dir, radius, type, bounds)); + static std::unique_ptr Make(sk_sp proxy, Direction dir, + int radius, Type type, const float bounds[2]) { + return std::unique_ptr( + new GrMorphologyEffect(std::move(proxy), dir, radius, type, bounds)); } Type type() const { return fType; } @@ -163,8 +163,8 @@ public: const char* name() const override { return "Morphology"; } - sk_sp clone() const override { - return sk_sp(new GrMorphologyEffect(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new GrMorphologyEffect(*this)); } private: @@ -382,7 +382,7 @@ bool GrMorphologyEffect::onIsEqual(const GrFragmentProcessor& sBase) const { GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMorphologyEffect); #if GR_TEST_UTILS -sk_sp GrMorphologyEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr GrMorphologyEffect::TestCreate(GrProcessorTestData* d) { int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx : GrProcessorUnitTest::kAlphaTextureIdx; sk_sp proxy = d->textureProxy(texIdx); diff --git a/src/effects/SkOverdrawColorFilter.cpp b/src/effects/SkOverdrawColorFilter.cpp index 4eb9bfcaeb..8ca699e89f 100644 --- a/src/effects/SkOverdrawColorFilter.cpp +++ b/src/effects/SkOverdrawColorFilter.cpp @@ -73,12 +73,12 @@ SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END class OverdrawFragmentProcessor : public GrFragmentProcessor { public: - static sk_sp Make(const SkPMColor* colors); + static std::unique_ptr Make(const SkPMColor* colors); const char* name() const override { return "Overdraw"; } - sk_sp clone() const override { - return sk_sp(new OverdrawFragmentProcessor(fColors)); + std::unique_ptr clone() const override { + return std::unique_ptr(new OverdrawFragmentProcessor(fColors)); } private: @@ -108,12 +108,12 @@ private: typedef GrGLSLFragmentProcessor INHERITED; }; -sk_sp SkOverdrawColorFilter::asFragmentProcessor(GrContext*, - SkColorSpace*) const { +std::unique_ptr SkOverdrawColorFilter::asFragmentProcessor( + GrContext*, SkColorSpace*) const { return OverdrawFragmentProcessor::Make(fColors); } -sk_sp OverdrawFragmentProcessor::Make(const SkPMColor* colors) { +std::unique_ptr 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 @@ sk_sp OverdrawFragmentProcessor::Make(const SkPMColor* colo SkGetPackedA32(colors[i]))); } - return sk_sp(new OverdrawFragmentProcessor(grColors)); + return std::unique_ptr(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 2840a09690..0948f7080d 100644 --- a/src/effects/SkOverdrawColorFilter.h +++ b/src/effects/SkOverdrawColorFilter.h @@ -28,7 +28,8 @@ public: } #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(GrContext*, SkColorSpace*) const override; + std::unique_ptr 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 8b1856a14a..2f045f1c9d 100644 --- a/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp +++ b/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp @@ -204,15 +204,16 @@ public: kSimpleCircular_Mode, }; - static sk_sp Make(const SkRRect& first, const SkRRect& second, - SkScalar radius) { - return sk_sp(new RRectsGaussianEdgeFP(first, second, radius)); + static std::unique_ptr Make(const SkRRect& first, const SkRRect& second, + SkScalar radius) { + return std::unique_ptr( + new RRectsGaussianEdgeFP(first, second, radius)); } const char* name() const override { return "RRectsGaussianEdgeFP"; } - sk_sp clone() const override { - return sk_sp(new RRectsGaussianEdgeFP(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new RRectsGaussianEdgeFP(*this)); } const SkRRect& first() const { return fFirst; } diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp index 0fb91094f9..2101bd65c9 100644 --- a/src/effects/SkTableColorFilter.cpp +++ b/src/effects/SkTableColorFilter.cpp @@ -86,7 +86,8 @@ public: sk_sp makeComposed(sk_sp inner) const override; #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(GrContext*, SkColorSpace*) const override; + std::unique_ptr asFragmentProcessor(GrContext*, + SkColorSpace*) const override; #endif SK_TO_STRING_OVERRIDE() @@ -330,7 +331,7 @@ sk_sp SkTable_ColorFilter::makeComposed(sk_sp inne class ColorTableEffect : public GrFragmentProcessor { public: - static sk_sp Make(GrContext* context, const SkBitmap& bitmap); + static std::unique_ptr Make(GrContext* context, const SkBitmap& bitmap); ~ColorTableEffect() override; @@ -339,7 +340,7 @@ public: const GrTextureStripAtlas* atlas() const { return fAtlas; } int atlasRow() const { return fRow; } - sk_sp clone() const override; + std::unique_ptr clone() const override; private: GrGLSLFragmentProcessor* onCreateGLSLInstance() const override; @@ -443,7 +444,8 @@ void GLColorTableEffect::emitCode(EmitArgs& args) { } /////////////////////////////////////////////////////////////////////////////// -sk_sp ColorTableEffect::Make(GrContext* context, const SkBitmap& bitmap) { +std::unique_ptr ColorTableEffect::Make(GrContext* context, + const SkBitmap& bitmap) { GrTextureStripAtlas::Desc desc; desc.fWidth = bitmap.width(); desc.fHeight = 128; @@ -467,7 +469,7 @@ sk_sp ColorTableEffect::Make(GrContext* context, const SkBi return nullptr; } - return sk_sp(new ColorTableEffect(std::move(proxy), atlas, row)); + return std::unique_ptr(new ColorTableEffect(std::move(proxy), atlas, row)); } ColorTableEffect::ColorTableEffect(sk_sp proxy, GrTextureStripAtlas* atlas, int row) @@ -485,9 +487,9 @@ ColorTableEffect::~ColorTableEffect() { } } -sk_sp ColorTableEffect::clone() const { +std::unique_ptr ColorTableEffect::clone() const { fAtlas->lockRow(fRow); - return sk_sp( + return std::unique_ptr( new ColorTableEffect(sk_ref_sp(fTextureSampler.proxy()), fAtlas, fRow)); } @@ -515,7 +517,7 @@ bool ColorTableEffect::onIsEqual(const GrFragmentProcessor& other) const { GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ColorTableEffect); #if GR_TEST_UTILS -sk_sp ColorTableEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr ColorTableEffect::TestCreate(GrProcessorTestData* d) { int flags = 0; uint8_t luts[256][4]; do { @@ -537,14 +539,14 @@ sk_sp ColorTableEffect::TestCreate(GrProcessorTestData* d) (flags & (1 << 3)) ? luts[3] : nullptr )); sk_sp colorSpace = GrTest::TestColorSpace(d->fRandom); - sk_sp fp = filter->asFragmentProcessor(d->context(), colorSpace.get()); + auto fp = filter->asFragmentProcessor(d->context(), colorSpace.get()); SkASSERT(fp); return fp; } #endif -sk_sp SkTable_ColorFilter::asFragmentProcessor(GrContext* context, - SkColorSpace*) const { +std::unique_ptr 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 f2ffc088f7..150877f645 100644 --- a/src/effects/SkToSRGBColorFilter.cpp +++ b/src/effects/SkToSRGBColorFilter.cpp @@ -86,8 +86,8 @@ void SkToSRGBColorFilter::toString(SkString* str) const { #endif #if SK_SUPPORT_GPU -sk_sp SkToSRGBColorFilter::asFragmentProcessor(GrContext*, - SkColorSpace*) const { +std::unique_ptr 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 f0c70a2a5c..e1033cfe9f 100644 --- a/src/effects/SkXfermodeImageFilter.cpp +++ b/src/effects/SkXfermodeImageFilter.cpp @@ -54,7 +54,8 @@ protected: void drawForeground(SkCanvas* canvas, SkSpecialImage*, const SkIRect&) const; #if SK_SUPPORT_GPU - sk_sp makeFGFrag(sk_sp bgFP) const; + std::unique_ptr makeFGFrag( + std::unique_ptr bgFP) const; #endif private: @@ -243,7 +244,7 @@ sk_sp SkXfermodeImageFilter_Base::filterImageGPU( } GrPaint paint; - sk_sp bgFP; + std::unique_ptr bgFP; if (backgroundProxy) { SkMatrix bgMatrix = SkMatrix::MakeTrans(-SkIntToScalar(backgroundOffset.fX), @@ -266,15 +267,13 @@ sk_sp SkXfermodeImageFilter_Base::filterImageGPU( -SkIntToScalar(foregroundOffset.fY)); sk_sp fgXform = GrColorSpaceXform::Make(foreground->getColorSpace(), outputProperties.colorSpace()); - sk_sp 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 xferFP = this->makeFGFrag(std::move(bgFP)); + std::unique_ptr 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 @@ sk_sp SkXfermodeImageFilter_Base::filterImageGPU( renderTargetContext->refColorSpace()); } -sk_sp -SkXfermodeImageFilter_Base::makeFGFrag(sk_sp bgFP) const { +std::unique_ptr SkXfermodeImageFilter_Base::makeFGFrag( + std::unique_ptr bgFP) const { return GrXfermodeFragmentProcessor::MakeFromDstProcessor(std::move(bgFP), fMode); } diff --git a/src/gpu/GrAppliedClip.h b/src/gpu/GrAppliedClip.h index 7ef3346ed3..bcf6eb9ce8 100644 --- a/src/gpu/GrAppliedClip.h +++ b/src/gpu/GrAppliedClip.h @@ -27,7 +27,7 @@ public: const GrScissorState& scissorState() const { return fScissorState; } const GrWindowRectsState& windowRectsState() const { return fWindowRectsState; } GrFragmentProcessor* clipCoverageFragmentProcessor() const { return fClipCoverageFP.get(); } - sk_sp detachClipCoverageFragmentProcessor() { + std::unique_ptr detachClipCoverageFragmentProcessor() { return std::move(fClipCoverageFP); } bool hasStencilClip() const { return SkClipStack::kInvalidGenID != fClipStackID; } @@ -51,9 +51,9 @@ public: fWindowRectsState.set(windows, mode); } - void addCoverageFP(sk_sp fp) { + void addCoverageFP(std::unique_ptr fp) { SkASSERT(!fClipCoverageFP); - fClipCoverageFP = fp; + fClipCoverageFP = std::move(fp); } void addStencilClip(uint32_t clipStackID) { @@ -85,7 +85,7 @@ public: private: GrScissorState fScissorState; GrWindowRectsState fWindowRectsState; - sk_sp fClipCoverageFP; + std::unique_ptr fClipCoverageFP; uint32_t fClipStackID = SkClipStack::kInvalidGenID; }; diff --git a/src/gpu/GrClipStackClip.cpp b/src/gpu/GrClipStackClip.cpp index 49d56351b6..0b07fd5c70 100644 --- a/src/gpu/GrClipStackClip.cpp +++ b/src/gpu/GrClipStackClip.cpp @@ -73,8 +73,8 @@ void GrClipStackClip::getConservativeBounds(int width, int height, SkIRect* devR //////////////////////////////////////////////////////////////////////////////// // set up the draw state to enable the aa clipping mask. -static sk_sp create_fp_for_mask(sk_sp mask, - const SkIRect &devBound) { +static std::unique_ptr create_fp_for_mask(sk_sp 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 @@ bool GrClipStackClip::UseSWOnlyPath(GrContext* context, static bool get_analytic_clip_processor(const ElementList& elements, bool abortIfAA, const SkRect& drawDevBounds, - sk_sp* resultFP) { + std::unique_ptr* resultFP) { SkASSERT(elements.count() <= kMaxAnalyticElements); - SkSTArray> fps; + SkSTArray> fps; ElementList::Iter iter(elements); while (iter.get()) { SkClipOp op = iter.get()->getOp(); @@ -302,7 +302,7 @@ bool GrClipStackClip::apply(GrContext* context, GrRenderTargetContext* renderTar // is multisampled. disallowAnalyticAA = useHWAA || hasUserStencilSettings; } - sk_sp clipFP; + std::unique_ptr 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 efa8e8c610..d5c82c64da 100644 --- a/src/gpu/GrContext.cpp +++ b/src/gpu/GrContext.cpp @@ -479,8 +479,7 @@ bool GrContextPriv::writeSurfacePixels(GrSurfaceContext* dst, } if (tempProxy) { - sk_sp 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 @@ bool GrContextPriv::readSurfacePixels(GrSurfaceContext* src, if (tempRTC) { SkMatrix textureMatrix = SkMatrix::MakeTrans(SkIntToScalar(left), SkIntToScalar(top)); sk_sp proxy = src->asTextureProxyRef(); - sk_sp 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 @@ bool GrContext::abandoned() const { return fDrawingManager->wasAbandoned(); } -sk_sp GrContext::createPMToUPMEffect(sk_sp fp, - bool useConfigConversionEffect) { +std::unique_ptr GrContext::createPMToUPMEffect( + std::unique_ptr 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 GrContext::createPMToUPMEffect(sk_sp GrContext::createUPMToPMEffect(sk_sp fp, - bool useConfigConversionEffect) { +std::unique_ptr GrContext::createUPMToPMEffect( + std::unique_ptr 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 44b14add2d..060cde5302 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 @@ bool GrFragmentProcessor::instantiate(GrResourceProvider* resourceProvider) cons return true; } -int GrFragmentProcessor::registerChildProcessor(sk_sp 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 child) { this->combineRequiredFeatures(*child); if (child->usesLocalCoords()) { @@ -83,19 +83,11 @@ int GrFragmentProcessor::registerChildProcessor(sk_sp child } 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 @@ bool GrFragmentProcessor::hasSameTransforms(const GrFragmentProcessor& that) con return true; } -sk_sp GrFragmentProcessor::MulOutputByInputAlpha( - sk_sp fp) { +std::unique_ptr GrFragmentProcessor::MulOutputByInputAlpha( + std::unique_ptr fp) { if (!fp) { return nullptr; } @@ -121,13 +113,13 @@ namespace { class PremulInputFragmentProcessor : public GrFragmentProcessor { public: - static sk_sp Make() { - return sk_sp(new PremulInputFragmentProcessor); + static std::unique_ptr Make() { + return std::unique_ptr(new PremulInputFragmentProcessor); } const char* name() const override { return "PremultiplyInput"; } - sk_sp clone() const override { return Make(); } + std::unique_ptr clone() const override { return Make(); } private: PremulInputFragmentProcessor() @@ -163,13 +155,13 @@ private: class UnpremulInputFragmentProcessor : public GrFragmentProcessor { public: - static sk_sp Make() { - return sk_sp(new UnpremulInputFragmentProcessor); + static std::unique_ptr Make() { + return std::unique_ptr(new UnpremulInputFragmentProcessor); } const char* name() const override { return "UnpremultiplyInput"; } - sk_sp clone() const override { return Make(); } + std::unique_ptr clone() const override { return Make(); } private: UnpremulInputFragmentProcessor() @@ -206,42 +198,48 @@ private: } -sk_sp GrFragmentProcessor::PremulInput(sk_sp fp) { +std::unique_ptr GrFragmentProcessor::PremulInput( + std::unique_ptr fp) { if (!fp) { return nullptr; } - sk_sp fpPipeline[] = { PremulInputFragmentProcessor::Make(), fp}; + std::unique_ptr fpPipeline[] = { PremulInputFragmentProcessor::Make(), + std::move(fp) }; return GrFragmentProcessor::RunInSeries(fpPipeline, 2); } -sk_sp GrFragmentProcessor::PremulOutput(sk_sp fp) { +std::unique_ptr GrFragmentProcessor::PremulOutput( + std::unique_ptr fp) { if (!fp) { return nullptr; } - sk_sp fpPipeline[] = { fp, PremulInputFragmentProcessor::Make() }; + std::unique_ptr fpPipeline[] = { std::move(fp), + PremulInputFragmentProcessor::Make() }; return GrFragmentProcessor::RunInSeries(fpPipeline, 2); } -sk_sp GrFragmentProcessor::UnpremulOutput(sk_sp fp) { +std::unique_ptr GrFragmentProcessor::UnpremulOutput( + std::unique_ptr fp) { if (!fp) { return nullptr; } - sk_sp fpPipeline[] = { fp, UnpremulInputFragmentProcessor::Make() }; + std::unique_ptr fpPipeline[] = { std::move(fp), + UnpremulInputFragmentProcessor::Make() }; return GrFragmentProcessor::RunInSeries(fpPipeline, 2); } -sk_sp GrFragmentProcessor::SwizzleOutput(sk_sp fp, - const GrSwizzle& swizzle) { +std::unique_ptr GrFragmentProcessor::SwizzleOutput( + std::unique_ptr fp, const GrSwizzle& swizzle) { class SwizzleFragmentProcessor : public GrFragmentProcessor { public: - static sk_sp Make(const GrSwizzle& swizzle) { - return sk_sp(new SwizzleFragmentProcessor(swizzle)); + static std::unique_ptr Make(const GrSwizzle& swizzle) { + return std::unique_ptr(new SwizzleFragmentProcessor(swizzle)); } const char* name() const override { return "Swizzle"; } const GrSwizzle& swizzle() const { return fSwizzle; } - sk_sp clone() const override { return Make(fSwizzle); } + std::unique_ptr clone() const override { return Make(fSwizzle); } private: SwizzleFragmentProcessor(const GrSwizzle& swizzle) @@ -289,30 +287,32 @@ sk_sp GrFragmentProcessor::SwizzleOutput(sk_sp fpPipeline[] = { fp, SwizzleFragmentProcessor::Make(swizzle) }; + std::unique_ptr fpPipeline[] = { std::move(fp), + SwizzleFragmentProcessor::Make(swizzle) }; return GrFragmentProcessor::RunInSeries(fpPipeline, 2); } -sk_sp GrFragmentProcessor::MakeInputPremulAndMulByOutput( - sk_sp fp) { - +std::unique_ptr GrFragmentProcessor::MakeInputPremulAndMulByOutput( + std::unique_ptr fp) { class PremulFragmentProcessor : public GrFragmentProcessor { public: - static sk_sp Make(sk_sp processor) { - return sk_sp(new PremulFragmentProcessor(std::move(processor))); + static std::unique_ptr Make( + std::unique_ptr processor) { + return std::unique_ptr( + new PremulFragmentProcessor(std::move(processor))); } const char* name() const override { return "Premultiply"; } - sk_sp clone() const override { + std::unique_ptr clone() const override { return Make(this->childProcessor(0).clone()); } private: - PremulFragmentProcessor(sk_sp processor) + PremulFragmentProcessor(std::unique_ptr processor) : INHERITED(OptFlags(processor.get())) { this->initClassID(); - this->registerChildProcessor(processor); + this->registerChildProcessor(std::move(processor)); } GrGLSLFragmentProcessor* onCreateGLSLInstance() const override { @@ -363,18 +363,19 @@ sk_sp GrFragmentProcessor::MakeInputPremulAndMulByOutput( ////////////////////////////////////////////////////////////////////////////// -sk_sp GrFragmentProcessor::OverrideInput(sk_sp fp, - GrColor4f color) { +std::unique_ptr GrFragmentProcessor::OverrideInput( + std::unique_ptr fp, GrColor4f color) { class ReplaceInputFragmentProcessor : public GrFragmentProcessor { public: - static sk_sp Make(sk_sp child, GrColor4f color) { - return sk_sp(new ReplaceInputFragmentProcessor(std::move(child), - color)); + static std::unique_ptr Make(std::unique_ptr child, + GrColor4f color) { + return std::unique_ptr( + new ReplaceInputFragmentProcessor(std::move(child), color)); } const char* name() const override { return "Replace Color"; } - sk_sp clone() const override { + std::unique_ptr clone() const override { return Make(this->childProcessor(0).clone(), fColor); } @@ -411,7 +412,7 @@ sk_sp GrFragmentProcessor::OverrideInput(sk_sp child, GrColor4f color) + ReplaceInputFragmentProcessor(std::unique_ptr child, GrColor4f color) : INHERITED(OptFlags(child.get(), color)), fColor(color) { this->initClassID(); this->registerChildProcessor(std::move(child)); @@ -451,18 +452,19 @@ sk_sp GrFragmentProcessor::OverrideInput(sk_sp GrFragmentProcessor::RunInSeries(sk_sp* series, - int cnt) { +std::unique_ptr GrFragmentProcessor::RunInSeries( + std::unique_ptr* series, int cnt) { class SeriesFragmentProcessor : public GrFragmentProcessor { public: - static sk_sp Make(sk_sp* children, int cnt) { - return sk_sp(new SeriesFragmentProcessor(children, cnt)); + static std::unique_ptr Make( + std::unique_ptr* children, int cnt) { + return std::unique_ptr(new SeriesFragmentProcessor(children, cnt)); } const char* name() const override { return "Series"; } - sk_sp clone() const override { - SkSTArray<4, sk_sp> children(this->numChildProcessors()); + std::unique_ptr clone() const override { + SkSTArray<4, std::unique_ptr> 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 @@ sk_sp GrFragmentProcessor::RunInSeries(sk_sp* children, int cnt) + SeriesFragmentProcessor(std::unique_ptr* children, int cnt) : INHERITED(OptFlags(children, cnt)) { SkASSERT(cnt > 1); this->initClassID(); @@ -501,7 +503,7 @@ sk_sp GrFragmentProcessor::RunInSeries(sk_sp* children, int cnt) { + static OptimizationFlags OptFlags(std::unique_ptr* 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 @@ sk_sp GrFragmentProcessor::RunInSeries(sk_sp> replacementSeries; + SkTArray> replacementSeries; GrColor4f knownColor; int leadingFPsToEliminate = info.initialProcessorsToEliminate(&knownColor); if (leadingFPsToEliminate) { - sk_sp colorFP( + std::unique_ptr 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 0784031d30..29a302b100 100644 --- a/src/gpu/GrFragmentProcessor.h +++ b/src/gpu/GrFragmentProcessor.h @@ -23,7 +23,7 @@ class GrSwizzle; 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 @@ public: * 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 MulOutputByInputAlpha(sk_sp); + static std::unique_ptr MulOutputByInputAlpha( + std::unique_ptr); /** * This assumes that the input color to the returned processor will be unpremul and that the @@ -41,38 +42,42 @@ public: * The result of the returned processor is a premul of its input color modulated by the child * processor's premul output. */ - static sk_sp MakeInputPremulAndMulByOutput(sk_sp); + static std::unique_ptr MakeInputPremulAndMulByOutput( + std::unique_ptr); /** * 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 OverrideInput(sk_sp, GrColor4f); + static std::unique_ptr OverrideInput(std::unique_ptr, + GrColor4f); /** * Returns a fragment processor that premuls the input before calling the passed in fragment * processor. */ - static sk_sp PremulInput(sk_sp); + static std::unique_ptr PremulInput(std::unique_ptr); /** * Returns a fragment processor that calls the passed in fragment processor, and then premuls * the output. */ - static sk_sp PremulOutput(sk_sp); + static std::unique_ptr PremulOutput(std::unique_ptr); /** * Returns a fragment processor that calls the passed in fragment processor, and then unpremuls * the output. */ - static sk_sp UnpremulOutput(sk_sp); + static std::unique_ptr UnpremulOutput( + std::unique_ptr); /** * Returns a fragment processor that calls the passed in fragment processor, and then swizzles * the output. */ - static sk_sp SwizzleOutput(sk_sp, const GrSwizzle&); + static std::unique_ptr SwizzleOutput(std::unique_ptr, + const GrSwizzle&); /** * Returns a fragment processor that runs the passed in array of fragment processors in a @@ -82,15 +87,14 @@ public: * * The array elements with be moved. */ - static sk_sp RunInSeries(sk_sp*, int cnt); - - ~GrFragmentProcessor() override; + static std::unique_ptr RunInSeries(std::unique_ptr*, + 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 clone() const = 0; + virtual std::unique_ptr clone() const = 0; GrGLSLFragmentProcessor* createGLSLInstance() const; @@ -117,6 +121,8 @@ public: 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 @@ protected: * 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 child); + int registerChildProcessor(std::unique_ptr 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 @@ private: SkSTArray<4, const GrCoordTransform*, true> fCoordTransforms; - /** - * This is not SkSTArray<1, sk_sp> because this class holds strong - * references until notifyRefCntIsZero and then it holds pending executions. - */ - SkSTArray<1, GrFragmentProcessor*, true> fChildProcessors; + SkSTArray<1, std::unique_ptr, true> fChildProcessors; typedef GrResourceIOProcessor INHERITED; }; diff --git a/src/gpu/GrPaint.h b/src/gpu/GrPaint.h index 1ab01f3ce4..ae19cad176 100644 --- a/src/gpu/GrPaint.h +++ b/src/gpu/GrPaint.h @@ -91,7 +91,7 @@ public: /** * Appends an additional color processor to the color computation. */ - void addColorFragmentProcessor(sk_sp fp) { + void addColorFragmentProcessor(std::unique_ptr fp) { SkASSERT(fp); fColorFragmentProcessors.push_back(std::move(fp)); fTrivial = false; @@ -100,7 +100,7 @@ public: /** * Appends an additional coverage processor to the coverage computation. */ - void addCoverageFragmentProcessor(sk_sp fp) { + void addCoverageFragmentProcessor(std::unique_ptr fp) { SkASSERT(fp); fCoverageFragmentProcessors.push_back(std::move(fp)); fTrivial = false; @@ -157,8 +157,8 @@ private: friend class GrProcessorSet; const GrXPFactory* fXPFactory = nullptr; - SkSTArray<4, sk_sp> fColorFragmentProcessors; - SkSTArray<2, sk_sp> fCoverageFragmentProcessors; + SkSTArray<4, std::unique_ptr> fColorFragmentProcessors; + SkSTArray<2, std::unique_ptr> fCoverageFragmentProcessors; bool fDisableOutputConversionToSRGB = false; bool fAllowSRGBInputs = false; bool fTrivial = true; diff --git a/src/gpu/GrPipeline.cpp b/src/gpu/GrPipeline.cpp index a6e8fbad20..d07dd08624 100644 --- a/src/gpu/GrPipeline.cpp +++ b/src/gpu/GrPipeline.cpp @@ -58,22 +58,20 @@ GrPipeline::GrPipeline(const InitArgs& args, GrProcessorSet&& processors, 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 7583c6c839..c4319958a4 100644 --- a/src/gpu/GrPipeline.h +++ b/src/gpu/GrPipeline.h @@ -230,8 +230,7 @@ private: using RenderTargetProxy = GrPendingIOResource; using DstTextureProxy = GrPendingIOResource; - using PendingFragmentProcessor = GrPendingProgramElement; - using FragmentProcessorArray = SkAutoSTArray<8, PendingFragmentProcessor>; + using FragmentProcessorArray = SkAutoSTArray<8, std::unique_ptr>; DstTextureProxy fDstTextureProxy; SkIPoint fDstTextureOffset; diff --git a/src/gpu/GrProcessorSet.cpp b/src/gpu/GrProcessorSet.cpp index 20d6745cad..cb4a25f799 100644 --- a/src/gpu/GrProcessorSet.cpp +++ b/src/gpu/GrProcessorSet.cpp @@ -29,11 +29,11 @@ GrProcessorSet::GrProcessorSet(GrPaint&& paint) : fXP(paint.getXPFactory()) { 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 @@ GrProcessorSet::GrProcessorSet(SkBlendMode mode) , fFragmentProcessorOffset(0) , fFlags(0) {} -GrProcessorSet::GrProcessorSet(sk_sp colorFP) +GrProcessorSet::GrProcessorSet(std::unique_ptr 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 @@ GrProcessorSet::GrProcessorSet(GrProcessorSet&& that) , 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 @@ GrProcessorSet::Analysis GrProcessorSet::finalize(const GrProcessorAnalysisColor 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* 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 @@ GrProcessorSet::Analysis GrProcessorSet::finalize(const GrProcessorAnalysisColor 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 d3aaf6dd61..023c4dfd6b 100644 --- a/src/gpu/GrProcessorSet.h +++ b/src/gpu/GrProcessorSet.h @@ -25,7 +25,7 @@ private: public: GrProcessorSet(GrPaint&&); GrProcessorSet(SkBlendMode); - GrProcessorSet(sk_sp colorFP); + GrProcessorSet(std::unique_ptr colorFP); GrProcessorSet(GrProcessorSet&&); GrProcessorSet(const GrProcessorSet&) = delete; GrProcessorSet& operator=(const GrProcessorSet&) = delete; @@ -42,10 +42,11 @@ public: 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 @@ public: return sk_ref_sp(fXP.fProcessor); } + std::unique_ptr detachColorFragmentProcessor(int idx) { + SkASSERT(idx < fColorFragmentProcessorCnt); + return std::move(fFragmentProcessors[idx + fFragmentProcessorOffset]); + } + + std::unique_ptr 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 @@ private: return fXP.fFactory; } - SkAutoSTArray<4, const GrFragmentProcessor*> fFragmentProcessors; + SkAutoSTArray<4, std::unique_ptr> fFragmentProcessors; XP fXP; uint8_t fColorFragmentProcessorCnt = 0; uint8_t fFragmentProcessorOffset = 0; diff --git a/src/gpu/GrProcessorUnitTest.cpp b/src/gpu/GrProcessorUnitTest.cpp index 563fd7c843..473903d8d8 100644 --- a/src/gpu/GrProcessorUnitTest.cpp +++ b/src/gpu/GrProcessorUnitTest.cpp @@ -10,9 +10,9 @@ #if GR_TEST_UTILS -sk_sp GrProcessorUnitTest::MakeChildFP(GrProcessorTestData* data) { +std::unique_ptr GrProcessorUnitTest::MakeChildFP(GrProcessorTestData* data) { #if SK_ALLOW_STATIC_GLOBAL_INITIALIZERS - sk_sp fp; + std::unique_ptr fp; do { fp = GrFragmentProcessorTestFactory::Make(data); SkASSERT(fp); diff --git a/src/gpu/GrProcessorUnitTest.h b/src/gpu/GrProcessorUnitTest.h index 73a2cf3279..739b2f0c26 100644 --- a/src/gpu/GrProcessorUnitTest.h +++ b/src/gpu/GrProcessorUnitTest.h @@ -35,7 +35,7 @@ enum { /** 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 MakeChildFP(GrProcessorTestData*); +std::unique_ptr MakeChildFP(GrProcessorTestData*); } @@ -117,7 +117,7 @@ private: static SkTArray*, true>* GetFactories(); }; -using GrFragmentProcessorTestFactory = GrProcessorTestFactory>; +using GrFragmentProcessorTestFactory = GrProcessorTestFactory>; using GrGeometryProcessorTestFactory = GrProcessorTestFactory>; class GrXPFactoryTestFactory : private SkNoncopyable { @@ -151,7 +151,7 @@ private: #define GR_DECLARE_FRAGMENT_PROCESSOR_TEST \ static GrFragmentProcessorTestFactory gTestFactory SK_UNUSED; \ - static sk_sp TestCreate(GrProcessorTestData*); + static std::unique_ptr TestCreate(GrProcessorTestData*); #define GR_DECLARE_XP_FACTORY_TEST \ static GrXPFactoryTestFactory gTestFactory SK_UNUSED; \ @@ -175,7 +175,7 @@ private: // 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 TestCreate(GrProcessorTestData*); + static std::unique_ptr 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 10f21e8ed2..03b120c2c1 100644 --- a/src/gpu/GrRenderTargetContext.cpp +++ b/src/gpu/GrRenderTargetContext.cpp @@ -1205,12 +1205,12 @@ bool GrRenderTargetContext::drawFilledDRRect(const GrClip& clip, } // TODO these need to be a geometry processors - sk_sp innerEffect(GrRRectEffect::Make(innerEdgeType, *inner)); + std::unique_ptr innerEffect(GrRRectEffect::Make(innerEdgeType, *inner)); if (!innerEffect) { return false; } - sk_sp outerEffect(GrRRectEffect::Make(outerEdgeType, *outer)); + std::unique_ptr outerEffect(GrRRectEffect::Make(outerEdgeType, *outer)); if (!outerEffect) { return false; } diff --git a/src/gpu/GrRenderTargetContext.h b/src/gpu/GrRenderTargetContext.h index 2b9308a544..33a9d8be1e 100644 --- a/src/gpu/GrRenderTargetContext.h +++ b/src/gpu/GrRenderTargetContext.h @@ -390,8 +390,8 @@ private: 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, sk_sp); + friend void test_draw_op(GrRenderTargetContext*, std::unique_ptr, + sk_sp); void internalClear(const GrFixedClip&, const GrColor, bool canIgnoreClip); diff --git a/src/gpu/GrTextureAdjuster.cpp b/src/gpu/GrTextureAdjuster.cpp index 166cb9d54b..546ea67b60 100644 --- a/src/gpu/GrTextureAdjuster.cpp +++ b/src/gpu/GrTextureAdjuster.cpp @@ -105,14 +105,13 @@ sk_sp GrTextureAdjuster::refTextureProxySafeForParams( return copy; } -sk_sp GrTextureAdjuster::createFragmentProcessor( - const SkMatrix& origTextureMatrix, - const SkRect& origConstraintRect, - FilterConstraint filterConstraint, - bool coordsLimitedToConstraintRect, - const GrSamplerParams::FilterMode* filterOrNullForBicubic, - SkColorSpace* dstColorSpace) { - +std::unique_ptr 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 eb500f7929..fad533f30f 100644 --- a/src/gpu/GrTextureAdjuster.h +++ b/src/gpu/GrTextureAdjuster.h @@ -27,13 +27,13 @@ public: sk_sp refTextureProxySafeForParams(const GrSamplerParams&, SkIPoint* outOffset, SkScalar scaleAdjust[2]); - sk_sp createFragmentProcessor( - const SkMatrix& textureMatrix, - const SkRect& constraintRect, - FilterConstraint, - bool coordsLimitedToConstraintRect, - const GrSamplerParams::FilterMode* filterOrNullForBicubic, - SkColorSpace* dstColorSpace) override; + std::unique_ptr 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 2962ddb4c2..7e257d8a78 100644 --- a/src/gpu/GrTextureMaker.cpp +++ b/src/gpu/GrTextureMaker.cpp @@ -76,14 +76,13 @@ sk_sp GrTextureMaker::refTextureProxyForParams(const GrSamplerPa return result; } -sk_sp GrTextureMaker::createFragmentProcessor( - const SkMatrix& textureMatrix, - const SkRect& constraintRect, - FilterConstraint filterConstraint, - bool coordsLimitedToConstraintRect, - const GrSamplerParams::FilterMode* filterOrNullForBicubic, - SkColorSpace* dstColorSpace) { - +std::unique_ptr 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 9e1e0dd96e..5055a8aae3 100644 --- a/src/gpu/GrTextureMaker.h +++ b/src/gpu/GrTextureMaker.h @@ -30,13 +30,13 @@ public: sk_sp* texColorSpace, SkScalar scaleAdjust[2]); - sk_sp createFragmentProcessor( - const SkMatrix& textureMatrix, - const SkRect& constraintRect, - FilterConstraint filterConstraint, - bool coordsLimitedToConstraintRect, - const GrSamplerParams::FilterMode* filterOrNullForBicubic, - SkColorSpace* dstColorSpace) override; + std::unique_ptr 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 78d143b435..92732238e6 100644 --- a/src/gpu/GrTextureProducer.cpp +++ b/src/gpu/GrTextureProducer.cpp @@ -218,13 +218,13 @@ GrTextureProducer::DomainMode GrTextureProducer::DetermineDomainMode( return kDomain_DomainMode; } -sk_sp GrTextureProducer::CreateFragmentProcessorForDomainAndFilter( - sk_sp proxy, - sk_sp colorSpaceXform, - const SkMatrix& textureMatrix, - DomainMode domainMode, - const SkRect& domain, - const GrSamplerParams::FilterMode* filterOrNullForBicubic) { +std::unique_ptr GrTextureProducer::CreateFragmentProcessorForDomainAndFilter( + sk_sp proxy, + sk_sp 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 6a32e2f76e..ccc0dae2ee 100644 --- a/src/gpu/GrTextureProducer.h +++ b/src/gpu/GrTextureProducer.h @@ -56,13 +56,13 @@ public: * @param filterOrNullForBicubic If non-null indicates the filter mode. If null means * use bicubic filtering. **/ - virtual sk_sp createFragmentProcessor( - const SkMatrix& textureMatrix, - const SkRect& constraintRect, - FilterConstraint filterConstraint, - bool coordsLimitedToConstraintRect, - const GrSamplerParams::FilterMode* filterOrNullForBicubic, - SkColorSpace* dstColorSpace) = 0; + virtual std::unique_ptr createFragmentProcessor( + const SkMatrix& textureMatrix, + const SkRect& constraintRect, + FilterConstraint filterConstraint, + bool coordsLimitedToConstraintRect, + const GrSamplerParams::FilterMode* filterOrNullForBicubic, + SkColorSpace* dstColorSpace) = 0; virtual ~GrTextureProducer() {} @@ -130,13 +130,13 @@ protected: const GrSamplerParams::FilterMode* filterModeOrNullForBicubic, SkRect* domainRect); - static sk_sp CreateFragmentProcessorForDomainAndFilter( - sk_sp proxy, - sk_sp, - const SkMatrix& textureMatrix, - DomainMode, - const SkRect& domain, - const GrSamplerParams::FilterMode* filterOrNullForBicubic); + static std::unique_ptr CreateFragmentProcessorForDomainAndFilter( + sk_sp proxy, + sk_sp, + 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 12390aaab0..6b58d42cd7 100644 --- a/src/gpu/GrYUVProvider.cpp +++ b/src/gpu/GrYUVProvider.cpp @@ -134,11 +134,11 @@ sk_sp GrYUVProvider::refAsTextureProxy(GrContext* ctx, const GrS } GrPaint paint; - sk_sp 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 @@ sk_sp GrYUVProvider::refAsTextureProxy(GrContext* ctx, const GrS // 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 colorConversionProcessor = + std::unique_ptr 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 607165cfd3..b0ca549992 100644 --- a/src/gpu/SkGpuDevice.cpp +++ b/src/gpu/SkGpuDevice.cpp @@ -1028,7 +1028,7 @@ void SkGpuDevice::drawBitmapTile(const SkBitmap& bitmap, // Construct a GrPaint by setting the bitmap texture as the first effect and then configuring // the rest from the SkPaint. - sk_sp fp; + std::unique_ptr fp; if (needsTextureDomain && (SkCanvas::kStrict_SrcRectConstraint == constraint)) { // Use a constrained texture domain to avoid color bleeding @@ -1132,9 +1132,8 @@ void SkGpuDevice::drawSpecial(SkSpecialImage* special1, int left, int top, const sk_sp colorSpaceXform = GrColorSpaceXform::Make(result->getColorSpace(), fRenderTargetContext->getColorSpace()); - sk_sp 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 @@ void SkGpuDevice::drawProducerNine(GrTextureProducer* producer, } static const GrSamplerParams::FilterMode kMode = GrSamplerParams::kNone_FilterMode; - sk_sp 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 @@ void SkGpuDevice::drawProducerLattice(GrTextureProducer* producer, CHECK_SHOULD_DRAW(); static const GrSamplerParams::FilterMode kMode = GrSamplerParams::kNone_FilterMode; - sk_sp fp( - producer->createFragmentProcessor(SkMatrix::I(), - SkRect::MakeIWH(producer->width(), producer->height()), - GrTextureProducer::kNo_FilterConstraint, true, - &kMode, fRenderTargetContext->getColorSpace())); + std::unique_ptr 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 48015a3906..6fa171113b 100644 --- a/src/gpu/SkGpuDevice_drawTexture.cpp +++ b/src/gpu/SkGpuDevice_drawTexture.cpp @@ -201,16 +201,16 @@ void SkGpuDevice::drawTextureProducerImpl(GrTextureProducer* producer, } textureMatrix = &tempMatrix; } - sk_sp 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 e426b95af0..c1fb2623b6 100644 --- a/src/gpu/SkGr.cpp +++ b/src/gpu/SkGr.cpp @@ -404,7 +404,7 @@ static inline bool skpaint_to_grpaint_impl(GrContext* context, GrRenderTargetContext* rtc, const SkPaint& skPaint, const SkMatrix& viewM, - sk_sp* shaderProcessor, + std::unique_ptr* shaderProcessor, SkBlendMode* primColorMode, GrPaint* grPaint) { grPaint->setAllowSRGBInputs(rtc->isGammaCorrect()); @@ -415,10 +415,10 @@ static inline bool skpaint_to_grpaint_impl(GrContext* context, // Setup the initial color considering the shader, the SkPaint color, and the presence or not // of per-vertex colors. - sk_sp shaderFP; + std::unique_ptr 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 @@ static inline bool skpaint_to_grpaint_impl(GrContext* context, // 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 @@ static inline bool skpaint_to_grpaint_impl(GrContext* context, 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 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 @@ static inline bool skpaint_to_grpaint_impl(GrContext* context, colorFilter->filterColor(skPaint.getColor()), nullptr, nullptr)); } } else { - sk_sp 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 @@ static inline bool skpaint_to_grpaint_impl(GrContext* context, if (maskFilter) { GrFragmentProcessor* mfFP; if (maskFilter->asFragmentProcessor(&mfFP)) { - grPaint->addCoverageFragmentProcessor(sk_sp(mfFP)); + grPaint->addCoverageFragmentProcessor(std::unique_ptr(mfFP)); } } @@ -559,7 +557,7 @@ bool SkPaintToGrPaint(GrContext* context, GrRenderTargetContext* rtc, const SkPa bool SkPaintToGrPaintReplaceShader(GrContext* context, GrRenderTargetContext* rtc, const SkPaint& skPaint, - sk_sp shaderFP, + std::unique_ptr shaderFP, GrPaint* grPaint) { if (!shaderFP) { return false; @@ -574,8 +572,8 @@ bool SkPaintToGrPaintNoShader(GrContext* context, 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 kNullShaderFP(nullptr); - static sk_sp* kIgnoreShader = &kNullShaderFP; + static std::unique_ptr kNullShaderFP(nullptr); + static std::unique_ptr* kIgnoreShader = &kNullShaderFP; return skpaint_to_grpaint_impl(context, rtc, skPaint, SkMatrix::I(), kIgnoreShader, nullptr, grPaint); } @@ -596,10 +594,10 @@ bool SkPaintToGrPaintWithTexture(GrContext* context, GrRenderTargetContext* rtc, const SkPaint& paint, const SkMatrix& viewM, - sk_sp fp, + std::unique_ptr fp, bool textureIsAlphaOnly, GrPaint* grPaint) { - sk_sp shaderFP; + std::unique_ptr shaderFP; if (textureIsAlphaOnly) { if (const auto* shader = as_SB(paint.getShader())) { shaderFP = shader->asFragmentProcessor( @@ -608,13 +606,13 @@ bool SkPaintToGrPaintWithTexture(GrContext* context, if (!shaderFP) { return false; } - sk_sp fpSeries[] = { std::move(shaderFP), std::move(fp) }; + std::unique_ptr 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 1f7f2ad425..126dc4c66c 100644 --- a/src/gpu/SkGr.h +++ b/src/gpu/SkGr.h @@ -115,7 +115,7 @@ bool SkPaintToGrPaintNoShader(GrContext* context, bool SkPaintToGrPaintReplaceShader(GrContext*, GrRenderTargetContext*, const SkPaint& skPaint, - sk_sp shaderFP, + std::unique_ptr shaderFP, GrPaint* grPaint); /** Blends the SkPaint's shader (or color if no shader) with the color which specified via a @@ -143,7 +143,7 @@ bool SkPaintToGrPaintWithTexture(GrContext* context, GrRenderTargetContext* rtc, const SkPaint& paint, const SkMatrix& viewM, - sk_sp fp, + std::unique_ptr fp, bool textureIsAlphaOnly, GrPaint* grPaint); diff --git a/src/gpu/effects/GrBicubicEffect.cpp b/src/gpu/effects/GrBicubicEffect.cpp index 28fcd9e1dc..c8b302cbdd 100644 --- a/src/gpu/effects/GrBicubicEffect.cpp +++ b/src/gpu/effects/GrBicubicEffect.cpp @@ -188,7 +188,7 @@ bool GrBicubicEffect::onIsEqual(const GrFragmentProcessor& sBase) const { GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrBicubicEffect); #if GR_TEST_UTILS -sk_sp GrBicubicEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr GrBicubicEffect::TestCreate(GrProcessorTestData* d) { int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx : GrProcessorUnitTest::kAlphaTextureIdx; sk_sp colorSpaceXform = GrTest::TestColorXform(d->fRandom); diff --git a/src/gpu/effects/GrBicubicEffect.h b/src/gpu/effects/GrBicubicEffect.h index 65e2c3dbba..7812f3fcb0 100644 --- a/src/gpu/effects/GrBicubicEffect.h +++ b/src/gpu/effects/GrBicubicEffect.h @@ -22,8 +22,8 @@ public: const char* name() const override { return "Bicubic"; } - sk_sp clone() const override { - return sk_sp(new GrBicubicEffect(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new GrBicubicEffect(*this)); } const GrTextureDomain& domain() const { return fDomain; } @@ -33,25 +33,23 @@ public: /** * Create a Mitchell filter effect with specified texture matrix and x/y tile modes. */ - static sk_sp Make(sk_sp proxy, - sk_sp colorSpaceXform, - const SkMatrix& matrix, - const SkShader::TileMode tileModes[2]) { - return sk_sp(new GrBicubicEffect(std::move(proxy), - std::move(colorSpaceXform), - matrix, tileModes)); + static std::unique_ptr Make(sk_sp proxy, + sk_sp colorSpaceXform, + const SkMatrix& matrix, + const SkShader::TileMode tileModes[2]) { + return std::unique_ptr(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 Make(sk_sp proxy, - sk_sp colorSpaceXform, - const SkMatrix& matrix, - const SkRect& domain) { - return sk_sp(new GrBicubicEffect(std::move(proxy), - std::move(colorSpaceXform), - matrix, domain)); + static std::unique_ptr Make(sk_sp proxy, + sk_sp colorSpaceXform, + const SkMatrix& matrix, + const SkRect& domain) { + return std::unique_ptr( + 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 8c0ff64d27..1b5ea600f9 100644 --- a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp +++ b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp @@ -55,7 +55,7 @@ GrBlurredEdgeFragmentProcessor::GrBlurredEdgeFragmentProcessor( : INHERITED(src.optimizationFlags()), fMode(src.fMode) { this->initClassID(); } -sk_sp GrBlurredEdgeFragmentProcessor::clone() const { - return sk_sp(new GrBlurredEdgeFragmentProcessor(*this)); +std::unique_ptr GrBlurredEdgeFragmentProcessor::clone() const { + return std::unique_ptr(new GrBlurredEdgeFragmentProcessor(*this)); } #endif diff --git a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.h b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.h index 677c285114..61cc53baa5 100644 --- a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.h +++ b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.h @@ -19,11 +19,11 @@ class GrBlurredEdgeFragmentProcessor : public GrFragmentProcessor { public: enum Mode { kGaussian_Mode = 0, kSmoothStep_Mode = 1 }; int mode() const { return fMode; } - static sk_sp Make(int mode) { - return sk_sp(new GrBlurredEdgeFragmentProcessor(mode)); + static std::unique_ptr Make(int mode) { + return std::unique_ptr(new GrBlurredEdgeFragmentProcessor(mode)); } GrBlurredEdgeFragmentProcessor(const GrBlurredEdgeFragmentProcessor& src); - sk_sp clone() const override; + std::unique_ptr 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 6fc47558c9..b764559ed4 100644 --- a/src/gpu/effects/GrCircleEffect.cpp +++ b/src/gpu/effects/GrCircleEffect.cpp @@ -95,12 +95,12 @@ GrCircleEffect::GrCircleEffect(const GrCircleEffect& src) , fRadius(src.fRadius) { this->initClassID(); } -sk_sp GrCircleEffect::clone() const { - return sk_sp(new GrCircleEffect(*this)); +std::unique_ptr GrCircleEffect::clone() const { + return std::unique_ptr(new GrCircleEffect(*this)); } GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrCircleEffect); #if GR_TEST_UTILS -sk_sp GrCircleEffect::TestCreate(GrProcessorTestData* testData) { +std::unique_ptr 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 46e46f9575..0d88dcb099 100644 --- a/src/gpu/effects/GrCircleEffect.h +++ b/src/gpu/effects/GrCircleEffect.h @@ -20,11 +20,11 @@ public: int edgeType() const { return fEdgeType; } SkPoint center() const { return fCenter; } float radius() const { return fRadius; } - static sk_sp Make(int edgeType, SkPoint center, float radius) { - return sk_sp(new GrCircleEffect(edgeType, center, radius)); + static std::unique_ptr Make(int edgeType, SkPoint center, float radius) { + return std::unique_ptr(new GrCircleEffect(edgeType, center, radius)); } GrCircleEffect(const GrCircleEffect& src); - sk_sp clone() const override; + std::unique_ptr 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 880648199e..e784ed78fc 100644 --- a/src/gpu/effects/GrConfigConversionEffect.cpp +++ b/src/gpu/effects/GrConfigConversionEffect.cpp @@ -70,8 +70,8 @@ GrConfigConversionEffect::GrConfigConversionEffect(PMConversion pmConversion) this->initClassID(); } -sk_sp GrConfigConversionEffect::clone() const { - return sk_sp(new GrConfigConversionEffect(fPMConversion)); +std::unique_ptr GrConfigConversionEffect::clone() const { + return std::unique_ptr(new GrConfigConversionEffect(fPMConversion)); } bool GrConfigConversionEffect::onIsEqual(const GrFragmentProcessor& s) const { @@ -84,9 +84,9 @@ bool GrConfigConversionEffect::onIsEqual(const GrFragmentProcessor& s) const { GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConfigConversionEffect); #if GR_TEST_UTILS -sk_sp GrConfigConversionEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr GrConfigConversionEffect::TestCreate(GrProcessorTestData* d) { PMConversion pmConv = static_cast(d->fRandom->nextULessThan(kPMConversionCnt)); - return sk_sp(new GrConfigConversionEffect(pmConv)); + return std::unique_ptr(new GrConfigConversionEffect(pmConv)); } #endif @@ -158,11 +158,13 @@ bool GrConfigConversionEffect::TestForPreservingPMConversions(GrContext* context GrPaint paint1; GrPaint paint2; GrPaint paint3; - sk_sp pmToUPM(new GrConfigConversionEffect(kToUnpremul_PMConversion)); - sk_sp upmToPM(new GrConfigConversionEffect(kToPremul_PMConversion)); + std::unique_ptr pmToUPM( + new GrConfigConversionEffect(kToUnpremul_PMConversion)); + std::unique_ptr 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 @@ bool GrConfigConversionEffect::TestForPreservingPMConversions(GrContext* context return true; } -sk_sp GrConfigConversionEffect::Make(sk_sp fp, - PMConversion pmConversion) { +std::unique_ptr GrConfigConversionEffect::Make( + std::unique_ptr fp, PMConversion pmConversion) { if (!fp) { return nullptr; } - sk_sp ccFP(new GrConfigConversionEffect(pmConversion)); - sk_sp fpPipeline[] = { fp, ccFP }; + std::unique_ptr ccFP(new GrConfigConversionEffect(pmConversion)); + std::unique_ptr 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 fe8f50bdf5..690fbd5ff7 100644 --- a/src/gpu/effects/GrConfigConversionEffect.h +++ b/src/gpu/effects/GrConfigConversionEffect.h @@ -29,11 +29,12 @@ public: * Returns a fragment processor that calls the passed in fragment processor, and then performs * the requested premul or unpremul conversion. */ - static sk_sp Make(sk_sp, PMConversion); + static std::unique_ptr Make(std::unique_ptr, + PMConversion); const char* name() const override { return "Config Conversion"; } - sk_sp clone() const override; + std::unique_ptr clone() const override; PMConversion pmConversion() const { return fPMConversion; } diff --git a/src/gpu/effects/GrConstColorProcessor.cpp b/src/gpu/effects/GrConstColorProcessor.cpp index d5f4e3527f..08592244ca 100644 --- a/src/gpu/effects/GrConstColorProcessor.cpp +++ b/src/gpu/effects/GrConstColorProcessor.cpp @@ -62,7 +62,9 @@ private: /////////////////////////////////////////////////////////////////////////////// -sk_sp GrConstColorProcessor::clone() const { return Make(fColor, fMode); } +std::unique_ptr GrConstColorProcessor::clone() const { + return Make(fColor, fMode); +} GrColor4f GrConstColorProcessor::constantOutputForConstantInput(GrColor4f input) const { switch (fMode) { @@ -96,7 +98,7 @@ bool GrConstColorProcessor::onIsEqual(const GrFragmentProcessor& other) const { GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConstColorProcessor); #if GR_TEST_UTILS -sk_sp GrConstColorProcessor::TestCreate(GrProcessorTestData* d) { +std::unique_ptr 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 baf405a8fe..7079a8dffb 100644 --- a/src/gpu/effects/GrConstColorProcessor.h +++ b/src/gpu/effects/GrConstColorProcessor.h @@ -26,8 +26,8 @@ public: }; static const int kInputModeCnt = kLastInputMode + 1; - static sk_sp Make(GrColor4f color, InputMode mode) { - return sk_sp(new GrConstColorProcessor(color, mode)); + static std::unique_ptr Make(GrColor4f color, InputMode mode) { + return std::unique_ptr(new GrConstColorProcessor(color, mode)); } const char* name() const override { return "Color"; } @@ -38,7 +38,7 @@ public: return str; } - sk_sp clone() const override; + std::unique_ptr clone() const override; GrColor4f color() const { return fColor; } diff --git a/src/gpu/effects/GrConvexPolyEffect.cpp b/src/gpu/effects/GrConvexPolyEffect.cpp index bb61cc1f20..e61923c29e 100644 --- a/src/gpu/effects/GrConvexPolyEffect.cpp +++ b/src/gpu/effects/GrConvexPolyEffect.cpp @@ -19,15 +19,16 @@ class AARectEffect : public GrFragmentProcessor { public: const SkRect& getRect() const { return fRect; } - static sk_sp Make(GrPrimitiveEdgeType edgeType, const SkRect& rect) { - return sk_sp(new AARectEffect(edgeType, rect)); + static std::unique_ptr Make(GrPrimitiveEdgeType edgeType, + const SkRect& rect) { + return std::unique_ptr(new AARectEffect(edgeType, rect)); } GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } const char* name() const override { return "AARect"; } - sk_sp clone() const override { return Make(fEdgeType, fRect); } + std::unique_ptr clone() const override { return Make(fEdgeType, fRect); } private: void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override; @@ -58,12 +59,12 @@ private: GR_DEFINE_FRAGMENT_PROCESSOR_TEST(AARectEffect); #if GR_TEST_UTILS -sk_sp AARectEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr AARectEffect::TestCreate(GrProcessorTestData* d) { SkRect rect = SkRect::MakeLTRB(d->fRandom->nextSScalar1(), d->fRandom->nextSScalar1(), d->fRandom->nextSScalar1(), d->fRandom->nextSScalar1()); - sk_sp fp; + std::unique_ptr fp; do { GrPrimitiveEdgeType edgeType = static_cast( d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt)); @@ -236,7 +237,8 @@ void GrGLConvexPolyEffect::GenKey(const GrProcessor& processor, const GrShaderCa ////////////////////////////////////////////////////////////////////////////// -sk_sp GrConvexPolyEffect::Make(GrPrimitiveEdgeType type, const SkPath& path) { +std::unique_ptr GrConvexPolyEffect::Make(GrPrimitiveEdgeType type, + const SkPath& path) { if (kHairlineAA_GrProcessorEdgeType == type) { return nullptr; } @@ -306,8 +308,8 @@ sk_sp GrConvexPolyEffect::Make(GrPrimitiveEdgeType type, co return Make(type, n, edges); } -sk_sp GrConvexPolyEffect::Make(GrPrimitiveEdgeType edgeType, - const SkRect& rect) { +std::unique_ptr GrConvexPolyEffect::Make(GrPrimitiveEdgeType edgeType, + const SkRect& rect) { if (kHairlineAA_GrProcessorEdgeType == edgeType){ return nullptr; } @@ -348,8 +350,8 @@ GrConvexPolyEffect::GrConvexPolyEffect(const GrConvexPolyEffect& that) memcpy(fEdges, that.fEdges, 3 * that.fEdgeCount * sizeof(SkScalar)); } -sk_sp GrConvexPolyEffect::clone() const { - return sk_sp(new GrConvexPolyEffect(*this)); +std::unique_ptr GrConvexPolyEffect::clone() const { + return std::unique_ptr(new GrConvexPolyEffect(*this)); } bool GrConvexPolyEffect::onIsEqual(const GrFragmentProcessor& other) const { @@ -364,14 +366,14 @@ bool GrConvexPolyEffect::onIsEqual(const GrFragmentProcessor& other) const { GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConvexPolyEffect); #if GR_TEST_UTILS -sk_sp GrConvexPolyEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr 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 fp; + std::unique_ptr fp; do { GrPrimitiveEdgeType edgeType = static_cast( d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt)); diff --git a/src/gpu/effects/GrConvexPolyEffect.h b/src/gpu/effects/GrConvexPolyEffect.h index f1f6ab0029..abb718e97f 100644 --- a/src/gpu/effects/GrConvexPolyEffect.h +++ b/src/gpu/effects/GrConvexPolyEffect.h @@ -38,30 +38,30 @@ public: * 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 Make(GrPrimitiveEdgeType edgeType, int n, - const SkScalar edges[]) { + static std::unique_ptr Make(GrPrimitiveEdgeType edgeType, int n, + const SkScalar edges[]) { if (n <= 0 || n > kMaxEdges || kHairlineAA_GrProcessorEdgeType == edgeType) { return nullptr; } - return sk_sp(new GrConvexPolyEffect(edgeType, n, edges)); + return std::unique_ptr(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 Make(GrPrimitiveEdgeType, const SkPath&); + static std::unique_ptr Make(GrPrimitiveEdgeType, const SkPath&); /** * Creates an effect that fills inside the rect with AA edges.. */ - static sk_sp Make(GrPrimitiveEdgeType, const SkRect&); + static std::unique_ptr Make(GrPrimitiveEdgeType, const SkRect&); ~GrConvexPolyEffect() override; const char* name() const override { return "ConvexPoly"; } - sk_sp clone() const override; + std::unique_ptr clone() const override; GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } diff --git a/src/gpu/effects/GrDitherEffect.cpp b/src/gpu/effects/GrDitherEffect.cpp index f2fc6784a2..d78af4ee5a 100644 --- a/src/gpu/effects/GrDitherEffect.cpp +++ b/src/gpu/effects/GrDitherEffect.cpp @@ -62,14 +62,14 @@ GrDitherEffect::GrDitherEffect(const GrDitherEffect& src) : INHERITED(src.optimizationFlags()), fRangeType(src.fRangeType) { this->initClassID(); } -sk_sp GrDitherEffect::clone() const { - return sk_sp(new GrDitherEffect(*this)); +std::unique_ptr GrDitherEffect::clone() const { + return std::unique_ptr(new GrDitherEffect(*this)); } GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDitherEffect); #if GR_TEST_UTILS -sk_sp GrDitherEffect::TestCreate(GrProcessorTestData* testData) { +std::unique_ptr GrDitherEffect::TestCreate(GrProcessorTestData* testData) { float range = testData->fRandom->nextRangeF(0.001f, 0.05f); - return sk_sp(new GrDitherEffect(range)); + return std::unique_ptr(new GrDitherEffect(range)); } #endif #endif diff --git a/src/gpu/effects/GrDitherEffect.fp b/src/gpu/effects/GrDitherEffect.fp index 7ec852e6b0..fe641c6132 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 Make(GrPixelConfig dstConfig) { + static std::unique_ptr Make(GrPixelConfig dstConfig) { int rangeType; switch (dstConfig) { case kGray_8_GrPixelConfig: @@ -27,7 +27,7 @@ layout(key) in int rangeType; case kAlpha_8_GrPixelConfig: return nullptr; } - return sk_sp(new GrDitherEffect(rangeType)); + return std::unique_ptr(new GrDitherEffect(rangeType)); } } @@ -68,5 +68,5 @@ void main() { @test(testData) { float range = testData->fRandom->nextRangeF(0.001f, 0.05f); - return sk_sp(new GrDitherEffect(range)); + return std::unique_ptr(new GrDitherEffect(range)); } diff --git a/src/gpu/effects/GrDitherEffect.h b/src/gpu/effects/GrDitherEffect.h index 529b5ec457..d428c3ced1 100644 --- a/src/gpu/effects/GrDitherEffect.h +++ b/src/gpu/effects/GrDitherEffect.h @@ -19,7 +19,7 @@ class GrDitherEffect : public GrFragmentProcessor { public: int rangeType() const { return fRangeType; } - static sk_sp Make(GrPixelConfig dstConfig) { + static std::unique_ptr Make(GrPixelConfig dstConfig) { int rangeType; switch (dstConfig) { case kGray_8_GrPixelConfig: @@ -44,10 +44,10 @@ public: case kAlpha_8_GrPixelConfig: return nullptr; } - return sk_sp(new GrDitherEffect(rangeType)); + return std::unique_ptr(new GrDitherEffect(rangeType)); } GrDitherEffect(const GrDitherEffect& src); - sk_sp clone() const override; + std::unique_ptr 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 edf12d27dd..e9443a8d00 100644 --- a/src/gpu/effects/GrEllipseEffect.cpp +++ b/src/gpu/effects/GrEllipseEffect.cpp @@ -120,12 +120,12 @@ GrEllipseEffect::GrEllipseEffect(const GrEllipseEffect& src) , fRadii(src.fRadii) { this->initClassID(); } -sk_sp GrEllipseEffect::clone() const { - return sk_sp(new GrEllipseEffect(*this)); +std::unique_ptr GrEllipseEffect::clone() const { + return std::unique_ptr(new GrEllipseEffect(*this)); } GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrEllipseEffect); #if GR_TEST_UTILS -sk_sp GrEllipseEffect::TestCreate(GrProcessorTestData* testData) { +std::unique_ptr 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 28586561da..1425f39945 100644 --- a/src/gpu/effects/GrEllipseEffect.h +++ b/src/gpu/effects/GrEllipseEffect.h @@ -20,11 +20,11 @@ public: int edgeType() const { return fEdgeType; } SkPoint center() const { return fCenter; } SkPoint radii() const { return fRadii; } - static sk_sp Make(int edgeType, SkPoint center, SkPoint radii) { - return sk_sp(new GrEllipseEffect(edgeType, center, radii)); + static std::unique_ptr Make(int edgeType, SkPoint center, SkPoint radii) { + return std::unique_ptr(new GrEllipseEffect(edgeType, center, radii)); } GrEllipseEffect(const GrEllipseEffect& src); - sk_sp clone() const override; + std::unique_ptr 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 ac22a8c0ef..b54ca53f4e 100644 --- a/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp +++ b/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp @@ -255,7 +255,7 @@ bool GrGaussianConvolutionFragmentProcessor::onIsEqual(const GrFragmentProcessor GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrGaussianConvolutionFragmentProcessor); #if GR_TEST_UTILS -sk_sp GrGaussianConvolutionFragmentProcessor::TestCreate( +std::unique_ptr 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 74e9a94c2d..9850e605fb 100644 --- a/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.h +++ b/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.h @@ -22,14 +22,14 @@ public: enum class Direction { kX, kY }; /// Convolve with a Gaussian kernel - static sk_sp Make(sk_sp proxy, - Direction dir, - int halfWidth, - float gaussianSigma, - GrTextureDomain::Mode mode, - int* bounds) { - return sk_sp(new GrGaussianConvolutionFragmentProcessor( - std::move(proxy), dir, halfWidth, gaussianSigma, mode, bounds)); + static std::unique_ptr Make(sk_sp proxy, + Direction dir, + int halfWidth, + float gaussianSigma, + GrTextureDomain::Mode mode, + int* bounds) { + return std::unique_ptr(new GrGaussianConvolutionFragmentProcessor( + std::move(proxy), dir, halfWidth, gaussianSigma, mode, bounds)); } const float* kernel() const { return fKernel; } @@ -44,8 +44,9 @@ public: const char* name() const override { return "GaussianConvolution"; } - sk_sp clone() const override { - return sk_sp(new GrGaussianConvolutionFragmentProcessor(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr( + 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 030a926845..9d9a03ed4b 100644 --- a/src/gpu/effects/GrMatrixConvolutionEffect.cpp +++ b/src/gpu/effects/GrMatrixConvolutionEffect.cpp @@ -194,8 +194,8 @@ GrMatrixConvolutionEffect::GrMatrixConvolutionEffect(const GrMatrixConvolutionEf memcpy(fKernelOffset, that.fKernelOffset, sizeof(fKernelOffset)); } -sk_sp GrMatrixConvolutionEffect::clone() const { - return sk_sp(new GrMatrixConvolutionEffect(*this)); +std::unique_ptr GrMatrixConvolutionEffect::clone() const { + return std::unique_ptr(new GrMatrixConvolutionEffect(*this)); } void GrMatrixConvolutionEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps, @@ -248,30 +248,30 @@ static void fill_in_2D_gaussian_kernel(float* kernel, int width, int height, } // Static function to create a 2D convolution -sk_sp GrMatrixConvolutionEffect::MakeGaussian( - sk_sp 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 GrMatrixConvolutionEffect::MakeGaussian( + sk_sp 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( - new GrMatrixConvolutionEffect(std::move(proxy), bounds, kernelSize, - kernel, gain, bias, kernelOffset, tileMode, convolveAlpha)); + return std::unique_ptr( + 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 GrMatrixConvolutionEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr GrMatrixConvolutionEffect::TestCreate(GrProcessorTestData* d) { int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx : GrProcessorUnitTest::kAlphaTextureIdx; sk_sp proxy = d->textureProxy(texIdx); diff --git a/src/gpu/effects/GrMatrixConvolutionEffect.h b/src/gpu/effects/GrMatrixConvolutionEffect.h index 9ece00ee5d..2e859b1cdd 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 Make(sk_sp 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( - new GrMatrixConvolutionEffect(std::move(proxy), bounds, kernelSize, - kernel, gain, bias, kernelOffset, tileMode, convolveAlpha)); + static std::unique_ptr Make(sk_sp 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( + new GrMatrixConvolutionEffect(std::move(proxy), bounds, kernelSize, kernel, gain, + bias, kernelOffset, tileMode, convolveAlpha)); } - static sk_sp MakeGaussian(sk_sp 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 MakeGaussian(sk_sp 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 @@ public: const char* name() const override { return "MatrixConvolution"; } - sk_sp clone() const override; + std::unique_ptr clone() const override; private: GrMatrixConvolutionEffect(sk_sp proxy, diff --git a/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp b/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp index 6ae770b820..b30746acb7 100644 --- a/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp +++ b/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp @@ -173,8 +173,8 @@ GrNonlinearColorSpaceXformEffect::GrNonlinearColorSpaceXformEffect( memcpy(fDstTransferFnCoeffs, that.fDstTransferFnCoeffs, sizeof(fDstTransferFnCoeffs)); } -sk_sp GrNonlinearColorSpaceXformEffect::clone() const { - return sk_sp(new GrNonlinearColorSpaceXformEffect(*this)); +std::unique_ptr GrNonlinearColorSpaceXformEffect::clone() const { + return std::unique_ptr(new GrNonlinearColorSpaceXformEffect(*this)); } bool GrNonlinearColorSpaceXformEffect::onIsEqual(const GrFragmentProcessor& s) const { @@ -201,7 +201,8 @@ bool GrNonlinearColorSpaceXformEffect::onIsEqual(const GrFragmentProcessor& s) c GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrNonlinearColorSpaceXformEffect); #if GR_TEST_UTILS -sk_sp GrNonlinearColorSpaceXformEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr GrNonlinearColorSpaceXformEffect::TestCreate( + GrProcessorTestData* d) { // TODO: Generate a random variety of color spaces for this effect (it can handle wacky // transfer functions, etc...) sk_sp srcSpace = SkColorSpace::MakeSRGBLinear(); @@ -221,8 +222,8 @@ GrGLSLFragmentProcessor* GrNonlinearColorSpaceXformEffect::onCreateGLSLInstance( return new GrGLNonlinearColorSpaceXformEffect(); } -sk_sp GrNonlinearColorSpaceXformEffect::Make(const SkColorSpace* src, - const SkColorSpace* dst) { +std::unique_ptr 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 @@ sk_sp GrNonlinearColorSpaceXformEffect::Make(const SkColorS } } - return sk_sp(new GrNonlinearColorSpaceXformEffect( - ops, srcTransferFn, dstTransferFn, srcToDstMtx)); + return std::unique_ptr( + new GrNonlinearColorSpaceXformEffect(ops, srcTransferFn, dstTransferFn, srcToDstMtx)); } diff --git a/src/gpu/effects/GrNonlinearColorSpaceXformEffect.h b/src/gpu/effects/GrNonlinearColorSpaceXformEffect.h index f57c64b93b..109ec10d89 100644 --- a/src/gpu/effects/GrNonlinearColorSpaceXformEffect.h +++ b/src/gpu/effects/GrNonlinearColorSpaceXformEffect.h @@ -27,11 +27,12 @@ public: * 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 Make(const SkColorSpace* src, const SkColorSpace* dst); + static std::unique_ptr Make(const SkColorSpace* src, + const SkColorSpace* dst); const char* name() const override { return "NonlinearColorSpaceXform"; } - sk_sp clone() const override; + std::unique_ptr clone() const override; static const int kNumTransferFnCoeffs = 7; diff --git a/src/gpu/effects/GrOvalEffect.cpp b/src/gpu/effects/GrOvalEffect.cpp index 3180533146..efc86a4c08 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 GrOvalEffect::Make(GrPrimitiveEdgeType edgeType, const SkRect& oval) { +std::unique_ptr 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 3ff241a65d..1372f237a7 100644 --- a/src/gpu/effects/GrOvalEffect.h +++ b/src/gpu/effects/GrOvalEffect.h @@ -16,10 +16,12 @@ class GrFragmentProcessor; struct SkRect; namespace GrOvalEffect { - /** - * Creates an effect that performs clipping against an oval. - */ - sk_sp Make(GrPrimitiveEdgeType, const SkRect&); + +/** + * Creates an effect that performs clipping against an oval. + */ +std::unique_ptr Make(GrPrimitiveEdgeType, const SkRect&); + }; #endif diff --git a/src/gpu/effects/GrRRectEffect.cpp b/src/gpu/effects/GrRRectEffect.cpp index 8dde914bb4..f253dfef86 100644 --- a/src/gpu/effects/GrRRectEffect.cpp +++ b/src/gpu/effects/GrRRectEffect.cpp @@ -45,14 +45,14 @@ public: // The flags are used to indicate which corners are circluar (unflagged corners are assumed to // be square). - static sk_sp Make(GrPrimitiveEdgeType, uint32_t circularCornerFlags, - const SkRRect&); + static std::unique_ptr Make(GrPrimitiveEdgeType, + uint32_t circularCornerFlags, const SkRRect&); ~CircularRRectEffect() override {} const char* name() const override { return "CircularRRect"; } - sk_sp clone() const override; + std::unique_ptr clone() const override; const SkRRect& getRRect() const { return fRRect; } @@ -78,14 +78,14 @@ private: typedef GrFragmentProcessor INHERITED; }; -sk_sp CircularRRectEffect::Make(GrPrimitiveEdgeType edgeType, - uint32_t circularCornerFlags, - const SkRRect& rrect) { +std::unique_ptr CircularRRectEffect::Make(GrPrimitiveEdgeType edgeType, + uint32_t circularCornerFlags, + const SkRRect& rrect) { if (kFillAA_GrProcessorEdgeType != edgeType && kInverseFillAA_GrProcessorEdgeType != edgeType) { return nullptr; } - return sk_sp( - new CircularRRectEffect(edgeType, circularCornerFlags, rrect)); + return std::unique_ptr( + new CircularRRectEffect(edgeType, circularCornerFlags, rrect)); } CircularRRectEffect::CircularRRectEffect(GrPrimitiveEdgeType edgeType, uint32_t circularCornerFlags, @@ -97,8 +97,8 @@ CircularRRectEffect::CircularRRectEffect(GrPrimitiveEdgeType edgeType, uint32_t this->initClassID(); } -sk_sp CircularRRectEffect::clone() const { - return sk_sp( +std::unique_ptr CircularRRectEffect::clone() const { + return std::unique_ptr( new CircularRRectEffect(fEdgeType, fCircularCornerFlags, fRRect)); } @@ -113,13 +113,13 @@ bool CircularRRectEffect::onIsEqual(const GrFragmentProcessor& other) const { GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircularRRectEffect); #if GR_TEST_UTILS -sk_sp CircularRRectEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr 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 fp; + std::unique_ptr fp; do { GrPrimitiveEdgeType et = (GrPrimitiveEdgeType)d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt); @@ -391,13 +391,13 @@ GrGLSLFragmentProcessor* CircularRRectEffect::onCreateGLSLInstance() const { class EllipticalRRectEffect : public GrFragmentProcessor { public: - static sk_sp Make(GrPrimitiveEdgeType, const SkRRect&); + static std::unique_ptr Make(GrPrimitiveEdgeType, const SkRRect&); ~EllipticalRRectEffect() override {} const char* name() const override { return "EllipticalRRect"; } - sk_sp clone() const override; + std::unique_ptr clone() const override; const SkRRect& getRRect() const { return fRRect; } @@ -420,12 +420,12 @@ private: typedef GrFragmentProcessor INHERITED; }; -sk_sp -EllipticalRRectEffect::Make(GrPrimitiveEdgeType edgeType, const SkRRect& rrect) { +std::unique_ptr EllipticalRRectEffect::Make(GrPrimitiveEdgeType edgeType, + const SkRRect& rrect) { if (kFillAA_GrProcessorEdgeType != edgeType && kInverseFillAA_GrProcessorEdgeType != edgeType) { return nullptr; } - return sk_sp(new EllipticalRRectEffect(edgeType, rrect)); + return std::unique_ptr(new EllipticalRRectEffect(edgeType, rrect)); } EllipticalRRectEffect::EllipticalRRectEffect(GrPrimitiveEdgeType edgeType, const SkRRect& rrect) @@ -435,8 +435,8 @@ EllipticalRRectEffect::EllipticalRRectEffect(GrPrimitiveEdgeType edgeType, const this->initClassID(); } -sk_sp EllipticalRRectEffect::clone() const { - return sk_sp(new EllipticalRRectEffect(fEdgeType, fRRect)); +std::unique_ptr EllipticalRRectEffect::clone() const { + return std::unique_ptr(new EllipticalRRectEffect(fEdgeType, fRRect)); } bool EllipticalRRectEffect::onIsEqual(const GrFragmentProcessor& other) const { @@ -449,7 +449,7 @@ bool EllipticalRRectEffect::onIsEqual(const GrFragmentProcessor& other) const { GR_DEFINE_FRAGMENT_PROCESSOR_TEST(EllipticalRRectEffect); #if GR_TEST_UTILS -sk_sp EllipticalRRectEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr 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 @@ sk_sp EllipticalRRectEffect::TestCreate(GrProcessorTestData rrect.setRectXY(SkRect::MakeWH(w, h), r[SkRRect::kUpperLeft_Corner].fX, r[SkRRect::kUpperLeft_Corner].fY); } - sk_sp fp; + std::unique_ptr fp; do { GrPrimitiveEdgeType et = (GrPrimitiveEdgeType)d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt); @@ -684,7 +684,8 @@ GrGLSLFragmentProcessor* EllipticalRRectEffect::onCreateGLSLInstance() const { ////////////////////////////////////////////////////////////////////////////// -sk_sp GrRRectEffect::Make(GrPrimitiveEdgeType edgeType, const SkRRect& rrect) { +std::unique_ptr 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 6ff2cc9735..fcd600ac4f 100644 --- a/src/gpu/effects/GrRRectEffect.h +++ b/src/gpu/effects/GrRRectEffect.h @@ -17,11 +17,13 @@ class GrProcessor; 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 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 Make(GrPrimitiveEdgeType, const SkRRect&); + }; #endif diff --git a/src/gpu/effects/GrSRGBEffect.cpp b/src/gpu/effects/GrSRGBEffect.cpp index 1cffb9eef0..f415a6cef1 100644 --- a/src/gpu/effects/GrSRGBEffect.cpp +++ b/src/gpu/effects/GrSRGBEffect.cpp @@ -85,7 +85,7 @@ GrSRGBEffect::GrSRGBEffect(Mode mode, Alpha alpha) this->initClassID(); } -sk_sp GrSRGBEffect::clone() const { return Make(fMode, fAlpha); } +std::unique_ptr GrSRGBEffect::clone() const { return Make(fMode, fAlpha); } bool GrSRGBEffect::onIsEqual(const GrFragmentProcessor& s) const { const GrSRGBEffect& other = s.cast(); @@ -119,7 +119,7 @@ GrColor4f GrSRGBEffect::constantOutputForConstantInput(GrColor4f color) const { GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSRGBEffect); #if GR_TEST_UTILS -sk_sp GrSRGBEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr GrSRGBEffect::TestCreate(GrProcessorTestData* d) { Mode testMode = static_cast(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 ef6fd28800..9b51fca7c6 100644 --- a/src/gpu/effects/GrSRGBEffect.h +++ b/src/gpu/effects/GrSRGBEffect.h @@ -25,8 +25,8 @@ public: /** * Creates an effect that applies the sRGB transfer function (or its inverse) */ - static sk_sp Make(Mode mode, Alpha alpha) { - return sk_sp(new GrSRGBEffect(mode, alpha)); + static std::unique_ptr Make(Mode mode, Alpha alpha) { + return std::unique_ptr(new GrSRGBEffect(mode, alpha)); } const char* name() const override { return "sRGB"; } @@ -34,7 +34,7 @@ public: Mode mode() const { return fMode; } Alpha alpha() const { return fAlpha; } - sk_sp clone() const override; + std::unique_ptr clone() const override; private: GrSRGBEffect(Mode mode, Alpha); diff --git a/src/gpu/effects/GrSimpleTextureEffect.cpp b/src/gpu/effects/GrSimpleTextureEffect.cpp index bd2b80529a..9a0017c8d1 100644 --- a/src/gpu/effects/GrSimpleTextureEffect.cpp +++ b/src/gpu/effects/GrSimpleTextureEffect.cpp @@ -80,12 +80,13 @@ GrSimpleTextureEffect::GrSimpleTextureEffect(const GrSimpleTextureEffect& src) this->addTextureSampler(&fImage); this->addCoordTransform(&fImageCoordTransform); } -sk_sp GrSimpleTextureEffect::clone() const { - return sk_sp(new GrSimpleTextureEffect(*this)); +std::unique_ptr GrSimpleTextureEffect::clone() const { + return std::unique_ptr(new GrSimpleTextureEffect(*this)); } GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSimpleTextureEffect); #if GR_TEST_UTILS -sk_sp GrSimpleTextureEffect::TestCreate(GrProcessorTestData* testData) { +std::unique_ptr 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 6f7c818672..80824fe076 100644 --- a/src/gpu/effects/GrSimpleTextureEffect.fp +++ b/src/gpu/effects/GrSimpleTextureEffect.fp @@ -22,29 +22,29 @@ in float4x4 matrix; } @make { - static sk_sp Make(sk_sp proxy, - sk_sp colorSpaceXform, - const SkMatrix& matrix) { - return sk_sp( + static std::unique_ptr Make(sk_sp proxy, + sk_sp colorSpaceXform, + const SkMatrix& matrix) { + return std::unique_ptr( new GrSimpleTextureEffect(std::move(proxy), std::move(colorSpaceXform), matrix, GrSamplerParams(SkShader::kClamp_TileMode, GrSamplerParams::kNone_FilterMode))); } /* clamp mode */ - static sk_sp Make(sk_sp proxy, - sk_sp colorSpaceXform, - const SkMatrix& matrix, - GrSamplerParams::FilterMode filterMode) { - return sk_sp( + static std::unique_ptr Make(sk_sp proxy, + sk_sp colorSpaceXform, + const SkMatrix& matrix, + GrSamplerParams::FilterMode filterMode) { + return std::unique_ptr( new GrSimpleTextureEffect(std::move(proxy), std::move(colorSpaceXform), matrix, GrSamplerParams(SkShader::kClamp_TileMode, filterMode))); } - static sk_sp Make(sk_sp proxy, - sk_sp colorSpaceXform, - const SkMatrix& matrix, - const GrSamplerParams& p) { - return sk_sp( + static std::unique_ptr Make(sk_sp proxy, + sk_sp colorSpaceXform, + const SkMatrix& matrix, + const GrSamplerParams& p) { + return std::unique_ptr( 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 25ef1c5bd0..11564bb6e2 100644 --- a/src/gpu/effects/GrSimpleTextureEffect.h +++ b/src/gpu/effects/GrSimpleTextureEffect.h @@ -20,35 +20,35 @@ public: sk_sp colorXform() const { return fColorXform; } SkMatrix44 matrix() const { return fMatrix; } - static sk_sp Make(sk_sp proxy, - sk_sp - colorSpaceXform, - const SkMatrix& matrix) { - return sk_sp(new GrSimpleTextureEffect( + static std::unique_ptr Make(sk_sp proxy, + sk_sp + colorSpaceXform, + const SkMatrix& matrix) { + return std::unique_ptr(new GrSimpleTextureEffect( std::move(proxy), std::move(colorSpaceXform), matrix, GrSamplerParams(SkShader::kClamp_TileMode, GrSamplerParams::kNone_FilterMode))); } - static sk_sp Make(sk_sp proxy, - sk_sp - colorSpaceXform, - const SkMatrix& matrix, - GrSamplerParams::FilterMode filterMode) { - return sk_sp( + static std::unique_ptr Make(sk_sp proxy, + sk_sp + colorSpaceXform, + const SkMatrix& matrix, + GrSamplerParams::FilterMode filterMode) { + return std::unique_ptr( new GrSimpleTextureEffect(std::move(proxy), std::move(colorSpaceXform), matrix, GrSamplerParams(SkShader::kClamp_TileMode, filterMode))); } - static sk_sp Make(sk_sp proxy, - sk_sp - colorSpaceXform, - const SkMatrix& matrix, - const GrSamplerParams& p) { - return sk_sp( + static std::unique_ptr Make(sk_sp proxy, + sk_sp + colorSpaceXform, + const SkMatrix& matrix, + const GrSamplerParams& p) { + return std::unique_ptr( new GrSimpleTextureEffect(std::move(proxy), std::move(colorSpaceXform), matrix, p)); } GrSimpleTextureEffect(const GrSimpleTextureEffect& src); - sk_sp clone() const override; + std::unique_ptr 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 ee7985c14e..5101762bd9 100644 --- a/src/gpu/effects/GrTextureDomain.cpp +++ b/src/gpu/effects/GrTextureDomain.cpp @@ -206,21 +206,20 @@ inline GrFragmentProcessor::OptimizationFlags GrTextureDomainEffect::OptFlags( } } -sk_sp GrTextureDomainEffect::Make(sk_sp proxy, - sk_sp colorSpaceXform, - const SkMatrix& matrix, - const SkRect& domain, - GrTextureDomain::Mode mode, - GrSamplerParams::FilterMode filterMode) { +std::unique_ptr GrTextureDomainEffect::Make( + sk_sp proxy, + sk_sp 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( - new GrTextureDomainEffect(std::move(proxy), - std::move(colorSpaceXform), - matrix, domain, mode, filterMode)); + return std::unique_ptr(new GrTextureDomainEffect( + std::move(proxy), std::move(colorSpaceXform), matrix, domain, mode, filterMode)); } } @@ -312,7 +311,7 @@ bool GrTextureDomainEffect::onIsEqual(const GrFragmentProcessor& sBase) const { GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrTextureDomainEffect); #if GR_TEST_UTILS -sk_sp GrTextureDomainEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr GrTextureDomainEffect::TestCreate(GrProcessorTestData* d) { int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx : GrProcessorUnitTest::kAlphaTextureIdx; sk_sp proxy = d->textureProxy(texIdx); @@ -337,11 +336,9 @@ sk_sp GrTextureDomainEffect::TestCreate(GrProcessorTestData #endif /////////////////////////////////////////////////////////////////////////////// -sk_sp GrDeviceSpaceTextureDecalFragmentProcessor::Make( - sk_sp proxy, - const SkIRect& subset, - const SkIPoint& deviceSpaceOffset) { - return sk_sp(new GrDeviceSpaceTextureDecalFragmentProcessor( +std::unique_ptr GrDeviceSpaceTextureDecalFragmentProcessor::Make( + sk_sp proxy, const SkIRect& subset, const SkIPoint& deviceSpaceOffset) { + return std::unique_ptr(new GrDeviceSpaceTextureDecalFragmentProcessor( std::move(proxy), subset, deviceSpaceOffset)); } @@ -369,8 +366,9 @@ GrDeviceSpaceTextureDecalFragmentProcessor::GrDeviceSpaceTextureDecalFragmentPro this->addTextureSampler(&fTextureSampler); } -sk_sp GrDeviceSpaceTextureDecalFragmentProcessor::clone() const { - return sk_sp(new GrDeviceSpaceTextureDecalFragmentProcessor(*this)); +std::unique_ptr GrDeviceSpaceTextureDecalFragmentProcessor::clone() const { + return std::unique_ptr( + new GrDeviceSpaceTextureDecalFragmentProcessor(*this)); } GrGLSLFragmentProcessor* GrDeviceSpaceTextureDecalFragmentProcessor::onCreateGLSLInstance() const { @@ -441,7 +439,7 @@ bool GrDeviceSpaceTextureDecalFragmentProcessor::onIsEqual(const GrFragmentProce GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDeviceSpaceTextureDecalFragmentProcessor); #if GR_TEST_UTILS -sk_sp GrDeviceSpaceTextureDecalFragmentProcessor::TestCreate( +std::unique_ptr 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 10c2e563c0..0db7d2c202 100644 --- a/src/gpu/effects/GrTextureDomain.h +++ b/src/gpu/effects/GrTextureDomain.h @@ -153,17 +153,17 @@ protected: */ class GrTextureDomainEffect : public GrFragmentProcessor { public: - static sk_sp Make(sk_sp, - sk_sp, - const SkMatrix&, - const SkRect& domain, - GrTextureDomain::Mode, - GrSamplerParams::FilterMode filterMode); + static std::unique_ptr Make(sk_sp, + sk_sp, + const SkMatrix&, + const SkRect& domain, + GrTextureDomain::Mode, + GrSamplerParams::FilterMode filterMode); const char* name() const override { return "TextureDomain"; } - sk_sp clone() const override { - return sk_sp(new GrTextureDomainEffect(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new GrTextureDomainEffect(*this)); } SkString dumpInfo() const override { @@ -207,9 +207,9 @@ private: class GrDeviceSpaceTextureDecalFragmentProcessor : public GrFragmentProcessor { public: - static sk_sp Make(sk_sp, - const SkIRect& subset, - const SkIPoint& deviceSpaceOffset); + static std::unique_ptr Make(sk_sp, + const SkIRect& subset, + const SkIPoint& deviceSpaceOffset); const char* name() const override { return "GrDeviceSpaceTextureDecalFragmentProcessor"; } @@ -223,7 +223,7 @@ public: return str; } - sk_sp clone() const override; + std::unique_ptr clone() const override; private: TextureSampler fTextureSampler; diff --git a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp index 490cb39990..f2c026fdfc 100644 --- a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp +++ b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp @@ -29,11 +29,11 @@ static inline bool does_cpu_blend_impl_match_gpu(SkBlendMode mode) { class ComposeTwoFragmentProcessor : public GrFragmentProcessor { public: - static sk_sp Make(sk_sp src, - sk_sp dst, - SkBlendMode mode) { - return sk_sp(new ComposeTwoFragmentProcessor(std::move(src), - std::move(dst), mode)); + static std::unique_ptr Make(std::unique_ptr src, + std::unique_ptr dst, + SkBlendMode mode) { + return std::unique_ptr( + new ComposeTwoFragmentProcessor(std::move(src), std::move(dst), mode)); } const char* name() const override { return "ComposeTwo"; } @@ -50,16 +50,15 @@ public: return str; } - sk_sp clone() const override; + std::unique_ptr clone() const override; SkBlendMode getMode() const { return fMode; } private: - ComposeTwoFragmentProcessor(sk_sp src, - sk_sp dst, + ComposeTwoFragmentProcessor(std::unique_ptr src, + std::unique_ptr dst, SkBlendMode mode) - : INHERITED(OptFlags(src.get(), dst.get(), mode)) - , fMode(mode) { + : INHERITED(OptFlags(src.get(), dst.get(), mode)), fMode(mode) { this->initClassID(); SkDEBUGCODE(int shaderAChildIndex = )this->registerChildProcessor(std::move(src)); SkDEBUGCODE(int shaderBChildIndex = )this->registerChildProcessor(std::move(dst)); @@ -182,24 +181,25 @@ private: GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ComposeTwoFragmentProcessor); #if GR_TEST_UTILS -sk_sp ComposeTwoFragmentProcessor::TestCreate(GrProcessorTestData* d) { +std::unique_ptr ComposeTwoFragmentProcessor::TestCreate( + GrProcessorTestData* d) { // Create two random frag procs. - sk_sp fpA(GrProcessorUnitTest::MakeChildFP(d)); - sk_sp fpB(GrProcessorUnitTest::MakeChildFP(d)); + std::unique_ptr fpA(GrProcessorUnitTest::MakeChildFP(d)); + std::unique_ptr fpB(GrProcessorUnitTest::MakeChildFP(d)); SkBlendMode mode; do { mode = static_cast(d->fRandom->nextRangeU(0, (int)SkBlendMode::kLastMode)); } while (SkBlendMode::kClear == mode || SkBlendMode::kSrc == mode || SkBlendMode::kDst == mode); - return sk_sp( - new ComposeTwoFragmentProcessor(std::move(fpA), std::move(fpB), mode)); + return std::unique_ptr( + new ComposeTwoFragmentProcessor(std::move(fpA), std::move(fpB), mode)); } #endif -sk_sp ComposeTwoFragmentProcessor::clone() const { +std::unique_ptr ComposeTwoFragmentProcessor::clone() const { auto src = this->childProcessor(0).clone(); auto dst = this->childProcessor(1).clone(); - return sk_sp( + return std::unique_ptr( new ComposeTwoFragmentProcessor(std::move(src), std::move(dst), fMode)); } @@ -242,8 +242,10 @@ void GLComposeTwoFragmentProcessor::emitCode(EmitArgs& args) { } } -sk_sp GrXfermodeFragmentProcessor::MakeFromTwoProcessors( - sk_sp src, sk_sp dst, SkBlendMode mode) { +std::unique_ptr GrXfermodeFragmentProcessor::MakeFromTwoProcessors( + std::unique_ptr src, + std::unique_ptr dst, + SkBlendMode mode) { switch (mode) { case SkBlendMode::kClear: return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(), @@ -266,13 +268,13 @@ public: kSrc_Child, }; - static sk_sp Make(sk_sp fp, SkBlendMode mode, - Child child) { + static std::unique_ptr Make(std::unique_ptr fp, + SkBlendMode mode, Child child) { if (!fp) { return nullptr; } - return sk_sp(new ComposeOneFragmentProcessor(std::move(fp), - mode, child)); + return std::unique_ptr( + new ComposeOneFragmentProcessor(std::move(fp), mode, child)); } const char* name() const override { return "ComposeOne"; } @@ -290,7 +292,7 @@ public: return str; } - sk_sp clone() const override; + std::unique_ptr clone() const override; SkBlendMode mode() const { return fMode; } @@ -417,10 +419,9 @@ private: } private: - ComposeOneFragmentProcessor(sk_sp fp, SkBlendMode mode, Child child) - : INHERITED(OptFlags(fp.get(), mode, child)) - , fMode(mode) - , fChild(child) { + ComposeOneFragmentProcessor(std::unique_ptr fp, SkBlendMode mode, + Child child) + : INHERITED(OptFlags(fp.get(), mode, child)), fMode(mode), fChild(child) { this->initClassID(); SkDEBUGCODE(int dstIndex =) this->registerChildProcessor(std::move(fp)); SkASSERT(0 == dstIndex); @@ -474,11 +475,12 @@ private: GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ComposeOneFragmentProcessor); #if GR_TEST_UTILS -sk_sp ComposeOneFragmentProcessor::TestCreate(GrProcessorTestData* d) { +std::unique_ptr 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 dst(GrProcessorUnitTest::MakeChildFP(d)); + std::unique_ptr dst(GrProcessorUnitTest::MakeChildFP(d)); SkBlendMode mode; ComposeOneFragmentProcessor::Child child; do { @@ -486,7 +488,8 @@ sk_sp ComposeOneFragmentProcessor::TestCreate(GrProcessorTe 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(new ComposeOneFragmentProcessor(std::move(dst), mode, child)); + return std::unique_ptr( + new ComposeOneFragmentProcessor(std::move(dst), mode, child)); } #endif @@ -494,8 +497,8 @@ GrGLSLFragmentProcessor* ComposeOneFragmentProcessor::onCreateGLSLInstance() con return new GLComposeOneFragmentProcessor; } -sk_sp ComposeOneFragmentProcessor::clone() const { - return sk_sp( +std::unique_ptr ComposeOneFragmentProcessor::clone() const { + return std::unique_ptr( new ComposeOneFragmentProcessor(this->childProcessor(0).clone(), fMode, fChild)); } @@ -507,8 +510,8 @@ sk_sp ComposeOneFragmentProcessor::clone() const { // ignore the original input. This could be implemented as: // RunInSeries(ConstColor(GrColor_WHITE, kIgnoreInput), inputFP). -sk_sp GrXfermodeFragmentProcessor::MakeFromDstProcessor( - sk_sp dst, SkBlendMode mode) { +std::unique_ptr GrXfermodeFragmentProcessor::MakeFromDstProcessor( + std::unique_ptr dst, SkBlendMode mode) { switch (mode) { case SkBlendMode::kClear: return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(), @@ -521,8 +524,8 @@ sk_sp GrXfermodeFragmentProcessor::MakeFromDstProcessor( } } -sk_sp GrXfermodeFragmentProcessor::MakeFromSrcProcessor( - sk_sp src, SkBlendMode mode) { +std::unique_ptr GrXfermodeFragmentProcessor::MakeFromSrcProcessor( + std::unique_ptr 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 edc5ae71e1..c5d0c599bb 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 MakeFromDstProcessor(sk_sp 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 MakeFromSrcProcessor(sk_sp 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. */ - sk_sp MakeFromTwoProcessors(sk_sp src, - sk_sp dst, - 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 MakeFromDstProcessor(std::unique_ptr 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 MakeFromSrcProcessor(std::unique_ptr 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 MakeFromTwoProcessors(std::unique_ptr src, + std::unique_ptr dst, + SkBlendMode mode); + }; #endif diff --git a/src/gpu/effects/GrYUVEffect.cpp b/src/gpu/effects/GrYUVEffect.cpp index 5b2eb7e3ae..80e87c2391 100644 --- a/src/gpu/effects/GrYUVEffect.cpp +++ b/src/gpu/effects/GrYUVEffect.cpp @@ -62,10 +62,11 @@ static const float kRec709InverseConversionMatrix[16] = { class YUVtoRGBEffect : public GrFragmentProcessor { public: - static sk_sp Make(sk_sp yProxy, - sk_sp uProxy, - sk_sp vProxy, const SkISize sizes[3], - SkYUVColorSpace colorSpace, bool nv12) { + static std::unique_ptr Make(sk_sp yProxy, + sk_sp uProxy, + sk_sp 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 @@ public: (sizes[2].fHeight != sizes[0].fHeight)) ? GrSamplerParams::kBilerp_FilterMode : GrSamplerParams::kNone_FilterMode; - return sk_sp(new YUVtoRGBEffect( - std::move(yProxy), std::move(uProxy), std::move(vProxy), - yuvMatrix, uvFilterMode, colorSpace, nv12)); + return std::unique_ptr( + 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 clone() const override { - return sk_sp(new YUVtoRGBEffect(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new YUVtoRGBEffect(*this)); } SkYUVColorSpace getColorSpace() const { return fColorSpace; } @@ -241,15 +242,16 @@ public: kV_OutputChannels }; - static sk_sp Make(sk_sp rgbFP, - SkYUVColorSpace colorSpace, - OutputChannels output) { - return sk_sp(new RGBToYUVEffect(std::move(rgbFP), colorSpace, output)); + static std::unique_ptr Make(std::unique_ptr rgbFP, + SkYUVColorSpace colorSpace, + OutputChannels output) { + return std::unique_ptr( + new RGBToYUVEffect(std::move(rgbFP), colorSpace, output)); } const char* name() const override { return "RGBToYUV"; } - sk_sp clone() const override { + std::unique_ptr clone() const override { return Make(this->childProcessor(0).clone(), fColorSpace, fOutputChannels); } @@ -353,7 +355,7 @@ public: }; private: - RGBToYUVEffect(sk_sp rgbFP, SkYUVColorSpace colorSpace, + RGBToYUVEffect(std::unique_ptr rgbFP, SkYUVColorSpace colorSpace, OutputChannels output) // This could advertise kConstantOutputForConstantInput, but doesn't seem useful. : INHERITED(kPreservesOpaqueInput_OptimizationFlag) @@ -393,42 +395,40 @@ private: ////////////////////////////////////////////////////////////////////////////// -sk_sp GrYUVEffect::MakeYUVToRGB(sk_sp yProxy, - sk_sp uProxy, - sk_sp vProxy, - const SkISize sizes[3], - SkYUVColorSpace colorSpace, bool nv12) { +std::unique_ptr GrYUVEffect::MakeYUVToRGB( + sk_sp yProxy, sk_sp uProxy, sk_sp 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 -GrYUVEffect::MakeRGBToYUV(sk_sp rgbFP, SkYUVColorSpace colorSpace) { +std::unique_ptr GrYUVEffect::MakeRGBToYUV( + std::unique_ptr rgbFP, SkYUVColorSpace colorSpace) { SkASSERT(rgbFP); return RGBToYUVEffect::Make(std::move(rgbFP), colorSpace, RGBToYUVEffect::kYUV_OutputChannels); } -sk_sp -GrYUVEffect::MakeRGBToY(sk_sp rgbFP, SkYUVColorSpace colorSpace) { +std::unique_ptr GrYUVEffect::MakeRGBToY( + std::unique_ptr rgbFP, SkYUVColorSpace colorSpace) { SkASSERT(rgbFP); return RGBToYUVEffect::Make(std::move(rgbFP), colorSpace, RGBToYUVEffect::kY_OutputChannels); } -sk_sp -GrYUVEffect::MakeRGBToUV(sk_sp rgbFP, SkYUVColorSpace colorSpace) { +std::unique_ptr GrYUVEffect::MakeRGBToUV( + std::unique_ptr rgbFP, SkYUVColorSpace colorSpace) { SkASSERT(rgbFP); return RGBToYUVEffect::Make(std::move(rgbFP), colorSpace, RGBToYUVEffect::kUV_OutputChannels); } -sk_sp -GrYUVEffect::MakeRGBToU(sk_sp rgbFP, SkYUVColorSpace colorSpace) { +std::unique_ptr GrYUVEffect::MakeRGBToU( + std::unique_ptr rgbFP, SkYUVColorSpace colorSpace) { SkASSERT(rgbFP); return RGBToYUVEffect::Make(std::move(rgbFP), colorSpace, RGBToYUVEffect::kU_OutputChannels); } -sk_sp -GrYUVEffect::MakeRGBToV(sk_sp rgbFP, SkYUVColorSpace colorSpace) { +std::unique_ptr GrYUVEffect::MakeRGBToV( + std::unique_ptr 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 ae62a16562..2ea41bf13c 100644 --- a/src/gpu/effects/GrYUVEffect.h +++ b/src/gpu/effects/GrYUVEffect.h @@ -18,32 +18,38 @@ namespace GrYUVEffect { * Creates an effect that performs color conversion from YUV to RGB. The input textures are * assumed to be kA8_GrPixelConfig. */ - sk_sp MakeYUVToRGB(sk_sp yProxy, - sk_sp uProxy, - sk_sp vProxy, const SkISize sizes[3], - SkYUVColorSpace colorSpace, bool nv12); +std::unique_ptr MakeYUVToRGB(sk_sp yProxy, + sk_sp uProxy, + sk_sp 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 MakeRGBToYUV(sk_sp, 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 MakeRGBToYUV(std::unique_ptr, + 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 MakeRGBToUV(sk_sp, 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 MakeRGBToY(sk_sp, SkYUVColorSpace); - sk_sp MakeRGBToU(sk_sp, SkYUVColorSpace); - sk_sp MakeRGBToV(sk_sp, 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 MakeRGBToUV(std::unique_ptr, + 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 MakeRGBToY(std::unique_ptr, + SkYUVColorSpace); +std::unique_ptr MakeRGBToU(std::unique_ptr, + SkYUVColorSpace); +std::unique_ptr MakeRGBToV(std::unique_ptr, + SkYUVColorSpace); }; #endif diff --git a/src/shaders/SkColorFilterShader.cpp b/src/shaders/SkColorFilterShader.cpp index a2d5433bad..bacfc37814 100644 --- a/src/shaders/SkColorFilterShader.cpp +++ b/src/shaders/SkColorFilterShader.cpp @@ -56,20 +56,19 @@ sk_sp SkColorFilterShader::onMakeColorSpace(SkColorSpaceXformer* xform #if SK_SUPPORT_GPU ///////////////////////////////////////////////////////////////////// -sk_sp SkColorFilterShader::asFragmentProcessor(const AsFPArgs& args) const { - - sk_sp fp1(as_SB(fShader)->asFragmentProcessor(args)); +std::unique_ptr SkColorFilterShader::asFragmentProcessor( + const AsFPArgs& args) const { + auto fp1 = as_SB(fShader)->asFragmentProcessor(args); if (!fp1) { return nullptr; } - sk_sp fp2(fFilter->asFragmentProcessor(args.fContext, - args.fDstColorSpace)); + auto fp2 = fFilter->asFragmentProcessor(args.fContext, args.fDstColorSpace); if (!fp2) { return fp1; } - sk_sp fpSeries[] = { std::move(fp1), std::move(fp2) }; + std::unique_ptr 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 3a1878fb2e..9cd199e7b1 100644 --- a/src/shaders/SkColorFilterShader.h +++ b/src/shaders/SkColorFilterShader.h @@ -18,7 +18,7 @@ public: SkColorFilterShader(sk_sp shader, sk_sp filter); #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(const AsFPArgs&) const override; + std::unique_ptr asFragmentProcessor(const AsFPArgs&) const override; #endif SK_TO_STRING_OVERRIDE() diff --git a/src/shaders/SkColorShader.cpp b/src/shaders/SkColorShader.cpp index e718cb0fbf..33ebc53f3f 100644 --- a/src/shaders/SkColorShader.cpp +++ b/src/shaders/SkColorShader.cpp @@ -89,7 +89,8 @@ SkShader::GradientType SkColorShader::asAGradient(GradientInfo* info) const { #include "SkGr.h" #include "effects/GrConstColorProcessor.h" -sk_sp SkColorShader::asFragmentProcessor(const AsFPArgs& args) const { +std::unique_ptr SkColorShader::asFragmentProcessor( + const AsFPArgs& args) const { GrColor4f color = SkColorToPremulGrColor4f(fColor, args.fDstColorSpace); return GrConstColorProcessor::Make(color, GrConstColorProcessor::kModulateA_InputMode); } @@ -206,7 +207,8 @@ SkShader::GradientType SkColor4Shader::asAGradient(GradientInfo* info) const { #include "SkGr.h" #include "effects/GrConstColorProcessor.h" #include "GrColorSpaceXform.h" -sk_sp SkColor4Shader::asFragmentProcessor(const AsFPArgs& args) const { +std::unique_ptr SkColor4Shader::asFragmentProcessor( + const AsFPArgs& args) const { sk_sp 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 f1bd4784f2..7d035f5ce2 100644 --- a/src/shaders/SkColorShader.h +++ b/src/shaders/SkColorShader.h @@ -47,7 +47,7 @@ public: GradientType asAGradient(GradientInfo* info) const override; #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(const AsFPArgs&) const override; + std::unique_ptr asFragmentProcessor(const AsFPArgs&) const override; #endif SK_TO_STRING_OVERRIDE() @@ -104,7 +104,7 @@ public: GradientType asAGradient(GradientInfo* info) const override; #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(const AsFPArgs&) const override; + std::unique_ptr asFragmentProcessor(const AsFPArgs&) const override; #endif SK_TO_STRING_OVERRIDE() diff --git a/src/shaders/SkComposeShader.cpp b/src/shaders/SkComposeShader.cpp index 7b3714003c..9799a1c142 100644 --- a/src/shaders/SkComposeShader.cpp +++ b/src/shaders/SkComposeShader.cpp @@ -125,7 +125,8 @@ bool SkComposeShader::onAppendStages(SkRasterPipeline* pipeline, SkColorSpace* d ///////////////////////////////////////////////////////////////////// -sk_sp SkComposeShader::asFragmentProcessor(const AsFPArgs& args) const { +std::unique_ptr 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 SkComposeShader::asFragmentProcessor(const AsFPArgs& } } - sk_sp fpA(as_SB(fDst)->asFragmentProcessor(args)); + std::unique_ptr fpA(as_SB(fDst)->asFragmentProcessor(args)); if (!fpA) { return nullptr; } - sk_sp fpB(as_SB(fSrc)->asFragmentProcessor(args)); + std::unique_ptr fpB(as_SB(fSrc)->asFragmentProcessor(args)); if (!fpB) { return nullptr; } diff --git a/src/shaders/SkComposeShader.h b/src/shaders/SkComposeShader.h index 1389742c3a..34abf62d53 100644 --- a/src/shaders/SkComposeShader.h +++ b/src/shaders/SkComposeShader.h @@ -23,7 +23,7 @@ public: } #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(const AsFPArgs&) const override; + std::unique_ptr asFragmentProcessor(const AsFPArgs&) const override; #endif #ifdef SK_DEBUGx diff --git a/src/shaders/SkImageShader.cpp b/src/shaders/SkImageShader.cpp index 609ad4b869..edd1f41dca 100644 --- a/src/shaders/SkImageShader.cpp +++ b/src/shaders/SkImageShader.cpp @@ -167,8 +167,8 @@ void SkImageShader::toString(SkString* str) const { #include "effects/GrBicubicEffect.h" #include "effects/GrSimpleTextureEffect.h" -sk_sp SkImageShader::asFragmentProcessor(const AsFPArgs& args) const { - +std::unique_ptr SkImageShader::asFragmentProcessor( + const AsFPArgs& args) const { SkMatrix lmInverse; if (!this->getLocalMatrix().invert(&lmInverse)) { return nullptr; @@ -207,7 +207,7 @@ sk_sp SkImageShader::asFragmentProcessor(const AsFPArgs& ar sk_sp colorSpaceXform = GrColorSpaceXform::Make(texColorSpace.get(), args.fDstColorSpace); - sk_sp inner; + std::unique_ptr inner; if (doBicubic) { inner = GrBicubicEffect::Make(std::move(proxy), std::move(colorSpaceXform), lmInverse, tm); @@ -219,7 +219,7 @@ sk_sp SkImageShader::asFragmentProcessor(const AsFPArgs& ar if (isAlphaOnly) { return inner; } - return sk_sp(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 b499b927a5..8e592e504c 100644 --- a/src/shaders/SkImageShader.h +++ b/src/shaders/SkImageShader.h @@ -24,7 +24,7 @@ public: SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkImageShader) #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(const AsFPArgs&) const override; + std::unique_ptr asFragmentProcessor(const AsFPArgs&) const override; #endif SkImageShader(sk_sp, TileMode tx, TileMode ty, const SkMatrix* localMatrix); diff --git a/src/shaders/SkLocalMatrixShader.cpp b/src/shaders/SkLocalMatrixShader.cpp index e21e4a84b7..254092dc44 100644 --- a/src/shaders/SkLocalMatrixShader.cpp +++ b/src/shaders/SkLocalMatrixShader.cpp @@ -12,7 +12,8 @@ #endif #if SK_SUPPORT_GPU -sk_sp SkLocalMatrixShader::asFragmentProcessor(const AsFPArgs& args) const { +std::unique_ptr 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 3ae44cf559..407c30dc52 100644 --- a/src/shaders/SkLocalMatrixShader.h +++ b/src/shaders/SkLocalMatrixShader.h @@ -28,7 +28,7 @@ public: } #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(const AsFPArgs&) const override; + std::unique_ptr asFragmentProcessor(const AsFPArgs&) const override; #endif sk_sp makeAsALocalMatrixShader(SkMatrix* localMatrix) const override { diff --git a/src/shaders/SkPerlinNoiseShader.cpp b/src/shaders/SkPerlinNoiseShader.cpp index 0ce007a55a..cc9a56959d 100644 --- a/src/shaders/SkPerlinNoiseShader.cpp +++ b/src/shaders/SkPerlinNoiseShader.cpp @@ -350,7 +350,7 @@ public: }; #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(const AsFPArgs&) const override; + std::unique_ptr asFragmentProcessor(const AsFPArgs&) const override; #endif SK_TO_STRING_OVERRIDE() @@ -693,22 +693,20 @@ private: class GrPerlinNoise2Effect : public GrFragmentProcessor { public: - static sk_sp Make(SkPerlinNoiseShaderImpl::Type type, - int numOctaves, bool stitchTiles, - std::unique_ptr paintingData, - sk_sp permutationsProxy, - sk_sp noiseProxy, - const SkMatrix& matrix) { - return sk_sp( - new GrPerlinNoise2Effect(type, numOctaves, stitchTiles, - std::move(paintingData), - std::move(permutationsProxy), std::move(noiseProxy), matrix)); + static std::unique_ptr Make( + SkPerlinNoiseShaderImpl::Type type, int numOctaves, bool stitchTiles, + std::unique_ptr paintingData, + sk_sp permutationsProxy, sk_sp noiseProxy, + const SkMatrix& matrix) { + return std::unique_ptr(new GrPerlinNoise2Effect( + type, numOctaves, stitchTiles, std::move(paintingData), + std::move(permutationsProxy), std::move(noiseProxy), matrix)); } const char* name() const override { return "PerlinNoise"; } - sk_sp clone() const override { - return sk_sp(new GrPerlinNoise2Effect(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new GrPerlinNoise2Effect(*this)); } const SkPerlinNoiseShaderImpl::StitchData& stitchData() const { return fPaintingData->fStitchDataInit; } @@ -789,7 +787,7 @@ private: GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrPerlinNoise2Effect); #if GR_TEST_UTILS -sk_sp GrPerlinNoise2Effect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr 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 @@ private: class GrImprovedPerlinNoiseEffect : public GrFragmentProcessor { public: - static sk_sp Make(int octaves, SkScalar z, - std::unique_ptr paintingData, - sk_sp permutationsProxy, - sk_sp gradientProxy, - const SkMatrix& matrix) { - return sk_sp( - new GrImprovedPerlinNoiseEffect(octaves, z, std::move(paintingData), - std::move(permutationsProxy), - std::move(gradientProxy), matrix)); + static std::unique_ptr Make( + int octaves, SkScalar z, + std::unique_ptr paintingData, + sk_sp permutationsProxy, sk_sp gradientProxy, + const SkMatrix& matrix) { + return std::unique_ptr(new GrImprovedPerlinNoiseEffect( + octaves, z, std::move(paintingData), std::move(permutationsProxy), + std::move(gradientProxy), matrix)); } const char* name() const override { return "ImprovedPerlinNoise"; } - sk_sp clone() const override { - return sk_sp(new GrImprovedPerlinNoiseEffect(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new GrImprovedPerlinNoiseEffect(*this)); } const SkVector& baseFrequency() const { return fPaintingData->fBaseFrequency; } @@ -1213,7 +1210,8 @@ private: GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrImprovedPerlinNoiseEffect); #if GR_TEST_UTILS -sk_sp GrImprovedPerlinNoiseEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr GrImprovedPerlinNoiseEffect::TestCreate( + GrProcessorTestData* d) { SkScalar baseFrequencyX = d->fRandom->nextRangeScalar(0.01f, 0.99f); SkScalar baseFrequencyY = d->fRandom->nextRangeScalar(0.01f, @@ -1387,7 +1385,8 @@ void GrGLImprovedPerlinNoise::onSetData(const GrGLSLProgramDataManager& pdman, } ///////////////////////////////////////////////////////////////////// -sk_sp SkPerlinNoiseShaderImpl::asFragmentProcessor(const AsFPArgs& args) const { +std::unique_ptr SkPerlinNoiseShaderImpl::asFragmentProcessor( + const AsFPArgs& args) const { SkASSERT(args.fContext); SkMatrix localMatrix = this->getLocalMatrix(); @@ -1434,9 +1433,9 @@ sk_sp SkPerlinNoiseShaderImpl::asFragmentProcessor(const As // 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 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 @@ sk_sp SkPerlinNoiseShaderImpl::asFragmentProcessor(const As paintingData->getNoiseBitmap()); if (permutationsProxy && noiseProxy) { - sk_sp 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 4c746ee94f..a14c211fba 100644 --- a/src/shaders/SkPictureShader.cpp +++ b/src/shaders/SkPictureShader.cpp @@ -373,7 +373,8 @@ void SkPictureShader::toString(SkString* str) const { #endif #if SK_SUPPORT_GPU -sk_sp SkPictureShader::asFragmentProcessor(const AsFPArgs& args) const { +std::unique_ptr 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 3d58d6db38..ee1ffb52a0 100644 --- a/src/shaders/SkPictureShader.h +++ b/src/shaders/SkPictureShader.h @@ -32,7 +32,7 @@ public: SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPictureShader) #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(const AsFPArgs&) const override; + std::unique_ptr asFragmentProcessor(const AsFPArgs&) const override; #endif protected: diff --git a/src/shaders/SkShader.cpp b/src/shaders/SkShader.cpp index 5540b2d95f..d288054a99 100644 --- a/src/shaders/SkShader.cpp +++ b/src/shaders/SkShader.cpp @@ -163,7 +163,7 @@ SkShader::GradientType SkShader::asAGradient(GradientInfo* info) const { } #if SK_SUPPORT_GPU -sk_sp SkShaderBase::asFragmentProcessor(const AsFPArgs&) const { +std::unique_ptr SkShaderBase::asFragmentProcessor(const AsFPArgs&) const { return nullptr; } #endif diff --git a/src/shaders/SkShaderBase.h b/src/shaders/SkShaderBase.h index 99cace22f9..8f64efea82 100644 --- a/src/shaders/SkShaderBase.h +++ b/src/shaders/SkShaderBase.h @@ -167,7 +167,7 @@ public: * The returned GrFragmentProcessor should expect an unpremultiplied input color and * produce a premultiplied output. */ - virtual sk_sp asFragmentProcessor(const AsFPArgs&) const; + virtual std::unique_ptr asFragmentProcessor(const AsFPArgs&) const; #endif /** diff --git a/src/shaders/gradients/SkLinearGradient.cpp b/src/shaders/gradients/SkLinearGradient.cpp index 0ed5350c6e..551368b94d 100644 --- a/src/shaders/gradients/SkLinearGradient.cpp +++ b/src/shaders/gradients/SkLinearGradient.cpp @@ -333,15 +333,15 @@ class GrLinearGradient : public GrGradientEffect { public: class GLSLLinearProcessor; - static sk_sp Make(const CreateArgs& args) { - auto processor = sk_sp(new GrLinearGradient(args)); + static std::unique_ptr Make(const CreateArgs& args) { + auto processor = std::unique_ptr(new GrLinearGradient(args)); return processor->isValid() ? std::move(processor) : nullptr; } const char* name() const override { return "Linear Gradient"; } - sk_sp clone() const override { - return sk_sp(new GrLinearGradient(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new GrLinearGradient(*this)); } private: @@ -396,7 +396,7 @@ void GrLinearGradient::onGetGLSLProcessorKey(const GrShaderCaps& caps, GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrLinearGradient); #if GR_TEST_UTILS -sk_sp GrLinearGradient::TestCreate(GrProcessorTestData* d) { +std::unique_ptr GrLinearGradient::TestCreate(GrProcessorTestData* d) { SkPoint points[] = {{d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()}, {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()}}; @@ -407,7 +407,7 @@ sk_sp GrLinearGradient::TestCreate(GrProcessorTestData* d) SkGradientShader::MakeLinear(points, params.fColors, params.fStops, params.fColorCount, params.fTileMode); GrTest::TestAsFPArgs asFPArgs(d); - sk_sp fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args()); + std::unique_ptr fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args()); GrAlwaysAssert(fp); return fp; } @@ -432,7 +432,8 @@ void GrLinearGradient::GLSLLinearProcessor::emitCode(EmitArgs& args) { ///////////////////////////////////////////////////////////////////// -sk_sp SkLinearGradient::asFragmentProcessor(const AsFPArgs& args) const { +std::unique_ptr SkLinearGradient::asFragmentProcessor( + const AsFPArgs& args) const { SkASSERT(args.fContext); SkMatrix matrix; @@ -450,9 +451,9 @@ sk_sp SkLinearGradient::asFragmentProcessor(const AsFPArgs& sk_sp colorSpaceXform = GrColorSpaceXform::Make(fColorSpace.get(), args.fDstColorSpace); - sk_sp 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 c0ba7f4dbf..64db9dcdb3 100644 --- a/src/shaders/gradients/SkLinearGradient.h +++ b/src/shaders/gradients/SkLinearGradient.h @@ -52,7 +52,7 @@ public: GradientType asAGradient(GradientInfo* info) const override; #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(const AsFPArgs&) const override; + std::unique_ptr 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 02086ea9fa..94d823c90c 100644 --- a/src/shaders/gradients/SkRadialGradient.cpp +++ b/src/shaders/gradients/SkRadialGradient.cpp @@ -68,15 +68,15 @@ class GrRadialGradient : public GrGradientEffect { public: class GLSLRadialProcessor; - static sk_sp Make(const CreateArgs& args) { - auto processor = sk_sp(new GrRadialGradient(args)); + static std::unique_ptr Make(const CreateArgs& args) { + auto processor = std::unique_ptr(new GrRadialGradient(args)); return processor->isValid() ? std::move(processor) : nullptr; } const char* name() const override { return "Radial Gradient"; } - sk_sp clone() const override { - return sk_sp(new GrRadialGradient(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new GrRadialGradient(*this)); } private: @@ -132,7 +132,7 @@ void GrRadialGradient::onGetGLSLProcessorKey(const GrShaderCaps& caps, GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRadialGradient); #if GR_TEST_UTILS -sk_sp GrRadialGradient::TestCreate(GrProcessorTestData* d) { +std::unique_ptr GrRadialGradient::TestCreate(GrProcessorTestData* d) { sk_sp shader; do { RandomGradientParams params(d->fRandom); @@ -147,7 +147,7 @@ sk_sp GrRadialGradient::TestCreate(GrProcessorTestData* d) params.fTileMode); } while (!shader); GrTest::TestAsFPArgs asFPArgs(d); - sk_sp fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args()); + std::unique_ptr fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args()); GrAlwaysAssert(fp); return fp; } @@ -172,7 +172,8 @@ void GrRadialGradient::GLSLRadialProcessor::emitCode(EmitArgs& args) { ///////////////////////////////////////////////////////////////////// -sk_sp SkRadialGradient::asFragmentProcessor(const AsFPArgs& args) const { +std::unique_ptr SkRadialGradient::asFragmentProcessor( + const AsFPArgs& args) const { SkASSERT(args.fContext); SkMatrix matrix; @@ -189,9 +190,9 @@ sk_sp SkRadialGradient::asFragmentProcessor(const AsFPArgs& matrix.postConcat(fPtsToUnit); sk_sp colorSpaceXform = GrColorSpaceXform::Make(fColorSpace.get(), args.fDstColorSpace); - sk_sp 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 8cd7df2680..6a6dadfbc4 100644 --- a/src/shaders/gradients/SkRadialGradient.h +++ b/src/shaders/gradients/SkRadialGradient.h @@ -16,7 +16,7 @@ public: GradientType asAGradient(GradientInfo* info) const override; #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(const AsFPArgs&) const override; + std::unique_ptr 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 011474ca24..87b82fdfac 100644 --- a/src/shaders/gradients/SkSweepGradient.cpp +++ b/src/shaders/gradients/SkSweepGradient.cpp @@ -74,16 +74,16 @@ class GrSweepGradient : public GrGradientEffect { public: class GLSLSweepProcessor; - static sk_sp Make(const CreateArgs& args, SkScalar tBias, - SkScalar tScale) { - auto processor = sk_sp(new GrSweepGradient(args, tBias, tScale)); + static std::unique_ptr Make(const CreateArgs& args, SkScalar tBias, + SkScalar tScale) { + auto processor = std::unique_ptr(new GrSweepGradient(args, tBias, tScale)); return processor->isValid() ? std::move(processor) : nullptr; } const char* name() const override { return "Sweep Gradient"; } - sk_sp clone() const override { - return sk_sp(new GrSweepGradient(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new GrSweepGradient(*this)); } private: @@ -176,7 +176,7 @@ void GrSweepGradient::onGetGLSLProcessorKey(const GrShaderCaps& caps, GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSweepGradient); #if GR_TEST_UTILS -sk_sp GrSweepGradient::TestCreate(GrProcessorTestData* d) { +std::unique_ptr GrSweepGradient::TestCreate(GrProcessorTestData* d) { SkPoint center = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()}; RandomGradientParams params(d->fRandom); @@ -186,7 +186,7 @@ sk_sp GrSweepGradient::TestCreate(GrProcessorTestData* d) { SkGradientShader::MakeSweep(center.fX, center.fY, params.fColors, params.fStops, params.fColorCount); GrTest::TestAsFPArgs asFPArgs(d); - sk_sp fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args()); + std::unique_ptr fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args()); GrAlwaysAssert(fp); return fp; } @@ -229,8 +229,8 @@ void GrSweepGradient::GLSLSweepProcessor::emitCode(EmitArgs& args) { ///////////////////////////////////////////////////////////////////// -sk_sp SkSweepGradient::asFragmentProcessor(const AsFPArgs& args) const { - +std::unique_ptr SkSweepGradient::asFragmentProcessor( + const AsFPArgs& args) const { SkMatrix matrix; if (!this->getLocalMatrix().invert(&matrix)) { return nullptr; @@ -246,10 +246,10 @@ sk_sp SkSweepGradient::asFragmentProcessor(const AsFPArgs& sk_sp colorSpaceXform = GrColorSpaceXform::Make(fColorSpace.get(), args.fDstColorSpace); - sk_sp 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 b42f270d5c..061d699887 100644 --- a/src/shaders/gradients/SkSweepGradient.h +++ b/src/shaders/gradients/SkSweepGradient.h @@ -17,7 +17,7 @@ public: GradientType asAGradient(GradientInfo* info) const override; #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(const AsFPArgs&) const override; + std::unique_ptr 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 0bee74fe38..a1634727a9 100644 --- a/src/shaders/gradients/SkTwoPointConicalGradient.cpp +++ b/src/shaders/gradients/SkTwoPointConicalGradient.cpp @@ -133,14 +133,14 @@ void SkTwoPointConicalGradient::flatten(SkWriteBuffer& buffer) const { #include "SkGr.h" #include "SkTwoPointConicalGradient_gpu.h" -sk_sp SkTwoPointConicalGradient::asFragmentProcessor( +std::unique_ptr SkTwoPointConicalGradient::asFragmentProcessor( const AsFPArgs& args) const { SkASSERT(args.fContext); sk_sp colorSpaceXform = GrColorSpaceXform::Make(fColorSpace.get(), args.fDstColorSpace); - sk_sp 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 408f31d8d3..4b2827117c 100644 --- a/src/shaders/gradients/SkTwoPointConicalGradient.h +++ b/src/shaders/gradients/SkTwoPointConicalGradient.h @@ -19,7 +19,7 @@ public: SkShader::GradientType asAGradient(GradientInfo* info) const override; #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(const AsFPArgs&) const override; + std::unique_ptr 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 8263f88946..caada92159 100644 --- a/src/shaders/gradients/SkTwoPointConicalGradient_gpu.cpp +++ b/src/shaders/gradients/SkTwoPointConicalGradient_gpu.cpp @@ -61,8 +61,8 @@ class Edge2PtConicalEffect : public GrGradientEffect { public: class GLSLEdge2PtConicalProcessor; - static sk_sp Make(const CreateArgs& args) { - auto processor = sk_sp(new Edge2PtConicalEffect(args)); + static std::unique_ptr Make(const CreateArgs& args) { + auto processor = std::unique_ptr(new Edge2PtConicalEffect(args)); return processor->isValid() ? std::move(processor) : nullptr; } @@ -75,8 +75,8 @@ public: SkScalar diffRadius() const { return fDiffRadius; } SkScalar radius() const { return fRadius0; } - sk_sp clone() const override { - return sk_sp(new Edge2PtConicalEffect(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new Edge2PtConicalEffect(*this)); } private: @@ -193,7 +193,7 @@ GR_DEFINE_FRAGMENT_PROCESSOR_TEST(Edge2PtConicalEffect); * All Two point conical gradient test create functions may occasionally create edge case shaders */ #if GR_TEST_UTILS -sk_sp Edge2PtConicalEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr Edge2PtConicalEffect::TestCreate(GrProcessorTestData* d) { SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()}; SkScalar radius1 = d->fRandom->nextUScalar1(); SkPoint center2; @@ -219,7 +219,7 @@ sk_sp Edge2PtConicalEffect::TestCreate(GrProcessorTestData* params.fColors, params.fStops, params.fColorCount, params.fTileMode); GrTest::TestAsFPArgs asFPArgs(d); - sk_sp fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args()); + std::unique_ptr fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args()); GrAlwaysAssert(fp); return fp; } @@ -381,9 +381,9 @@ class FocalOutside2PtConicalEffect : public GrGradientEffect { public: class GLSLFocalOutside2PtConicalProcessor; - static sk_sp Make(const CreateArgs& args, SkScalar focalX) { - auto processor = - sk_sp(new FocalOutside2PtConicalEffect(args, focalX)); + static std::unique_ptr Make(const CreateArgs& args, SkScalar focalX) { + auto processor = std::unique_ptr( + new FocalOutside2PtConicalEffect(args, focalX)); return processor->isValid() ? std::move(processor) : nullptr; } @@ -391,8 +391,8 @@ public: return "Two-Point Conical Gradient Focal Outside"; } - sk_sp clone() const override { - return sk_sp(new FocalOutside2PtConicalEffect(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new FocalOutside2PtConicalEffect(*this)); } bool isFlipped() const { return fIsFlipped; } @@ -481,7 +481,8 @@ GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalOutside2PtConicalEffect); * All Two point conical gradient test create functions may occasionally create edge case shaders */ #if GR_TEST_UTILS -sk_sp FocalOutside2PtConicalEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr FocalOutside2PtConicalEffect::TestCreate( + GrProcessorTestData* d) { SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()}; SkScalar radius1 = 0.f; SkPoint center2; @@ -505,7 +506,7 @@ sk_sp FocalOutside2PtConicalEffect::TestCreate(GrProcessorT params.fColors, params.fStops, params.fColorCount, params.fTileMode); GrTest::TestAsFPArgs asFPArgs(d); - sk_sp fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args()); + std::unique_ptr fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args()); GrAlwaysAssert(fp); return fp; } @@ -601,9 +602,9 @@ class FocalInside2PtConicalEffect : public GrGradientEffect { public: class GLSLFocalInside2PtConicalProcessor; - static sk_sp Make(const CreateArgs& args, SkScalar focalX) { - auto processor = - sk_sp(new FocalInside2PtConicalEffect(args, focalX)); + static std::unique_ptr Make(const CreateArgs& args, SkScalar focalX) { + auto processor = std::unique_ptr( + new FocalInside2PtConicalEffect(args, focalX)); return processor->isValid() ? std::move(processor) : nullptr; } @@ -611,8 +612,8 @@ public: return "Two-Point Conical Gradient Focal Inside"; } - sk_sp clone() const override { - return sk_sp(new FocalInside2PtConicalEffect(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new FocalInside2PtConicalEffect(*this)); } SkScalar focal() const { return fFocalX; } @@ -691,7 +692,8 @@ GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalInside2PtConicalEffect); * All Two point conical gradient test create functions may occasionally create edge case shaders */ #if GR_TEST_UTILS -sk_sp FocalInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr FocalInside2PtConicalEffect::TestCreate( + GrProcessorTestData* d) { SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()}; SkScalar radius1 = 0.f; SkPoint center2; @@ -716,7 +718,7 @@ sk_sp FocalInside2PtConicalEffect::TestCreate(GrProcessorTe params.fColors, params.fStops, params.fColorCount, params.fTileMode); GrTest::TestAsFPArgs asFPArgs(d); - sk_sp fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args()); + std::unique_ptr fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args()); GrAlwaysAssert(fp); return fp; } @@ -846,16 +848,17 @@ class CircleInside2PtConicalEffect : public GrGradientEffect { public: class GLSLCircleInside2PtConicalProcessor; - static sk_sp Make(const CreateArgs& args, const CircleConicalInfo& info) { - auto processor = - sk_sp(new CircleInside2PtConicalEffect(args, info)); + static std::unique_ptr Make(const CreateArgs& args, + const CircleConicalInfo& info) { + auto processor = std::unique_ptr( + new CircleInside2PtConicalEffect(args, info)); return processor->isValid() ? std::move(processor) : nullptr; } const char* name() const override { return "Two-Point Conical Gradient Inside"; } - sk_sp clone() const override { - return sk_sp(new CircleInside2PtConicalEffect(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new CircleInside2PtConicalEffect(*this)); } SkScalar centerX() const { return fInfo.fCenterEnd.fX; } @@ -945,7 +948,8 @@ GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleInside2PtConicalEffect); * All Two point conical gradient test create functions may occasionally create edge case shaders */ #if GR_TEST_UTILS -sk_sp CircleInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr 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 @@ sk_sp CircleInside2PtConicalEffect::TestCreate(GrProcessorT params.fColors, params.fStops, params.fColorCount, params.fTileMode); GrTest::TestAsFPArgs asFPArgs(d); - sk_sp fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args()); + std::unique_ptr fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args()); GrAlwaysAssert(fp); return fp; } @@ -1068,15 +1072,15 @@ class CircleOutside2PtConicalEffect : public GrGradientEffect { public: class GLSLCircleOutside2PtConicalProcessor; - static sk_sp Make(const CreateArgs& args, const CircleConicalInfo& info) { - return sk_sp( - new CircleOutside2PtConicalEffect(args, info)); + static std::unique_ptr Make(const CreateArgs& args, + const CircleConicalInfo& info) { + return std::unique_ptr(new CircleOutside2PtConicalEffect(args, info)); } const char* name() const override { return "Two-Point Conical Gradient Outside"; } - sk_sp clone() const override { - return sk_sp(new CircleOutside2PtConicalEffect(*this)); + std::unique_ptr clone() const override { + return std::unique_ptr(new CircleOutside2PtConicalEffect(*this)); } SkScalar centerX() const { return fInfo.fCenterEnd.fX; } @@ -1187,7 +1191,8 @@ GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleOutside2PtConicalEffect); * All Two point conical gradient test create functions may occasionally create edge case shaders */ #if GR_TEST_UTILS -sk_sp CircleOutside2PtConicalEffect::TestCreate(GrProcessorTestData* d) { +std::unique_ptr 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 @@ sk_sp CircleOutside2PtConicalEffect::TestCreate(GrProcessor params.fColors, params.fStops, params.fColorCount, params.fTileMode); GrTest::TestAsFPArgs asFPArgs(d); - sk_sp fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args()); + std::unique_ptr fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args()); GrAlwaysAssert(fp); return fp; } @@ -1334,8 +1339,8 @@ void CircleOutside2PtConicalEffect::GLSLCircleOutside2PtConicalProcessor::GenKey ////////////////////////////////////////////////////////////////////////////// -sk_sp Gr2PtConicalGradientEffect::Make( - const GrGradientEffect::CreateArgs& args) { +std::unique_ptr Gr2PtConicalGradientEffect::Make( + const GrGradientEffect::CreateArgs& args) { const SkTwoPointConicalGradient& shader = *static_cast(args.fShader); diff --git a/src/shaders/gradients/SkTwoPointConicalGradient_gpu.h b/src/shaders/gradients/SkTwoPointConicalGradient_gpu.h index 46edb1f7d1..e7eac07299 100644 --- a/src/shaders/gradients/SkTwoPointConicalGradient_gpu.h +++ b/src/shaders/gradients/SkTwoPointConicalGradient_gpu.h @@ -14,11 +14,12 @@ class GrProcessor; class SkTwoPointConicalGradient; namespace Gr2PtConicalGradientEffect { - /** - * Creates an effect that produces a two point conical gradient based on the - * shader passed in. - */ - sk_sp Make(const GrGradientEffect::CreateArgs& args); + +/** + * Creates an effect that produces a two point conical gradient based on the shader passed in. + */ +std::unique_ptr Make(const GrGradientEffect::CreateArgs& args); + }; #endif diff --git a/src/sksl/SkSLCPPCodeGenerator.cpp b/src/sksl/SkSLCPPCodeGenerator.cpp index 76faef9aae..bc47ff0ce3 100644 --- a/src/sksl/SkSLCPPCodeGenerator.cpp +++ b/src/sksl/SkSLCPPCodeGenerator.cpp @@ -543,8 +543,10 @@ void CPPCodeGenerator::writeClone() { this->writef(" this->addCoordTransform(&%sCoordTransform);\n", field.c_str()); } this->write("}\n"); - this->writef("sk_sp %s::clone() const {\n", fFullName.c_str()); - this->writef(" return sk_sp(new %s(*this));\n", fFullName.c_str()); + this->writef("std::unique_ptr %s::clone() const {\n", + fFullName.c_str()); + this->writef(" return std::unique_ptr(new %s(*this));\n", + fFullName.c_str()); this->write("}\n"); } } @@ -552,12 +554,13 @@ void CPPCodeGenerator::writeClone() { 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 %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 %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 22f4fd80ce..50d242896a 100644 --- a/src/sksl/SkSLHCodeGenerator.cpp +++ b/src/sksl/SkSLHCodeGenerator.cpp @@ -123,7 +123,7 @@ void HCodeGenerator::writeExtraConstructorParams(const char* separator) { void HCodeGenerator::writeMake() { const char* separator; if (!this->writeSection(MAKE_SECTION)) { - this->writef(" static sk_sp Make("); + this->writef(" static std::unique_ptr Make("); separator = ""; for (const auto& param : fSectionAndParameterHelper.getParameters()) { this->writef("%s%s %s", separator, ParameterType(param->fType).c_str(), @@ -132,7 +132,7 @@ void HCodeGenerator::writeMake() { } this->writeSection(CONSTRUCTOR_PARAMS_SECTION, separator); this->writef(") {\n" - " return sk_sp(new %s(", + " return std::unique_ptr(new %s(", fFullName.c_str()); separator = ""; for (const auto& param : fSectionAndParameterHelper.getParameters()) { @@ -251,7 +251,7 @@ bool HCodeGenerator::generateCode() { } this->writeMake(); this->writef(" %s(const %s& src);\n" - " sk_sp clone() const override;\n" + " std::unique_ptr 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 b6c57f370e..e95668ae2b 100644 --- a/src/utils/SkShadowUtils.cpp +++ b/src/utils/SkShadowUtils.cpp @@ -38,7 +38,8 @@ public: } #if SK_SUPPORT_GPU - sk_sp asFragmentProcessor(GrContext*, SkColorSpace*) const override; + std::unique_ptr asFragmentProcessor(GrContext*, + SkColorSpace*) const override; #endif SK_TO_STRING_OVERRIDE() @@ -68,8 +69,8 @@ void SkGaussianColorFilter::toString(SkString* str) const { #if SK_SUPPORT_GPU -sk_sp SkGaussianColorFilter::asFragmentProcessor(GrContext*, - SkColorSpace*) const { +std::unique_ptr SkGaussianColorFilter::asFragmentProcessor( + GrContext*, SkColorSpace*) const { return GrBlurredEdgeFragmentProcessor::Make(GrBlurredEdgeFragmentProcessor::kGaussian_Mode); } #endif -- cgit v1.2.3