sk_sp for gpu.

src/effects/SkXfermodeImageFilter.cpp

 /*
  * Copyright 2013 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkXfermodeImageFilter.h"
 
 #include "SkCanvas.h"
@@ skipping 162 matching lines @@
     if (background) {
         backgroundTex = background->asTextureRef(context);
     }
 
     if (foreground) {
         foregroundTex = foreground->asTextureRef(context);
     }
 
     GrPaint paint;
     // SRGBTODO: AllowSRGBInputs?
-    SkAutoTUnref<const GrFragmentProcessor> bgFP;
+    sk_sp<GrFragmentProcessor> bgFP;
 
     if (backgroundTex) {
         SkMatrix backgroundMatrix;
         backgroundMatrix.setIDiv(backgroundTex->width(), backgroundTex->height());
         backgroundMatrix.preTranslate(SkIntToScalar(-backgroundOffset.fX),
                                       SkIntToScalar(-backgroundOffset.fY));
-        bgFP.reset(GrTextureDomainEffect::Create(
+        bgFP = GrTextureDomainEffect::Make(
                             backgroundTex.get(), backgroundMatrix,
                             GrTextureDomain::MakeTexelDomain(backgroundTex.get(),
                                                              background->subset()),
                             GrTextureDomain::kDecal_Mode,
-                            GrTextureParams::kNone_FilterMode));
+                            GrTextureParams::kNone_FilterMode);
     } else {
-        bgFP.reset(GrConstColorProcessor::Create(GrColor_TRANSPARENT_BLACK,
-                                                 GrConstColorProcessor::kIgnore_InputMode));
+        bgFP = GrConstColorProcessor::Make(GrColor_TRANSPARENT_BLACK,
+                                             GrConstColorProcessor::kIgnore_InputMode);
     }
 
     if (foregroundTex) {
         SkMatrix foregroundMatrix;
         foregroundMatrix.setIDiv(foregroundTex->width(), foregroundTex->height());
         foregroundMatrix.preTranslate(SkIntToScalar(-foregroundOffset.fX),
                                       SkIntToScalar(-foregroundOffset.fY));
 
-        SkAutoTUnref<const GrFragmentProcessor> foregroundFP;
+        sk_sp<GrFragmentProcessor> foregroundFP;
 
-        foregroundFP.reset(GrTextureDomainEffect::Create(
+        foregroundFP = GrTextureDomainEffect::Make(
                             foregroundTex.get(), foregroundMatrix,
                             GrTextureDomain::MakeTexelDomain(foregroundTex.get(), 
                                                              foreground->subset()),
                             GrTextureDomain::kDecal_Mode,
-                            GrTextureParams::kNone_FilterMode));
+                            GrTextureParams::kNone_FilterMode);
 
-        paint.addColorFragmentProcessor(foregroundFP.get());
+        paint.addColorFragmentProcessor(std::move(foregroundFP));
 
         // A null fMode is interpreted to mean kSrcOver_Mode (to match raster).
         SkAutoTUnref<SkXfermode> mode(SkSafeRef(fMode.get()));
         if (!mode) {
             // It would be awesome to use SkXfermode::Create here but it knows better
             // than us and won't return a kSrcOver_Mode SkXfermode. That means we
             // have to get one the hard way.
             struct ProcCoeff rec;
             rec.fProc = SkXfermode::GetProc(SkXfermode::kSrcOver_Mode);
             SkXfermode::ModeAsCoeff(SkXfermode::kSrcOver_Mode, &rec.fSC, &rec.fDC);
 
             mode.reset(new SkProcCoeffXfermode(rec, SkXfermode::kSrcOver_Mode));
         }
 
-        sk_sp<const GrFragmentProcessor> xferFP(mode->getFragmentProcessorForImageFilter(bgFP));
+        sk_sp<GrFragmentProcessor> xferFP(
+            mode->makeFragmentProcessorForImageFilter(std::move(bgFP)));
 
         // A null 'xferFP' here means kSrc_Mode was used in which case we can just proceed
         if (xferFP) {
-            paint.addColorFragmentProcessor(xferFP.get());
+            paint.addColorFragmentProcessor(std::move(xferFP));
         }
     } else {
-        paint.addColorFragmentProcessor(bgFP);
+        paint.addColorFragmentProcessor(std::move(bgFP));
     }
 
     paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
 
     sk_sp<GrDrawContext> drawContext(context->newDrawContext(SkBackingFit::kApprox,
                                                              bounds.width(), bounds.height(),
                                                              kSkia8888_GrPixelConfig));
     if (!drawContext) {
         return nullptr;
     }
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
     drawContext->drawRect(GrNoClip(), paint, matrix, SkRect::Make(bounds));
 
     return SkSpecialImage::MakeFromGpu(SkIRect::MakeWH(bounds.width(), bounds.height()),
                                        kNeedNewImageUniqueID_SpecialImage,
                                        drawContext->asTexture());
 }
 
 #endif