Revert of Refactor drawContext/RenderTarget creation

src/gpu/GrBlurUtils.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrBlurUtils.h"
 #include "GrDrawContext.h"
 #include "GrCaps.h"
@@ skipping 75 matching lines @@
     }
     texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
                                dstM.fImage, dstM.fRowBytes);
 
     SkRect maskRect = SkRect::Make(dstM.fBounds);
 
     return draw_mask(drawContext, clipData, viewMatrix, maskRect, grp, texture);
 }
 
 // Create a mask of 'devPath' and place the result in 'mask'.
-static sk_sp<GrTexture> create_mask_GPU(GrContext* context,
-                                        SkRect* maskRect,
-                                        const SkPath& devPath,
-                                        const GrStrokeInfo& strokeInfo,
-                                        bool doAA,
-                                        int sampleCnt) {
+static GrTexture* create_mask_GPU(GrContext* context,
+                                  SkRect* maskRect,
+                                  const SkPath& devPath,
+                                  const GrStrokeInfo& strokeInfo,
+                                  bool doAA,
+                                  int sampleCnt) {
     // This mask will ultimately be drawn as a non-AA rect (see draw_mask).
     // Non-AA rects have a bad habit of snapping arbitrarily. Integerize here
     // so the mask draws in a reproducible manner.
     *maskRect = SkRect::Make(maskRect->roundOut());
 
-    if (!doAA) {
-        // Don't need MSAA if mask isn't AA
-        sampleCnt = 0;
+    GrSurfaceDesc desc;
+    desc.fFlags = kRenderTarget_GrSurfaceFlag;
+    desc.fWidth = SkScalarCeilToInt(maskRect->width());
+    desc.fHeight = SkScalarCeilToInt(maskRect->height());
+    desc.fSampleCnt = doAA ? sampleCnt : 0;
+    // We actually only need A8, but it often isn't supported as a
+    // render target so default to RGBA_8888
+    desc.fConfig = kRGBA_8888_GrPixelConfig;
+
+    if (context->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, desc.fSampleCnt > 0)) {
+        desc.fConfig = kAlpha_8_GrPixelConfig;
     }
 
-    // We actually only need A8, but it often isn't supported as a
-    // render target so default to RGBA_8888
-    GrPixelConfig config = kRGBA_8888_GrPixelConfig;
-    if (context->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, sampleCnt > 0)) {
-        config = kAlpha_8_GrPixelConfig;
+    GrTexture* mask = context->textureProvider()->createApproxTexture(desc);
+    if (nullptr == mask) {
+        return nullptr;
     }
 
-    sk_sp<GrDrawContext> drawContext(context->newDrawContext(GrContext::kLoose_BackingFit,
-                                                             SkScalarCeilToInt(maskRect->width()), 
-                                                             SkScalarCeilToInt(maskRect->height()),
-                                                             config,
-                                                             sampleCnt));
+    SkRect clipRect = SkRect::MakeWH(maskRect->width(), maskRect->height());
+
+    sk_sp<GrDrawContext> drawContext(context->drawContext(sk_ref_sp(mask->asRenderTarget())));
     if (!drawContext) {
         return nullptr;
     }
 
     drawContext->clear(nullptr, 0x0, true);
 
     GrPaint tempPaint;
     tempPaint.setAntiAlias(doAA);
     tempPaint.setCoverageSetOpXPFactory(SkRegion::kReplace_Op);
 
     // setup new clip
-    const SkRect clipRect = SkRect::MakeWH(maskRect->width(), maskRect->height());
     GrClip clip(clipRect);
 
     // Draw the mask into maskTexture with the path's integerized top-left at
     // the origin using tempPaint.
     SkMatrix translate;
     translate.setTranslate(-maskRect->fLeft, -maskRect->fTop);
     drawContext->drawPath(clip, tempPaint, translate, devPath, strokeInfo);
-    return drawContext->asTexture();;
+    return mask;
 }
 
 static void draw_path_with_mask_filter(GrContext* context,
                                        GrDrawContext* drawContext,
                                        const GrClip& clip,
                                        GrPaint* paint,
                                        const SkMatrix& viewMatrix,
                                        const SkMaskFilter* maskFilter,
                                        const SkPathEffect* pathEffect,
                                        const GrStrokeInfo& origStrokeInfo,
@@ skipping 55 matching lines @@
                                             paint,
                                             clip,
                                             viewMatrix,
                                             strokeInfo,
                                             *devPathPtr)) {
             // the mask filter was able to draw itself directly, so there's nothing
             // left to do.
             return;
         }
 
-        sk_sp<GrTexture> mask(create_mask_GPU(context,
-                                              &maskRect,
-                                              *devPathPtr,
-                                              strokeInfo,
-                                              paint->isAntiAlias(),
-                                              drawContext->numColorSamples()));
+        SkAutoTUnref<GrTexture> mask(create_mask_GPU(context,
+                                                     &maskRect,
+                                                     *devPathPtr,
+                                                     strokeInfo,
+                                                     paint->isAntiAlias(),
+                                                     drawContext->numColorSamples()));
         if (mask) {
             GrTexture* filtered;
 
-            if (maskFilter->filterMaskGPU(mask.get(), viewMatrix, maskRect, &filtered, true)) {
+            if (maskFilter->filterMaskGPU(mask, viewMatrix, maskRect, &filtered, true)) {
                 // filterMaskGPU gives us ownership of a ref to the result
                 SkAutoTUnref<GrTexture> atu(filtered);
                 if (draw_mask(drawContext, clip, viewMatrix, maskRect, paint, filtered)) {
                     // This path is completely drawn
                     return;
                 }
             }
         }
     }
 
@@ skipping 99 matching lines @@
     }
 
     if (paint.getMaskFilter()) {
         draw_path_with_mask_filter(context, drawContext, clip, &grPaint, viewMatrix,
                                    paint.getMaskFilter(), pathEffect, strokeInfo,
                                    pathPtr, pathIsMutable);
     } else {
         drawContext->drawPath(clip, grPaint, viewMatrix, *pathPtr, strokeInfo);
     }
 }