Start using RenderTargetProxy (omnibus)

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 "GrRenderTargetContext.h"
 #include "GrPaint.h"
 #include "GrTextureProvider.h"
+#include "GrTextureProxy.h"
 
 namespace {
     using MakeFPProc = sk_sp<GrFragmentProcessor> (*)(sk_sp<GrFragmentProcessor>,
                                                       SkYUVColorSpace colorSpace);
 };
 
 static bool convert_texture(GrTexture* src, GrRenderTargetContext* dst, int dstW, int dstH,
                             SkYUVColorSpace colorSpace, MakeFPProc proc) {
 
     SkScalar xScale = SkIntToScalar(src->width()) / dstW / src->width();
@@ skipping 115 matching lines @@
                 if (!convert_texture(texture, vRenderTargetContext.get(),
                                      sizes[2].fWidth, sizes[2].fHeight,
                                      colorSpace, GrYUVEffect::MakeRGBToV)) {
                     return false;
                 }
             }
         }
 
         if (yuvRenderTargetContext) {
             SkASSERT(sizes[0] == sizes[1] && sizes[1] == sizes[2]);
-            sk_sp<GrTexture> yuvTex(yuvRenderTargetContext->asTexture());
+            sk_sp<GrTextureProxy> yuvTex(yuvRenderTargetContext->asDeferredTexture());
             SkASSERT(yuvTex);
             SkISize yuvSize = sizes[0];
             // We have no kRGB_888 pixel format, so readback rgba and then copy three channels.
             SkAutoSTMalloc<128 * 128, uint32_t> tempYUV(yuvSize.fWidth * yuvSize.fHeight);
             if (!yuvTex->readPixels(0, 0, yuvSize.fWidth, yuvSize.fHeight,
                                     kRGBA_8888_GrPixelConfig, tempYUV.get(), 0)) {
                 return false;
             }
             size_t yRowBytes = rowBytes[0] ? rowBytes[0] : yuvSize.fWidth;
             size_t uRowBytes = rowBytes[1] ? rowBytes[1] : yuvSize.fWidth;
@@ skipping 12 matching lines @@
                     uint8_t* uLoc = ((uint8_t*)planes[1]) + j * uRowBytes + i;
                     uint8_t* vLoc = ((uint8_t*)planes[2]) + j * vRowBytes + i;
                     *yLoc = y;
                     *uLoc = u;
                     *vLoc = v;
                 }
             }
             return true;
         } else {
             SkASSERT(yRenderTargetContext);
-            sk_sp<GrTexture> yTex(yRenderTargetContext->asTexture());
+            sk_sp<GrTextureProxy> yTex(yRenderTargetContext->asDeferredTexture());
             SkASSERT(yTex);
             if (!yTex->readPixels(0, 0, sizes[0].fWidth, sizes[0].fHeight,
                                   kAlpha_8_GrPixelConfig, planes[0], rowBytes[0])) {
                 return false;
             }
             if (uvRenderTargetContext) {
                 SkASSERT(sizes[1].fWidth == sizes[2].fWidth);
-                sk_sp<GrTexture> uvTex(uvRenderTargetContext->asTexture());
+                sk_sp<GrTextureProxy> uvTex(uvRenderTargetContext->asDeferredTexture());
                 SkASSERT(uvTex);
                 SkISize uvSize = sizes[1];
                 // We have no kRG_88 pixel format, so readback rgba and then copy two channels.
                 SkAutoSTMalloc<128 * 128, uint32_t> tempUV(uvSize.fWidth * uvSize.fHeight);
                 if (!uvTex->readPixels(0, 0, uvSize.fWidth, uvSize.fHeight,
                                        kRGBA_8888_GrPixelConfig, tempUV.get(), 0)) {
                     return false;
                 }
 
                 size_t uRowBytes = rowBytes[1] ? rowBytes[1] : uvSize.fWidth;
                 size_t vRowBytes = rowBytes[2] ? rowBytes[2] : uvSize.fWidth;
                 if (uRowBytes < (size_t)uvSize.fWidth || vRowBytes < (size_t)uvSize.fWidth) {
                     return false;
                 }
                 for (int j = 0; j < uvSize.fHeight; ++j) {
                     for (int i = 0; i < uvSize.fWidth; ++i) {
                         // These writes could surely be made more efficient.
                         uint32_t u = GrColorUnpackR(tempUV.get()[j * uvSize.fWidth + i]);
                         uint32_t v = GrColorUnpackG(tempUV.get()[j * uvSize.fWidth + i]);
                         uint8_t* uLoc = ((uint8_t*)planes[1]) + j * uRowBytes + i;
                         uint8_t* vLoc = ((uint8_t*)planes[2]) + j * vRowBytes + i;
                         *uLoc = u;
                         *vLoc = v;
                     }
                 }
                 return true;
             } else {
                 SkASSERT(uRenderTargetContext && vRenderTargetContext);
-                sk_sp<GrTexture> tex(uRenderTargetContext->asTexture());
+                sk_sp<GrTextureProxy> tex(uRenderTargetContext->asDeferredTexture());
                 SkASSERT(tex);
                 if (!tex->readPixels(0, 0, sizes[1].fWidth, sizes[1].fHeight,
                                      kAlpha_8_GrPixelConfig, planes[1], rowBytes[1])) {
                     return false;
                 }
-                tex = vRenderTargetContext->asTexture();
+                tex = sk_ref_sp(vRenderTargetContext->asDeferredTexture());
                 SkASSERT(tex);
                 if (!tex->readPixels(0, 0, sizes[2].fWidth, sizes[2].fHeight,
                                      kAlpha_8_GrPixelConfig, planes[2], rowBytes[2])) {
                     return false;
                 }
                 return true;
             }
         }
     }
     return false;
 }