sk_sp for gpu.

src/gpu/GrTextureToYUVPlanes.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTextureToYUVPlanes.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "effects/GrYUVEffect.h"
 #include "GrClip.h"
 #include "GrContext.h"
 #include "GrDrawContext.h"
 #include "GrPaint.h"
 #include "GrTextureProvider.h"
 
 namespace {
-    using CreateFPProc = const GrFragmentProcessor* (*)(const GrFragmentProcessor*,
-                                                        SkYUVColorSpace colorSpace);
+    using MakeFPProc = sk_sp<GrFragmentProcessor> (*)(sk_sp<GrFragmentProcessor>,
+                                                      SkYUVColorSpace colorSpace);
 };
 
 static bool convert_texture(GrTexture* src, GrDrawContext* dst, int dstW, int dstH,
-                            SkYUVColorSpace colorSpace, CreateFPProc proc) {
+                            SkYUVColorSpace colorSpace, MakeFPProc proc) {
 
     SkScalar xScale = SkIntToScalar(src->width()) / dstW / src->width();
     SkScalar yScale = SkIntToScalar(src->height()) / dstH / src->height();
     GrTextureParams::FilterMode filter;
     if (dstW == src->width() && dstW == src->height()) {
         filter = GrTextureParams::kNone_FilterMode;
     } else {
         filter = GrTextureParams::kBilerp_FilterMode;
     }
 
-    SkAutoTUnref<const GrFragmentProcessor> fp(
-            GrSimpleTextureEffect::Create(src, SkMatrix::MakeScale(xScale, yScale), filter));
+    sk_sp<GrFragmentProcessor> fp(
+            GrSimpleTextureEffect::Make(src, SkMatrix::MakeScale(xScale, yScale), filter));
     if (!fp) {
         return false;
     }
-    fp.reset(proc(fp, colorSpace));
+    fp = proc(std::move(fp), colorSpace);
     if (!fp) {
         return false;
     }
     GrPaint paint;
     paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
-    paint.addColorFragmentProcessor(fp);
+    paint.addColorFragmentProcessor(std::move(fp));
     dst->drawRect(GrNoClip(), paint, SkMatrix::I(), SkRect::MakeIWH(dstW, dstH));
     return true;
 }
 
 bool GrTextureToYUVPlanes(GrTexture* texture, const SkISize sizes[3], void* const planes[3],
                           const size_t rowBytes[3], SkYUVColorSpace colorSpace) {
     if (GrContext* context = texture->getContext()) {
         // Depending on the relative sizes of the y, u, and v planes we may do 1 to 3 draws/
         // readbacks.
         sk_sp<GrDrawContext> yuvDrawContext;
@@ skipping 44 matching lines @@
                 if (!uDrawContext || !vDrawContext) {
                     return false;
                 }
             }
         }
 
         // Do all the draws before any readback.
         if (yuvDrawContext) {
             if (!convert_texture(texture, yuvDrawContext.get(),
                                  sizes[0].fWidth, sizes[0].fHeight,
-                                 colorSpace, GrYUVEffect::CreateRGBToYUV)) {
+                                 colorSpace, GrYUVEffect::MakeRGBToYUV)) {
                 return false;
             }
         } else {
             SkASSERT(yDrawContext);
             if (!convert_texture(texture, yDrawContext.get(),
                                  sizes[0].fWidth, sizes[0].fHeight,
-                                 colorSpace, GrYUVEffect::CreateRGBToY)) {
+                                 colorSpace, GrYUVEffect::MakeRGBToY)) {
                 return false;
             }
             if (uvDrawContext) {
                 if (!convert_texture(texture, uvDrawContext.get(),
                                      sizes[1].fWidth, sizes[1].fHeight,
-                                     colorSpace,  GrYUVEffect::CreateRGBToUV)) {
+                                     colorSpace,  GrYUVEffect::MakeRGBToUV)) {
                     return false;
                 }
             } else {
                 SkASSERT(uDrawContext && vDrawContext);
                 if (!convert_texture(texture, uDrawContext.get(),
                                      sizes[1].fWidth, sizes[1].fHeight,
-                                     colorSpace, GrYUVEffect::CreateRGBToU)) {
+                                     colorSpace, GrYUVEffect::MakeRGBToU)) {
                     return false;
                 }
                 if (!convert_texture(texture, vDrawContext.get(),
                                      sizes[2].fWidth, sizes[2].fHeight,
-                                     colorSpace, GrYUVEffect::CreateRGBToV)) {
+                                     colorSpace, GrYUVEffect::MakeRGBToV)) {
                     return false;
                 }
             }
         }
 
         if (yuvDrawContext) {
             SkASSERT(sizes[0] == sizes[1] && sizes[1] == sizes[2]);
             sk_sp<GrTexture> yuvTex(yuvDrawContext->asTexture());
             SkASSERT(yuvTex);
             SkISize yuvSize = sizes[0];
@@ skipping 75 matching lines @@
                 if (!tex->readPixels(0, 0, sizes[2].fWidth, sizes[2].fHeight,
                                      kAlpha_8_GrPixelConfig, planes[2], rowBytes[2])) {
                     return false;
                 }
                 return true;
             }
         }
     }
     return false;
 }