Add control over whether lines are special cased in SkDashPath. Disable when called from GrShape.

src/gpu/GrStyle.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrStyle.h"
+#include "SkDashPathPriv.h"
 
 int GrStyle::KeySize(const GrStyle &style, Apply apply, uint32_t flags) {
     GR_STATIC_ASSERT(sizeof(uint32_t) == sizeof(SkScalar));
     int size = 0;
     if (style.isDashed()) {
         // One scalar for scale, one for dash phase, and one for each dash value.
         size += 2 + style.dashIntervalCnt();
     } else if (style.pathEffect()) {
         // No key for a generic path effect.
         return -1;
@@ skipping 94 matching lines @@
             fDashInfo.fPhase = info.fPhase;
             info.fIntervals = fDashInfo.fIntervals.get();
             pe->asADash(&info);
             fPathEffect.reset(SkSafeRef(pe));
         }
     } else {
         fPathEffect.reset(SkSafeRef(pe));
     }
 }
 
-static inline bool apply_path_effect(SkPath* dst, SkStrokeRec* strokeRec,
-                                     const sk_sp<SkPathEffect>& pe, const SkPath& src) {
-    if (!pe) {
+bool GrStyle::applyPathEffect(SkPath* dst, SkStrokeRec* strokeRec, const SkPath& src) const {
+    if (!fPathEffect) {
         return false;
     }
-    if (!pe->filterPath(dst, src, strokeRec, nullptr)) {
+    if (SkPathEffect::kDash_DashType == fDashInfo.fType) {
+        // We apply the dash ourselves here rather than using the path effect. This is so that
+        // we can control whether the dasher applies the strokeRec for special cases. Our keying
+        // depends on the strokeRec being applied separately.
+        SkScalar phase = fDashInfo.fPhase;
+        const SkScalar* intervals = fDashInfo.fIntervals.get();
+        int intervalCnt = fDashInfo.fIntervals.count();
+        SkScalar initialLength;
+        int initialIndex;
+        SkScalar intervalLength;
+        SkDashPath::CalcDashParameters(phase, intervals, intervalCnt, &initialLength,
+                                       &initialIndex, &intervalLength);
+        if (!SkDashPath::InternalFilter(dst, src, strokeRec,
+                                        nullptr, intervals, intervalCnt,
+                                        initialLength, initialIndex, intervalLength,
+                                        SkDashPath::StrokeRecApplication::kDisallow)) {
+            return false;
+        }
+    } else if (!fPathEffect->filterPath(dst, src, strokeRec, nullptr)) {
         return false;
     }
     dst->setIsVolatile(true);
     return true;
 }
 
 bool GrStyle::applyPathEffectToPath(SkPath *dst, SkStrokeRec *remainingStroke,
                                     const SkPath &src, SkScalar resScale) const {
     SkASSERT(dst);
     SkStrokeRec strokeRec = fStrokeRec;
     strokeRec.setResScale(resScale);
-    if (!apply_path_effect(dst, &strokeRec, fPathEffect, src)) {
+    if (!this->applyPathEffect(dst, &strokeRec, src)) {
         return false;
     }
     *remainingStroke = strokeRec;
     return true;
 }
 
 bool GrStyle::applyToPath(SkPath* dst, SkStrokeRec::InitStyle* style, const SkPath& src,
                           SkScalar resScale) const {
     SkASSERT(style);
     SkASSERT(dst);
     SkStrokeRec strokeRec = fStrokeRec;
     strokeRec.setResScale(resScale);
     const SkPath* pathForStrokeRec = &src;
-    if (apply_path_effect(dst, &strokeRec, fPathEffect, src)) {
+    if (this->applyPathEffect(dst, &strokeRec, src)) {
         pathForStrokeRec = dst;
     } else if (fPathEffect) {
         return false;
     }
     if (strokeRec.needToApply()) {
         if (!strokeRec.applyToPath(dst, *pathForStrokeRec)) {
             return false;
         }
         *style = SkStrokeRec::kFill_InitStyle;
     } else if (!fPathEffect) {
         // Nothing to do for path effect or stroke, fail.
         return false;
     } else {
         SkASSERT(SkStrokeRec::kFill_Style == strokeRec.getStyle() ||
                  SkStrokeRec::kHairline_Style == strokeRec.getStyle());
         *style = strokeRec.getStyle() == SkStrokeRec::kFill_Style
                  ? SkStrokeRec::kFill_InitStyle
                  : SkStrokeRec::kHairline_InitStyle;
     }
     return true;
 }