Swap SkGpuBlurUtils over to using SkIRects

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 10 matching lines @@
 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,
                       const GrClip& clip,
                       const SkMatrix& viewMatrix,
-                      const SkRect& maskRect,
+                      const SkIRect& maskRect,
                       GrPaint* grp,
                       GrTexture* mask) {
     SkMatrix matrix;
-    matrix.setTranslate(-maskRect.fLeft, -maskRect.fTop);
+    matrix.setTranslate(-SkIntToScalar(maskRect.fLeft), -SkIntToScalar(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->fillRectWithLocalMatrix(clip, *grp, SkMatrix::I(), maskRect, inverse);
+    drawContext->fillRectWithLocalMatrix(clip, *grp, SkMatrix::I(),
+                                         SkRect::Make(maskRect), inverse);
     return true;
 }
 
 static bool sw_draw_with_mask_filter(GrDrawContext* drawContext,
                                      GrTextureProvider* textureProvider,
                                      const GrClip& clipData,
                                      const SkMatrix& viewMatrix,
                                      const SkPath& devPath,
                                      const SkMaskFilter* filter,
                                      const SkIRect& clipBounds,
@@ skipping 23 matching lines @@
     desc.fHeight = dstM.fBounds.height();
     desc.fConfig = kAlpha_8_GrPixelConfig;
 
     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, clipData, viewMatrix, maskRect, grp, texture);
+    return draw_mask(drawContext, clipData, viewMatrix, dstM.fBounds, 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 SkIRect& maskRect,
                                         const SkPath& devPath,
                                         SkStrokeRec::InitStyle fillOrHairline,
                                         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;
     }
 
     // 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;
     }
 
     sk_sp<GrDrawContext> drawContext(context->newDrawContext(SkBackingFit::kApprox,
-                                                             SkScalarCeilToInt(maskRect->width()), 
-                                                             SkScalarCeilToInt(maskRect->height()),
+                                                             maskRect.width(), 
+                                                             maskRect.height(),
                                                              config,
                                                              sampleCnt));
     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());
+    const SkRect clipRect = SkRect::MakeIWH(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);
+    translate.setTranslate(-SkIntToScalar(maskRect.fLeft), -SkIntToScalar(maskRect.fTop));
     drawContext->drawPath(clip, tempPaint, translate, devPath, GrStyle(fillOrHairline));
     return drawContext->asTexture();;
 }
 
 static void draw_path_with_mask_filter(GrContext* context,
                                        GrDrawContext* drawContext,
                                        const GrClip& clip,
                                        GrPaint* paint,
                                        const SkMatrix& viewMatrix,
                                        const SkMaskFilter* maskFilter,
@@ skipping 37 matching lines @@
         path = result;
         result->setIsVolatile(true);
         pathIsMutable = true;
     }
 
     SkRect maskRect;
     if (maskFilter->canFilterMaskGPU(SkRRect::MakeRect(path->getBounds()),
                                      clipBounds,
                                      viewMatrix,
                                      &maskRect)) {
+        // 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.
         SkIRect finalIRect;
         maskRect.roundOut(&finalIRect);
         if (clip_bounds_quick_reject(clipBounds, finalIRect)) {
             // clipped out
             return;
         }
 
         if (maskFilter->directFilterMaskGPU(context->textureProvider(),
                                             drawContext,
                                             paint,
                                             clip,
                                             viewMatrix,
                                             SkStrokeRec(fillOrHairline),
                                             *path)) {
             // 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,
+                                              finalIRect,
                                               *path,
                                               fillOrHairline,
                                               paint->isAntiAlias(),
                                               drawContext->numColorSamples()));
         if (mask) {
             GrTexture* filtered;
 
-            if (maskFilter->filterMaskGPU(mask.get(), viewMatrix, maskRect, &filtered, true)) {
+            if (maskFilter->filterMaskGPU(mask.get(), viewMatrix, finalIRect, &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)) {
+                if (draw_mask(drawContext, clip, viewMatrix, finalIRect, paint, filtered)) {
                     // This path is completely drawn
                     return;
                 }
             }
         }
     }
 
     sw_draw_with_mask_filter(drawContext, context->textureProvider(),
                              clip, viewMatrix, *path,
                              maskFilter, clipBounds, paint, fillOrHairline);
@@ skipping 55 matching lines @@
     }
 
     if (paint.getMaskFilter()) {
         draw_path_with_mask_filter(context, drawContext, clip, &grPaint, viewMatrix,
                                    paint.getMaskFilter(), style,
                                    path, pathIsMutable);
     } else {
         drawContext->drawPath(clip, grPaint, viewMatrix, *path, style);
     }
 }