Defer more renderTargetContexts in the GPU image filter paths - take 2

src/core/SkGpuBlurUtils.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuBlurUtils.h"
 
 #include "SkRect.h"
@@ skipping 211 matching lines @@
              kRGBA_8888_GrPixelConfig == srcTexture->config() ||
              kSRGBA_8888_GrPixelConfig == srcTexture->config() ||
              kSBGRA_8888_GrPixelConfig == srcTexture->config() ||
              kRGBA_half_GrPixelConfig == srcTexture->config() ||
              kAlpha_8_GrPixelConfig == srcTexture->config());
 
     const int width = dstBounds.width();
     const int height = dstBounds.height();
     const GrPixelConfig config = srcTexture->config();
 
-    sk_sp<GrRenderTargetContext> dstRenderTargetContext(context->makeRenderTargetContext(
+    sk_sp<GrRenderTargetContext> dstRenderTargetContext(context->makeDeferredRenderTargetContext(
         fit, width, height, config, colorSpace, 0, kDefault_GrSurfaceOrigin));
     if (!dstRenderTargetContext) {
         return nullptr;
     }
 
     // For really small blurs (certainly no wider than 5x5 on desktop gpus) it is faster to just
     // launch a single non separable kernel vs two launches
     if (sigmaX > 0.0f && sigmaY > 0.0f &&
             (2 * radiusX + 1) * (2 * radiusY + 1) <= MAX_KERNEL_SIZE) {
         // We shouldn't be scaling because this is a small size blur
         SkASSERT((1 == scaleFactorX) && (1 == scaleFactorY));
 
         convolve_gaussian_2d(dstRenderTargetContext.get(), clip, localDstBounds, srcOffset,
                              srcTexture.get(), radiusX, radiusY, sigmaX, sigmaY, srcBounds);
 
         return dstRenderTargetContext;
     } 
 
-    sk_sp<GrRenderTargetContext> tmpRenderTargetContext(context->makeRenderTargetContext(
+    sk_sp<GrRenderTargetContext> tmpRenderTargetContext(context->makeDeferredRenderTargetContext(
         fit, width, height, config, colorSpace, 0, kDefault_GrSurfaceOrigin));
     if (!tmpRenderTargetContext) {
         return nullptr;
     }
 
     sk_sp<GrRenderTargetContext> srcRenderTargetContext;
 
     SkASSERT(SkIsPow2(scaleFactorX) && SkIsPow2(scaleFactorY));
 
     for (int i = 1; i < scaleFactorX || i < scaleFactorY; i *= 2) {
         GrPaint paint;
         paint.setGammaCorrect(dstRenderTargetContext->isGammaCorrect());
+        // TODO: this matrix relies on the final instantiated size of the texture. This
+        // will have to be deferred for TextureProxys
         SkMatrix matrix;
         matrix.setIDiv(srcTexture->width(), srcTexture->height());
         SkIRect dstRect(srcRect);
         if (srcBounds && i == 1) {
             SkRect domain;
             matrix.mapRect(&domain, SkRect::Make(*srcBounds));
             domain.inset((i < scaleFactorX) ? SK_ScalarHalf / srcTexture->width() : 0.0f,
                          (i < scaleFactorY) ? SK_ScalarHalf / srcTexture->height() : 0.0f);
             sk_sp<GrFragmentProcessor> fp(GrTextureDomainEffect::Make(
                                                         srcTexture.get(),
@@ skipping 11 matching lines @@
         }
         paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
         shrink_irect_by_2(&dstRect, i < scaleFactorX, i < scaleFactorY);
 
         dstRenderTargetContext->fillRectToRect(clip, paint, SkMatrix::I(),
                                                SkRect::Make(dstRect), SkRect::Make(srcRect));
 
         srcRenderTargetContext = dstRenderTargetContext;
         srcRect = dstRect;
         srcTexture = srcRenderTargetContext->asTexture();
+        if (!srcTexture) {
+            return nullptr;
+        }
         dstRenderTargetContext.swap(tmpRenderTargetContext);
         localSrcBounds = srcRect;
     }
 
     srcRect = localDstBounds;
     scale_irect_roundout(&srcRect, 1.0f / scaleFactorX, 1.0f / scaleFactorY);
     if (sigmaX > 0.0f) {
         if (scaleFactorX > 1) {
             SkASSERT(srcRenderTargetContext);
 
             // Clear out a radius to the right of the srcRect to prevent the
             // X convolution from reading garbage.
             clearRect = SkIRect::MakeXYWH(srcRect.fRight, srcRect.fTop,
                                           radiusX, srcRect.height());
             srcRenderTargetContext->clear(&clearRect, 0x0, false);
         }
 
         convolve_gaussian(dstRenderTargetContext.get(), clip, srcRect,
                           srcTexture.get(), Gr1DKernelEffect::kX_Direction, radiusX, sigmaX,
                           srcBounds, srcOffset);
         srcRenderTargetContext = dstRenderTargetContext;
         srcTexture = srcRenderTargetContext->asTexture();
+        if (!srcTexture) {
+            return nullptr;
+        }
         srcRect.offsetTo(0, 0);
         dstRenderTargetContext.swap(tmpRenderTargetContext);
         localSrcBounds = srcRect;
         srcOffset.set(0, 0);
     }
 
     if (sigmaY > 0.0f) {
         if (scaleFactorY > 1 || sigmaX > 0.0f) {
             SkASSERT(srcRenderTargetContext);
 
@@ skipping 16 matching lines @@
     SkASSERT(srcRenderTargetContext);
     srcTexture = nullptr;     // we don't use this from here on out
 
     if (scaleFactorX > 1 || scaleFactorY > 1) {
         // Clear one pixel to the right and below, to accommodate bilinear upsampling.
         clearRect = SkIRect::MakeXYWH(srcRect.fLeft, srcRect.fBottom, srcRect.width() + 1, 1);
         srcRenderTargetContext->clear(&clearRect, 0x0, false);
         clearRect = SkIRect::MakeXYWH(srcRect.fRight, srcRect.fTop, 1, srcRect.height());
         srcRenderTargetContext->clear(&clearRect, 0x0, false);
 
-        SkMatrix matrix;
-        matrix.setIDiv(srcRenderTargetContext->width(), srcRenderTargetContext->height());
-
         GrPaint paint;
         paint.setGammaCorrect(dstRenderTargetContext->isGammaCorrect());
         // FIXME:  this should be mitchell, not bilinear.
         GrSamplerParams params(SkShader::kClamp_TileMode, GrSamplerParams::kBilerp_FilterMode);
         sk_sp<GrTexture> tex(srcRenderTargetContext->asTexture());
+        if (!tex) {
+            return nullptr;
+        }
+
+        // TODO: this matrix relies on the final instantiated size of the texture. This
+        // will have to be deferred for TextureProxys
+        SkMatrix matrix;
+        matrix.setIDiv(tex->width(), tex->height());
+
         paint.addColorTextureProcessor(tex.get(), nullptr, matrix, params);
         paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
 
         SkIRect dstRect(srcRect);
         scale_irect(&dstRect, scaleFactorX, scaleFactorY);
 
         dstRenderTargetContext->fillRectToRect(clip, paint, SkMatrix::I(),
                                                SkRect::Make(dstRect), SkRect::Make(srcRect));
 
         srcRenderTargetContext = dstRenderTargetContext;
         srcRect = dstRect;
         dstRenderTargetContext.swap(tmpRenderTargetContext);
     }
 
     return srcRenderTargetContext;
 }
 
 }
 
 #endif