sk_sp for gpu.

src/gpu/GrContext.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrContext.h"
 #include "GrContextOptions.h"
 #include "GrDrawingManager.h"
@@ skipping 299 matching lines @@
         tempTexture.reset(
             this->textureProvider()->createApproxTexture(tempDrawInfo.fTempSurfaceDesc));
         if (!tempTexture && GrGpu::kRequireDraw_DrawPreference == drawPreference) {
             return false;
         }
     }
 
     // temp buffer for doing sw premul conversion, if needed.
     SkAutoSTMalloc<128 * 128, uint32_t> tmpPixels(0);
     if (tempTexture) {
-        SkAutoTUnref<const GrFragmentProcessor> fp;
+        sk_sp<GrFragmentProcessor> fp;
         SkMatrix textureMatrix;
         textureMatrix.setIDiv(tempTexture->width(), tempTexture->height());
         if (applyPremulToSrc) {
-            fp.reset(this->createUPMToPMEffect(tempTexture, tempDrawInfo.fSwizzle,
-                                               textureMatrix));
+            fp = this->createUPMToPMEffect(tempTexture, tempDrawInfo.fSwizzle, textureMatrix);
             // If premultiplying was the only reason for the draw, fall back to a straight write.
             if (!fp) {
                 if (GrGpu::kCallerPrefersDraw_DrawPreference == drawPreference) {
                     tempTexture.reset(nullptr);
                 }
             } else {
                 applyPremulToSrc = false;
             }
         }
         if (tempTexture) {
             if (!fp) {
-                fp.reset(GrConfigConversionEffect::Create(tempTexture, tempDrawInfo.fSwizzle,
-                    GrConfigConversionEffect::kNone_PMConversion, textureMatrix));
+                fp = GrConfigConversionEffect::Make(tempTexture, tempDrawInfo.fSwizzle,
+                                                    GrConfigConversionEffect::kNone_PMConversion,
+                                                    textureMatrix);
                 if (!fp) {
                     return false;
                 }
             }
             GrRenderTarget* renderTarget = surface->asRenderTarget();
             SkASSERT(renderTarget);
             if (tempTexture->surfacePriv().hasPendingIO()) {
                 this->flush();
             }
             if (applyPremulToSrc) {
@@ skipping 12 matching lines @@
                                    rowBytes)) {
                 return false;
             }
             SkMatrix matrix;
             matrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
             sk_sp<GrDrawContext> drawContext(this->drawContext(sk_ref_sp(renderTarget)));
             if (!drawContext) {
                 return false;
             }
             GrPaint paint;
-            paint.addColorFragmentProcessor(fp);
+            paint.addColorFragmentProcessor(std::move(fp));
             paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
             paint.setAllowSRGBInputs(true);
             SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
             drawContext->drawRect(GrNoClip(), paint, matrix, rect, nullptr);
 
             if (kFlushWrites_PixelOp & pixelOpsFlags) {
                 this->flushSurfaceWrites(surface);
             }
         }
     }
@@ skipping 72 matching lines @@
         if (tempDrawInfo.fUseExactScratch) {
             temp.reset(this->textureProvider()->createTexture(tempDrawInfo.fTempSurfaceDesc,
                                                               SkBudgeted::kYes));
         } else {
             temp.reset(this->textureProvider()->createApproxTexture(tempDrawInfo.fTempSurfaceDesc));
         }
         if (temp) {
             SkMatrix textureMatrix;
             textureMatrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
             textureMatrix.postIDiv(src->width(), src->height());
-            SkAutoTUnref<const GrFragmentProcessor> fp;
+            sk_sp<GrFragmentProcessor> fp;
             if (unpremul) {
-                fp.reset(this->createPMToUPMEffect(src->asTexture(), tempDrawInfo.fSwizzle,
-                    textureMatrix));
+                fp = this->createPMToUPMEffect(src->asTexture(), tempDrawInfo.fSwizzle,
+                                               textureMatrix);
                 if (fp) {
                     unpremul = false; // we no longer need to do this on CPU after the read back.
                 } else if (GrGpu::kCallerPrefersDraw_DrawPreference == drawPreference) {
                     // We only wanted to do the draw in order to perform the unpremul so don't
                     // bother.
                     temp.reset(nullptr);
                 }
             }
             if (!fp && temp) {
-                fp.reset(GrConfigConversionEffect::Create(src->asTexture(), tempDrawInfo.fSwizzle,
-                    GrConfigConversionEffect::kNone_PMConversion, textureMatrix));
+                fp = GrConfigConversionEffect::Make(src->asTexture(), tempDrawInfo.fSwizzle,
+                                                    GrConfigConversionEffect::kNone_PMConversion,
+                                                    textureMatrix);
             }
             if (fp) {
                 GrPaint paint;
-                paint.addColorFragmentProcessor(fp);
+                paint.addColorFragmentProcessor(std::move(fp));
                 paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
                 paint.setAllowSRGBInputs(true);
                 SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
                 sk_sp<GrDrawContext> drawContext(
                                             this->drawContext(sk_ref_sp(temp->asRenderTarget())));
                 drawContext->drawRect(GrNoClip(), paint, SkMatrix::I(), rect, nullptr);
                 surfaceToRead.reset(SkRef(temp.get()));
                 left = 0;
                 top = 0;
                 didTempDraw = true;
@@ skipping 50 matching lines @@
     SkSurfaceProps props(SkSurfaceProps::kGammaCorrect_Flag,
                          SkSurfaceProps::kLegacyFontHost_InitType);
     sk_sp<GrDrawContext> drawContext(this->drawContext(sk_ref_sp(dst), &props));
     if (!drawContext) {
         return false;
     }
 
     GrPaint paint;
     paint.addColorTextureProcessor(src, GrCoordTransform::MakeDivByTextureWHMatrix(src));
     if (!SkScalarNearlyEqual(gamma, 1.0f)) {
-        paint.addColorFragmentProcessor(GrGammaEffect::Create(gamma))->unref();
+        paint.addColorFragmentProcessor(GrGammaEffect::Make(gamma));
     }
     paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
     paint.setGammaCorrect(true);
 
     SkRect rect;
     src->getBoundsRect(&rect);
     drawContext->drawRect(GrNoClip(), paint, SkMatrix::I(), rect);
 
     this->flushSurfaceWrites(dst);
     return true;
@@ skipping 138 matching lines @@
     ASSERT_SINGLE_OWNER
     if (SkToBool(kUnpremul_PixelOpsFlag & flags)) {
         SkAutoMutexAcquire ama(fTestPMConversionsMutex);
         if (!fDidTestPMConversions) {
             test_pm_conversions(this, &fPMToUPMConversion, &fUPMToPMConversion);
             fDidTestPMConversions = true;
         }
     }
 }
 
-const GrFragmentProcessor* GrContext::createPMToUPMEffect(GrTexture* texture,
+sk_sp<GrFragmentProcessor> GrContext::createPMToUPMEffect(GrTexture* texture,
                                                           const GrSwizzle& swizzle,
                                                           const SkMatrix& matrix) const {
     ASSERT_SINGLE_OWNER
     // We should have already called this->testPMConversionsIfNecessary().
     SkASSERT(fDidTestPMConversions);
     GrConfigConversionEffect::PMConversion pmToUPM =
         static_cast<GrConfigConversionEffect::PMConversion>(fPMToUPMConversion);
     if (GrConfigConversionEffect::kNone_PMConversion != pmToUPM) {
-        return GrConfigConversionEffect::Create(texture, swizzle, pmToUPM, matrix);
+        return GrConfigConversionEffect::Make(texture, swizzle, pmToUPM, matrix);
     } else {
         return nullptr;
     }
 }
 
-const GrFragmentProcessor* GrContext::createUPMToPMEffect(GrTexture* texture,
+sk_sp<GrFragmentProcessor> GrContext::createUPMToPMEffect(GrTexture* texture,
                                                           const GrSwizzle& swizzle,
                                                           const SkMatrix& matrix) const {
     ASSERT_SINGLE_OWNER
     // We should have already called this->testPMConversionsIfNecessary().
     SkASSERT(fDidTestPMConversions);
     GrConfigConversionEffect::PMConversion upmToPM =
         static_cast<GrConfigConversionEffect::PMConversion>(fUPMToPMConversion);
     if (GrConfigConversionEffect::kNone_PMConversion != upmToPM) {
-        return GrConfigConversionEffect::Create(texture, swizzle, upmToPM, matrix);
+        return GrConfigConversionEffect::Make(texture, swizzle, upmToPM, matrix);
     } else {
         return nullptr;
     }
 }
 
 bool GrContext::didFailPMUPMConversionTest() const {
     ASSERT_SINGLE_OWNER
     // We should have already called this->testPMConversionsIfNecessary().
     SkASSERT(fDidTestPMConversions);
     // The PM<->UPM tests fail or succeed together so we only need to check one.
@@ skipping 16 matching lines @@
     ASSERT_SINGLE_OWNER
     fResourceCache->setLimits(maxTextures, maxTextureBytes);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
     ASSERT_SINGLE_OWNER
     fResourceCache->dumpMemoryStatistics(traceMemoryDump);
 }