Pass dashing info from drawPath to Gr side

src/gpu/SkGpuDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuDevice.h"
 
 #include "GrBitmapTextContext.h"
@@ skipping 808 matching lines @@
     // at this point we're done with prePathMatrix
     SkDEBUGCODE(prePathMatrix = (const SkMatrix*)0x50FF8001;)
 
     GrPaint grPaint;
     if (!SkPaint2GrPaint(this->context(), fRenderTarget, paint, viewMatrix, true, &grPaint)) {
         return;
     }
 
     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;
                 strokeInfo.setFillStyle();
             }
         }
 
         // avoid possibly allocating a new path in transform if we can
         SkPath* devPathPtr = pathIsMutable ? pathPtr : tmpPath.init();
         if (!pathIsMutable) {
             devPathPtr->setIsVolatile(true);
@@ skipping 1182 matching lines @@
 #endif
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif