Fix GPU-only snapping bug in mask blur rendering

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 79 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, rt, clipData, viewMatrix, maskRect, grp, texture);
 }
 
 // Create a mask of 'devPath' and place the result in 'mask'.
 static GrTexture* create_mask_GPU(GrContext* context,
-                                  const SkRect& maskRect,
+                                  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());
+
     GrSurfaceDesc desc;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
-    desc.fWidth = SkScalarCeilToInt(maskRect.width());
-    desc.fHeight = SkScalarCeilToInt(maskRect.height());
+    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;
     }
 
     GrTexture* mask = context->textureProvider()->createApproxTexture(desc);
     if (nullptr == mask) {
         return nullptr;
     }
 
-    SkRect clipRect = SkRect::MakeWH(maskRect.width(), maskRect.height());
+    SkRect clipRect = SkRect::MakeWH(maskRect->width(), maskRect->height());
 
     SkAutoTUnref<GrDrawContext> drawContext(context->drawContext());
     if (!drawContext) {
         return nullptr;
     }
 
     drawContext->clear(mask->asRenderTarget(), 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 top-left at the origin using tempPaint.
+    // 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);
+    translate.setTranslate(-maskRect->fLeft, -maskRect->fTop);
     drawContext->drawPath(mask->asRenderTarget(), 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,
@@ skipping 95 matching lines @@
                                                            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,
+                                                         &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
@@ skipping 18 matching lines @@
                                                               SkPaint::kFill_Style;
         draw_with_mask_filter(drawContext, context->textureProvider(), renderTarget,
                               clip, viewMatrix, *devPathPtr,
                               paint.getMaskFilter(), clipBounds, &grPaint, style);
         return;
     }
 
     drawContext->drawPath(renderTarget, clip, grPaint, viewMatrix, *pathPtr, strokeInfo);
 }