Retract GrRenderTarget a bit

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 130 matching lines @@
     // 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 mask;
 }
 
 static void draw_path_with_mask_filter(GrContext* context,
                                        GrDrawContext* drawContext,
-                                       GrRenderTarget* renderTarget,
                                        const GrClip& clip,
                                        GrPaint* paint,
                                        const SkMatrix& viewMatrix,
                                        const SkMaskFilter* maskFilter,
                                        const SkPathEffect* pathEffect,
                                        const GrStrokeInfo& origStrokeInfo,
                                        SkPath* pathPtr,
                                        bool pathIsMutable) {
     SkASSERT(maskFilter);
 
     SkIRect clipBounds;
-    clip.getConservativeBounds(renderTarget, &clipBounds);
+    clip.getConservativeBounds(drawContext->width(), drawContext->height(), &clipBounds);
     SkTLazy<SkPath> tmpPath;
     GrStrokeInfo strokeInfo(origStrokeInfo);
 
     static const SkRect* cullRect = nullptr;  // TODO: what is our bounds?
 
     SkASSERT(strokeInfo.isDashed() || !pathEffect);
 
     if (!strokeInfo.isHairlineStyle()) {
         SkPath* strokedPath = pathIsMutable ? pathPtr : tmpPath.init();
         if (strokeInfo.isDashed()) {
@@ skipping 44 matching lines @@
             // 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,
                                                      paint->isAntiAlias(),
-                                                     renderTarget->numColorSamples()));
+                                                     drawContext->numColorSamples()));
         if (mask) {
             GrTexture* filtered;
 
             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;
                 }
             }
         }
     }
 
     // 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;
     sw_draw_with_mask_filter(drawContext, context->textureProvider(),
                              clip, viewMatrix, *devPathPtr,
                              maskFilter, clipBounds, paint, style);
 }
 
 void GrBlurUtils::drawPathWithMaskFilter(GrContext* context,
                                          GrDrawContext* drawContext,
-                                         GrRenderTarget* rt,
                                          const GrClip& clip,
                                          const SkPath& origPath,
                                          GrPaint* paint,
                                          const SkMatrix& viewMatrix,
                                          const SkMaskFilter* mf,
                                          const SkPathEffect* pathEffect,
                                          const GrStrokeInfo& origStrokeInfo,
                                          bool pathIsMutable) {
     SkPath* pathPtr = const_cast<SkPath*>(&origPath);
 
     SkTLazy<SkPath> tmpPath;
     GrStrokeInfo strokeInfo(origStrokeInfo);
 
     if (!strokeInfo.isDashed() && pathEffect && pathEffect->filterPath(tmpPath.init(), *pathPtr,
                                                                        &strokeInfo, nullptr)) {
         pathPtr = tmpPath.get();
         pathPtr->setIsVolatile(true);
         pathIsMutable = true;
         pathEffect = nullptr;
     }
 
-    draw_path_with_mask_filter(context, drawContext, rt, clip, paint, viewMatrix, mf, pathEffect,
+    draw_path_with_mask_filter(context, drawContext, clip, paint, viewMatrix, mf, pathEffect,
                                strokeInfo, pathPtr, pathIsMutable);
 }
 
 void GrBlurUtils::drawPathWithMaskFilter(GrContext* context, 
                                          GrDrawContext* drawContext,
-                                         GrRenderTarget* renderTarget,
                                          const GrClip& clip,
                                          const SkPath& origSrcPath,
                                          const SkPaint& paint,
                                          const SkMatrix& origViewMatrix,
                                          const SkMatrix* prePathMatrix,
                                          const SkIRect& clipBounds,
                                          bool pathIsMutable) {
     SkASSERT(!pathIsMutable || origSrcPath.isVolatile());
 
     GrStrokeInfo strokeInfo(paint);
@@ skipping 40 matching lines @@
         pathIsMutable = true;
         pathEffect = nullptr;
     }
 
     GrPaint grPaint;
     if (!SkPaintToGrPaint(context, paint, viewMatrix, &grPaint)) {
         return;
     }
 
     if (paint.getMaskFilter()) {
-        draw_path_with_mask_filter(context, drawContext, renderTarget, clip, &grPaint, viewMatrix,
+        draw_path_with_mask_filter(context, drawContext, clip, &grPaint, viewMatrix,
                                    paint.getMaskFilter(), pathEffect, strokeInfo,
                                    pathPtr, pathIsMutable);
     } else {
         drawContext->drawPath(clip, grPaint, viewMatrix, *pathPtr, strokeInfo);
     }
 }