Pass dashing info from drawPath to Gr side

src/gpu/SkGpuDevice.cpp

Index: src/gpu/SkGpuDevice.cpp
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 337f400056f87c9d48d7d536c6ae3d30568a4c55..4e79db5cf727eae0650dee5247d211782df29261 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -826,17 +826,23 @@ void SkGpuDevice::internalDrawPath(const SkPath& origSrcPath, const SkPaint& pai
 
     const SkRect* cullRect = NULL;  // TODO: what is our bounds?
     SkStrokeRec* strokePtr = strokeInfo.getStrokeRecPtr();
-    if (pathEffect && pathEffect->filterPath(effectPath.init(), *pathPtr, strokePtr,
-                                             cullRect)) {
+    if (!strokeInfo.isDashed() && pathEffect && pathEffect->filterPath(effectPath.init(), *pathPtr,
+                                                                       strokePtr, cullRect)) {
         pathPtr = effectPath.get();
         pathIsMutable = true;
-        strokeInfo.removeDash();
     }
 
     const SkStrokeRec& stroke = strokeInfo.getStrokeRec();
     if (paint.getMaskFilter()) {
         if (!stroke.isHairlineStyle()) {
             SkPath* strokedPath = pathIsMutable ? pathPtr : tmpPath.init();
+            if (strokeInfo.isDashed()) {
+                if (pathEffect->filterPath(strokedPath, *pathPtr, strokePtr, cullRect)) {
+                    pathPtr = strokedPath;
+                    pathIsMutable = true;
+                }
+                strokeInfo.removeDash();
+            }
             if (stroke.applyToPath(strokedPath, *pathPtr)) {

[egdaniel, 2015/04/28 13:25:48]

what happens if both these if statements trigger and we filter/stroke the path
twice? seems like the stroke would take the original path and stroke it.

[Kimmo Kinnunen, 2015/04/28 14:12:30]

Yeah, the intention is to first apply the dashing and then apply the stroking.
The intention is to apply the dash to the original path and store that to
stroked path. Then the idea is to stroke that and store the result to the
stroked path.

[egdaniel, 2015/04/28 14:18:19]

So if on line 838, if !pathIsMutable then strokedPath = tmpPath. Then we take
pathPtr (original path), "dash" it, and store the result into strokedPath
(tmpPath). Then when we try to apply the stroke to path, we use pathPtr as the
source again. This value wasn't updated in the "dashing" block so we end up
stroking the original path and not the dashed one. Or am I missing something?

[egdaniel, 2015/04/28 14:20:09]

oh wait I am missing a line. woops ignore all my stupidity.

                 pathPtr = strokedPath;
                 pathIsMutable = true;