tunnel down texture-size-constraint to imagefilters

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 137 matching lines @@
 
 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) {
+                                         bool pathIsMutable,
+                                         GrTextureProvider::SizeConstraint constraint) {
     SkASSERT(!pathIsMutable || origSrcPath.isVolatile());
 
     GrStrokeInfo strokeInfo(paint);
 
     // If we have a prematrix, apply it to the path, optimizing for the case
     // where the original path can in fact be modified in place (even though
     // its parameter type is const).
     SkPath* pathPtr = const_cast<SkPath*>(&origSrcPath);
     SkTLazy<SkPath> tmpPath;
     SkTLazy<SkPath> effectPath;
@@ skipping 89 matching lines @@
             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)) {
+                                                         &filtered, true, constraint)) {
                     // filterMaskGPU gives us ownership of a ref to the result
                     SkAutoTUnref<GrTexture> atu(filtered);
                     if (draw_mask(drawContext,
                                   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(),
                               clip, viewMatrix, *devPathPtr,
                               paint.getMaskFilter(), clipBounds, &grPaint, style);
         return;
     }
 
     drawContext->drawPath(clip, grPaint, viewMatrix, *pathPtr, strokeInfo);
 }