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

src/gpu/GrBlurUtils.cpp

Index: src/gpu/GrBlurUtils.cpp
diff --git a/src/gpu/GrBlurUtils.cpp b/src/gpu/GrBlurUtils.cpp
index 58d12af1788e63f204bea8f8add07b9e3d3955ef..97fa623e2f976e232a4abff7d655a11d75af318c 100644
--- a/src/gpu/GrBlurUtils.cpp
+++ b/src/gpu/GrBlurUtils.cpp
@@ -13,6 +13,7 @@
 #include "effects/GrSimpleTextureEffect.h"
 #include "GrStyle.h"
 #include "GrTexture.h"
+#include "GrTextureProxy.h"
 #include "GrTextureProvider.h"
 #include "SkDraw.h"
 #include "SkGrPriv.h"
@@ -92,25 +93,25 @@ static bool sw_draw_with_mask_filter(GrRenderTargetContext* renderTargetContext,
 }
 
 // Create a mask of 'devPath' and place the result in 'mask'.
-static sk_sp<GrTexture> create_mask_GPU(GrContext* context,
-                                        const SkIRect& maskRect,
-                                        const SkPath& devPath,
-                                        SkStrokeRec::InitStyle fillOrHairline,
-                                        bool doAA,
-                                        int sampleCnt) {
+static sk_sp<GrTextureProxy> create_mask_GPU(GrContext* context,
+                                             const SkIRect& maskRect,
+                                             const SkPath& devPath,
+                                             SkStrokeRec::InitStyle fillOrHairline,
+                                             bool doAA,
+                                             int sampleCnt) {
     if (!doAA) {
         // Don't need MSAA if mask isn't AA
         sampleCnt = 0;
     }
 
-    sk_sp<GrRenderTargetContext> renderTargetContext(context->makeRenderTargetContextWithFallback(
+    sk_sp<GrRenderTargetContext> rtContext(context->makeDeferredRenderTargetContextWithFallback(
         SkBackingFit::kApprox, maskRect.width(), maskRect.height(), kAlpha_8_GrPixelConfig, nullptr,
         sampleCnt));
-    if (!renderTargetContext) {
+    if (!rtContext) {
         return nullptr;
     }
 
-    renderTargetContext->clear(nullptr, 0x0, true);
+    rtContext->clear(nullptr, 0x0, true);
 
     GrPaint tempPaint;
     tempPaint.setAntiAlias(doAA);
@@ -124,8 +125,8 @@ static sk_sp<GrTexture> create_mask_GPU(GrContext* context,
     // the origin using tempPaint.
     SkMatrix translate;
     translate.setTranslate(-SkIntToScalar(maskRect.fLeft), -SkIntToScalar(maskRect.fTop));
-    renderTargetContext->drawPath(clip, tempPaint, translate, devPath, GrStyle(fillOrHairline));
-    return renderTargetContext->asTexture();;
+    rtContext->drawPath(clip, tempPaint, translate, devPath, GrStyle(fillOrHairline));
+    return sk_ref_sp(rtContext->asDeferredTexture());
 }
 
 static void draw_path_with_mask_filter(GrContext* context,
@@ -204,16 +205,21 @@ static void draw_path_with_mask_filter(GrContext* context,
             return;
         }
 
-        sk_sp<GrTexture> mask(create_mask_GPU(context,
-                                              finalIRect,
-                                              *path,
-                                              fillOrHairline,
-                                              paint->isAntiAlias(),
-                                              renderTargetContext->numColorSamples()));
-        if (mask) {
+        sk_sp<GrTextureProxy> maskProxy(create_mask_GPU(context,
+                                                        finalIRect,
+                                                        *path,
+                                                        fillOrHairline,
+                                                        paint->isAntiAlias(),
+                                                        renderTargetContext->numColorSamples()));
+        if (maskProxy) {
             GrTexture* filtered;
 
-            if (maskFilter->filterMaskGPU(mask.get(), viewMatrix, finalIRect, &filtered)) {
+            GrTexture* mask = maskProxy->instantiate(context->textureProvider());
+            if (!mask) {
+                return;
+            }
+
+            if (maskFilter->filterMaskGPU(mask, viewMatrix, finalIRect, &filtered)) {
                 // filterMaskGPU gives us ownership of a ref to the result
                 sk_sp<GrTexture> atu(filtered);
                 if (draw_mask(renderTargetContext, clip, viewMatrix, finalIRect, paint, filtered)) {