GrDrawContext now holds GrRenderTarget pointer

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"
 #include "GrContext.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "GrStrokeInfo.h"
 #include "GrTexture.h"
 #include "GrTextureProvider.h"
 #include "SkDraw.h"
 #include "SkGrPriv.h"
 #include "SkMaskFilter.h"
 #include "SkPaint.h"
 
 static bool clip_bounds_quick_reject(const SkIRect& clipBounds, const SkIRect& rect) {
     return clipBounds.isEmpty() || rect.isEmpty() || !SkIRect::Intersects(clipBounds, rect);
 }
 
 // Draw a mask using the supplied paint. Since the coverage/geometry
 // is already burnt into the mask this boils down to a rect draw.
 // Return true if the mask was successfully drawn.
 static bool draw_mask(GrDrawContext* drawContext,
-                      GrRenderTarget* rt,
                       const GrClip& clip,
                       const SkMatrix& viewMatrix,
                       const SkRect& maskRect,
                       GrPaint* grp,
                       GrTexture* mask) {
     SkMatrix matrix;
     matrix.setTranslate(-maskRect.fLeft, -maskRect.fTop);
     matrix.postIDiv(mask->width(), mask->height());
 
     grp->addCoverageFragmentProcessor(GrSimpleTextureEffect::Create(mask, matrix,
                                                                     kDevice_GrCoordSet))->unref();
 
     SkMatrix inverse;
     if (!viewMatrix.invert(&inverse)) {
         return false;
     }
-    drawContext->drawNonAARectWithLocalMatrix(rt, clip, *grp, SkMatrix::I(), maskRect, inverse);
+    drawContext->drawNonAARectWithLocalMatrix(clip, *grp, SkMatrix::I(), maskRect, inverse);
     return true;
 }
 
 static bool draw_with_mask_filter(GrDrawContext* drawContext,
                                   GrTextureProvider* textureProvider,
-                                  GrRenderTarget* rt,
                                   const GrClip& clipData,
                                   const SkMatrix& viewMatrix,
                                   const SkPath& devPath,
                                   SkMaskFilter* filter,
                                   const SkIRect& clipBounds,
                                   GrPaint* grp,
                                   SkPaint::Style style) {
     SkMask  srcM, dstM;
 
     if (!SkDraw::DrawToMask(devPath, &clipBounds, filter, &viewMatrix, &srcM,
@@ skipping 21 matching lines @@
 
     SkAutoTUnref<GrTexture> texture(textureProvider->createApproxTexture(desc));
     if (!texture) {
         return false;
     }
     texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
                                dstM.fImage, dstM.fRowBytes);
 
     SkRect maskRect = SkRect::Make(dstM.fBounds);
 
-    return draw_mask(drawContext, rt, clipData, viewMatrix, maskRect, grp, texture);
+    return draw_mask(drawContext, clipData, viewMatrix, maskRect, grp, texture);
 }
 
 // Create a mask of 'devPath' and place the result in 'mask'.
 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). 
@@ skipping 14 matching lines @@
         desc.fConfig = kAlpha_8_GrPixelConfig;
     }
 
     GrTexture* mask = context->textureProvider()->createApproxTexture(desc);
     if (nullptr == mask) {
         return nullptr;
     }
 
     SkRect clipRect = SkRect::MakeWH(maskRect->width(), maskRect->height());
 
-    SkAutoTUnref<GrDrawContext> drawContext(context->drawContext());
+    SkAutoTUnref<GrDrawContext> drawContext(context->drawContext(mask->asRenderTarget()));
     if (!drawContext) {
         return nullptr;
     }
 
-    drawContext->clear(mask->asRenderTarget(), nullptr, 0x0, true);
+    drawContext->clear(nullptr, 0x0, true);
 
     GrPaint tempPaint;
     tempPaint.setAntiAlias(doAA);
     tempPaint.setCoverageSetOpXPFactory(SkRegion::kReplace_Op);
 
     // setup new clip
     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(mask->asRenderTarget(), clip, tempPaint, translate, devPath, strokeInfo);
+    drawContext->drawPath(clip, tempPaint, translate, devPath, strokeInfo);
     return mask;
 }
 
 void GrBlurUtils::drawPathWithMaskFilter(GrContext* context, 
                                          GrDrawContext* drawContext,
                                          GrRenderTarget* renderTarget,
                                          const GrClip& clip,
                                          const SkPath& origSrcPath,
                                          const SkPaint& paint,
                                          const SkMatrix& origViewMatrix,
@@ skipping 82 matching lines @@
                                                     &maskRect)) {
             SkIRect finalIRect;
             maskRect.roundOut(&finalIRect);
             if (clip_bounds_quick_reject(clipBounds, finalIRect)) {
                 // clipped out
                 return;
             }
 
             if (paint.getMaskFilter()->directFilterMaskGPU(context->textureProvider(),
                                                            drawContext,
-                                                           renderTarget,
                                                            &grPaint,
                                                            clip,
                                                            viewMatrix,
                                                            strokeInfo,
                                                            *devPathPtr)) {
                 // the mask filter was able to draw itself directly, so there's nothing
                 // left to do.
                 return;
             }
 
             SkAutoTUnref<GrTexture> mask(create_mask_GPU(context,
                                                          &maskRect,
                                                          *devPathPtr,
                                                          strokeInfo,
                                                          grPaint.isAntiAlias(),
                                                          renderTarget->numColorSamples()));
             if (mask) {
                 GrTexture* filtered;
 
                 if (paint.getMaskFilter()->filterMaskGPU(mask, viewMatrix, maskRect,
                                                          &filtered, true)) {
                     // filterMaskGPU gives us ownership of a ref to the result
                     SkAutoTUnref<GrTexture> atu(filtered);
                     if (draw_mask(drawContext,
-                                  renderTarget,
                                   clip,
                                   viewMatrix,
                                   maskRect,
                                   &grPaint,
                                   filtered)) {
                         // This path is completely drawn
                         return;
                     }
                 }
             }
         }
 
         // draw the mask on the CPU - this is a fallthrough path in case the
         // GPU path fails
         SkPaint::Style style = strokeInfo.isHairlineStyle() ? SkPaint::kStroke_Style :
                                                               SkPaint::kFill_Style;
-        draw_with_mask_filter(drawContext, context->textureProvider(), renderTarget,
+        draw_with_mask_filter(drawContext, context->textureProvider(),
                               clip, viewMatrix, *devPathPtr,
                               paint.getMaskFilter(), clipBounds, &grPaint, style);
         return;
     }
 
-    drawContext->drawPath(renderTarget, clip, grPaint, viewMatrix, *pathPtr, strokeInfo);
+    drawContext->drawPath(clip, grPaint, viewMatrix, *pathPtr, strokeInfo);
 }