sk_sp for gpu.

src/gpu/effects/GrMatrixConvolutionEffect.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrMatrixConvolutionEffect.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
@@ skipping 173 matching lines @@
            !memcmp(fKernel, s.kernel(),
                    fKernelSize.width() * fKernelSize.height() * sizeof(float)) &&
            fGain == s.gain() &&
            fBias == s.bias() &&
            fKernelOffset == s.kernelOffset() &&
            fConvolveAlpha == s.convolveAlpha() &&
            fDomain == s.domain();
 }
 
 // Static function to create a 2D convolution
-GrFragmentProcessor*
-GrMatrixConvolutionEffect::CreateGaussian(GrTexture* texture,
-                                          const SkIRect& bounds,
-                                          const SkISize& kernelSize,
-                                          SkScalar gain,
-                                          SkScalar bias,
-                                          const SkIPoint& kernelOffset,
-                                          GrTextureDomain::Mode tileMode,
-                                          bool convolveAlpha,
-                                          SkScalar sigmaX,
-                                          SkScalar sigmaY) {
+sk_sp<GrFragmentProcessor>
+GrMatrixConvolutionEffect::MakeGaussian(GrTexture* texture,
+                                        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];
     int width = kernelSize.width();
     int height = kernelSize.height();
     SkASSERT(width * height <= MAX_KERNEL_SIZE);
     float sum = 0.0f;
     float sigmaXDenom = 1.0f / (2.0f * SkScalarToFloat(SkScalarSquare(sigmaX)));
     float sigmaYDenom = 1.0f / (2.0f * SkScalarToFloat(SkScalarSquare(sigmaY)));
     int xRadius = width / 2;
     int yRadius = height / 2;
     for (int x = 0; x < width; x++) {
       float xTerm = static_cast<float>(x - xRadius);
       xTerm = xTerm * xTerm * sigmaXDenom;
       for (int y = 0; y < height; y++) {
         float yTerm = static_cast<float>(y - yRadius);
         float xyTerm = sk_float_exp(-(xTerm + yTerm * yTerm * sigmaYDenom));
         // Note that the constant term (1/(sqrt(2*pi*sigma^2)) of the Gaussian
        // is dropped here, since we renormalize the kernel below.
         kernel[y * width + x] = xyTerm;
         sum += xyTerm;
       }
     }
     // Normalize the kernel
     float scale = 1.0f / sum;
     for (int i = 0; i < width * height; ++i) {
         kernel[i] *= scale;
     }
-    return new GrMatrixConvolutionEffect(texture, bounds, kernelSize, kernel, gain, bias,
-                                         kernelOffset, tileMode, convolveAlpha);
+    return sk_sp<GrFragmentProcessor>(
+        new GrMatrixConvolutionEffect(texture, bounds, kernelSize, kernel, gain, bias,
+                                      kernelOffset, tileMode, convolveAlpha));
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMatrixConvolutionEffect);
 
-const GrFragmentProcessor* GrMatrixConvolutionEffect::TestCreate(GrProcessorTestData* d) {
+sk_sp<GrFragmentProcessor> GrMatrixConvolutionEffect::TestCreate(GrProcessorTestData* d) {
     int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
                                           GrProcessorUnitTest::kAlphaTextureIdx;
     int width = d->fRandom->nextRangeU(1, MAX_KERNEL_SIZE);
     int height = d->fRandom->nextRangeU(1, MAX_KERNEL_SIZE / width);
     SkISize kernelSize = SkISize::Make(width, height);
     SkAutoTDeleteArray<SkScalar> kernel(new SkScalar[width * height]);
     for (int i = 0; i < width * height; i++) {
         kernel.get()[i] = d->fRandom->nextSScalar1();
     }
     SkScalar gain = d->fRandom->nextSScalar1();
     SkScalar bias = d->fRandom->nextSScalar1();
     SkIPoint kernelOffset = SkIPoint::Make(d->fRandom->nextRangeU(0, kernelSize.width()),
                                            d->fRandom->nextRangeU(0, kernelSize.height()));
     SkIRect bounds = SkIRect::MakeXYWH(d->fRandom->nextRangeU(0, d->fTextures[texIdx]->width()),
                                        d->fRandom->nextRangeU(0, d->fTextures[texIdx]->height()),
                                        d->fRandom->nextRangeU(0, d->fTextures[texIdx]->width()),
                                        d->fRandom->nextRangeU(0, d->fTextures[texIdx]->height()));
     GrTextureDomain::Mode tileMode =
             static_cast<GrTextureDomain::Mode>(d->fRandom->nextRangeU(0, 2));
     bool convolveAlpha = d->fRandom->nextBool();
-    return GrMatrixConvolutionEffect::Create(d->fTextures[texIdx],
-                                             bounds,
-                                             kernelSize,
-                                             kernel.get(),
-                                             gain,
-                                             bias,
-                                             kernelOffset,
-                                             tileMode,
-                                             convolveAlpha);
+    return GrMatrixConvolutionEffect::Make(d->fTextures[texIdx],
+                                           bounds,
+                                           kernelSize,
+                                           kernel.get(),
+                                           gain,
+                                           bias,
+                                           kernelOffset,
+                                           tileMode,
+                                           convolveAlpha);
 }