Clean up Ganesh path render a little 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 28 matching lines @@
                                                                     kDevice_GrCoordSet))->unref();
 
     SkMatrix inverse;
     if (!viewMatrix.invert(&inverse)) {
         return false;
     }
     drawContext->fillRectWithLocalMatrix(clip, *grp, SkMatrix::I(), maskRect, inverse);
     return true;
 }
 
-static bool draw_with_mask_filter(GrDrawContext* drawContext,
-                                  GrTextureProvider* textureProvider,
-                                  const GrClip& clipData,
-                                  const SkMatrix& viewMatrix,
-                                  const SkPath& devPath,
-                                  const SkMaskFilter* filter,
-                                  const SkIRect& clipBounds,
-                                  GrPaint* grp,
-                                  SkPaint::Style style) {
+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,
+                                     GrPaint* grp,
+                                     SkPaint::Style style) {
     SkMask  srcM, dstM;
 
     if (!SkDraw::DrawToMask(devPath, &clipBounds, filter, &viewMatrix, &srcM,
                             SkMask::kComputeBoundsAndRenderImage_CreateMode, style)) {
         return false;
     }
     SkAutoMaskFreeImage autoSrc(srcM.fImage);
 
     if (!filter->filterMask(&dstM, srcM, viewMatrix, nullptr)) {
         return false;
@@ skipping 91 matching lines @@
                                        bool pathIsMutable) {
     SkASSERT(maskFilter);
 
     SkIRect clipBounds;
     clip.getConservativeBounds(renderTarget, &clipBounds);
     SkTLazy<SkPath> tmpPath;
     GrStrokeInfo strokeInfo(origStrokeInfo);
 
     static const SkRect* cullRect = nullptr;  // TODO: what is our bounds?
 
-    if (!strokeInfo.isDashed() && pathEffect && pathEffect->filterPath(tmpPath.init(), *pathPtr,
-                                                                       &strokeInfo, cullRect)) {
-        pathPtr = tmpPath.get();
-        pathPtr->setIsVolatile(true);
-        pathIsMutable = true;
-    }
+    SkASSERT(strokeInfo.isDashed() || !pathEffect);
+
     if (!strokeInfo.isHairlineStyle()) {
         SkPath* strokedPath = pathIsMutable ? pathPtr : tmpPath.init();
         if (strokeInfo.isDashed()) {
             if (pathEffect->filterPath(strokedPath, *pathPtr, &strokeInfo, cullRect)) {
                 pathPtr = strokedPath;
                 pathPtr->setIsVolatile(true);
                 pathIsMutable = true;
             }
             strokeInfo.removeDash();
         }
         if (strokeInfo.applyToPath(strokedPath, *pathPtr)) {
+            // Apply the stroke to the path if there is one
             pathPtr = strokedPath;
             pathPtr->setIsVolatile(true);
             pathIsMutable = true;
             strokeInfo.setFillStyle();
         }
     }
 
     // avoid possibly allocating a new path in transform if we can
     SkPath* devPathPtr = pathIsMutable ? pathPtr : tmpPath.init();
     if (!pathIsMutable) {
@@ skipping 44 matching lines @@
                     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,
-                          maskFilter, clipBounds, paint, 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* pe,
-                                         const GrStrokeInfo& strokeInfo) {
-    SkPath* path = const_cast<SkPath*>(&origPath);
-    draw_path_with_mask_filter(context, drawContext, rt, clip, paint, viewMatrix, mf, pe,
-                               strokeInfo, path, false);
+                                         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,
+                               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,
@@ skipping 29 matching lines @@
             }
             // should I push prePathMatrix on our MV stack temporarily, instead
             // of applying it here? See SkDraw.cpp
             pathPtr->transform(*prePathMatrix, result);
             pathPtr = result;
         }
     }
     // at this point we're done with prePathMatrix
     SkDEBUGCODE(prePathMatrix = (const SkMatrix*)0x50FF8001;)
 
+    SkTLazy<SkPath> tmpPath2;
+
+    if (!strokeInfo.isDashed() && pathEffect &&
+        pathEffect->filterPath(tmpPath2.init(), *pathPtr, &strokeInfo, nullptr)) {
+        pathPtr = tmpPath2.get();
+        pathPtr->setIsVolatile(true);
+        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,
-                                   paint.getMaskFilter(), paint.getPathEffect(), strokeInfo,
+                                   paint.getMaskFilter(), pathEffect, strokeInfo,
                                    pathPtr, pathIsMutable);
     } else {
-        SkTLazy<SkPath> tmpPath2;
-        if (!strokeInfo.isDashed() && pathEffect &&
-            pathEffect->filterPath(tmpPath2.init(), *pathPtr, &strokeInfo, nullptr)) {
-            pathPtr = tmpPath2.get();
-            pathPtr->setIsVolatile(true);
-            pathIsMutable = true;
-        }
         drawContext->drawPath(clip, grPaint, viewMatrix, *pathPtr, strokeInfo);
     }
 }