sk_sp for gpu.

src/gpu/GrTextureParamsAdjuster.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTextureParamsAdjuster.h"
 
 #include "GrCaps.h"
@@ skipping 75 matching lines @@
         (subset->width() != copyParams.fWidth || subset->height() != copyParams.fHeight)) {
         SkRect domain;
         domain.fLeft = (subset->fLeft + 0.5f) * sx;
         domain.fTop = (subset->fTop + 0.5f)* sy;
         domain.fRight = (subset->fRight - 0.5f) * sx;
         domain.fBottom = (subset->fBottom - 0.5f) * sy;
         // This would cause us to read values from outside the subset. Surely, the caller knows
         // better!
         SkASSERT(copyParams.fFilter != GrTextureParams::kMipMap_FilterMode);
         paint.addColorFragmentProcessor(
-            GrTextureDomainEffect::Create(inputTexture, SkMatrix::I(), domain,
-                                          GrTextureDomain::kClamp_Mode,
-                                          copyParams.fFilter))->unref();
+            GrTextureDomainEffect::Make(inputTexture, SkMatrix::I(), domain,
+                                        GrTextureDomain::kClamp_Mode,
+                                        copyParams.fFilter));
     } else {
         GrTextureParams params(SkShader::kClamp_TileMode, copyParams.fFilter);
         paint.addColorTextureProcessor(inputTexture, SkMatrix::I(), params);
     }
     paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
 
     SkRect localRect;
     if (subset) {
         localRect = SkRect::Make(*subset);
         localRect.fLeft *= sx;
@@ skipping 226 matching lines @@
     if (domainRect->fTop > domainRect->fBottom) {
         domainRect->fTop = domainRect->fBottom = SkScalarAve(domainRect->fTop, domainRect->fBottom);
     }
     domainRect->fLeft /= texW;
     domainRect->fTop /= texH;
     domainRect->fRight /= texW;
     domainRect->fBottom /= texH;
     return kDomain_DomainMode;
 }
 
-static const GrFragmentProcessor* create_fp_for_domain_and_filter(
+static sk_sp<GrFragmentProcessor> create_fp_for_domain_and_filter(
                                         GrTexture* texture,
                                         const SkMatrix& textureMatrix,
                                         DomainMode domainMode,
                                         const SkRect& domain,
                                         const GrTextureParams::FilterMode* filterOrNullForBicubic) {
     SkASSERT(kTightCopy_DomainMode != domainMode);
     if (filterOrNullForBicubic) {
         if (kDomain_DomainMode == domainMode) {
-            return GrTextureDomainEffect::Create(texture, textureMatrix, domain,
-                                                 GrTextureDomain::kClamp_Mode,
-                                                 *filterOrNullForBicubic);
+            return GrTextureDomainEffect::Make(texture, textureMatrix, domain,
+                                               GrTextureDomain::kClamp_Mode,
+                                               *filterOrNullForBicubic);
         } else {
             GrTextureParams params(SkShader::kClamp_TileMode, *filterOrNullForBicubic);
-            return GrSimpleTextureEffect::Create(texture, textureMatrix, params);
+            return GrSimpleTextureEffect::Make(texture, textureMatrix, params);
         }
     } else {
         if (kDomain_DomainMode == domainMode) {
-            return GrBicubicEffect::Create(texture, textureMatrix, domain);
+            return GrBicubicEffect::Make(texture, textureMatrix, domain);
         } else {
             static const SkShader::TileMode kClampClamp[] =
                 { SkShader::kClamp_TileMode, SkShader::kClamp_TileMode };
-            return GrBicubicEffect::Create(texture, textureMatrix, kClampClamp);
+            return GrBicubicEffect::Make(texture, textureMatrix, kClampClamp);
         }
     }
 }
 
-const GrFragmentProcessor* GrTextureAdjuster::createFragmentProcessor(
+sk_sp<GrFragmentProcessor> GrTextureAdjuster::createFragmentProcessor(
                                         const SkMatrix& origTextureMatrix,
                                         const SkRect& origConstraintRect,
                                         FilterConstraint filterConstraint,
                                         bool coordsLimitedToConstraintRect,
                                         const GrTextureParams::FilterMode* filterOrNullForBicubic,
                                         SkSourceGammaTreatment gammaTreatment) {
 
     SkMatrix textureMatrix = origTextureMatrix;
     const SkIRect* contentArea = this->contentAreaOrNull();
     // Convert the constraintRect to be relative to the texture rather than the content area so
@@ skipping 77 matching lines @@
         return nullptr;
     }
 
     if (copyKey.isValid()) {
         fContext->textureProvider()->assignUniqueKeyToTexture(copyKey, result);
         this->didCacheCopy(copyKey);
     }
     return result;
 }
 
-const GrFragmentProcessor* GrTextureMaker::createFragmentProcessor(
+sk_sp<GrFragmentProcessor> GrTextureMaker::createFragmentProcessor(
                                         const SkMatrix& textureMatrix,
                                         const SkRect& constraintRect,
                                         FilterConstraint filterConstraint,
                                         bool coordsLimitedToConstraintRect,
                                         const GrTextureParams::FilterMode* filterOrNullForBicubic,
                                         SkSourceGammaTreatment gammaTreatment) {
 
     const GrTextureParams::FilterMode* fmForDetermineDomain = filterOrNullForBicubic;
     if (filterOrNullForBicubic && GrTextureParams::kMipMap_FilterMode == *filterOrNullForBicubic &&
         kYes_FilterConstraint == filterConstraint) {
@@ skipping 30 matching lines @@
 }
 
 GrTexture* GrTextureMaker::generateTextureForParams(const CopyParams& copyParams, bool willBeMipped,
                                                     SkSourceGammaTreatment gammaTreatment) {
     SkAutoTUnref<GrTexture> original(this->refOriginalTexture(willBeMipped, gammaTreatment));
     if (!original) {
         return nullptr;
     }
     return copy_on_gpu(original, nullptr, copyParams);
 }