allow one zero length dash

src/utils/SkDashPath.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDashPathPriv.h"
 #include "SkPathMeasure.h"
 #include "SkStrokeRec.h"
@@ skipping 13 matching lines @@
         }
     }
     // If we get here, phase "appears" to be larger than our length. This
     // shouldn't happen with perfect precision, but we can accumulate errors
     // during the initial length computation (rounding can make our sum be too
     // big or too small. In that event, we just have to eat the error here.
     *index = 0;
     return intervals[0];
 }
 
-void SkDashPath::CalcDashParameters(SkScalar phase, const SkScalar intervals[], int32_t count,
+bool SkDashPath::CalcDashParameters(SkScalar phase, const SkScalar intervals[], int32_t count,
                                     SkScalar* initialDashLength, int32_t* initialDashIndex,
                                     SkScalar* intervalLength, SkScalar* adjustedPhase) {
     SkScalar len = 0;
     for (int i = 0; i < count; i++) {
         len += intervals[i];
     }
     *intervalLength = len;
 
     // watch out for values that might make us go out of bounds
-    if ((len > 0) && SkScalarIsFinite(phase) && SkScalarIsFinite(len)) {
+    if ((len <= 0) || !SkScalarIsFinite(phase) || !SkScalarIsFinite(len)) {
+        return false;
+    }
 
-        // Adjust phase to be between 0 and len, "flipping" phase if negative.
-        // e.g., if len is 100, then phase of -20 (or -120) is equivalent to 80
-        if (adjustedPhase) {
-            if (phase < 0) {
-                phase = -phase;
-                if (phase > len) {
-                    phase = SkScalarMod(phase, len);
-                }
-                phase = len - phase;
-
-                // Due to finite precision, it's possible that phase == len,
-                // even after the subtract (if len >>> phase), so fix that here.
-                // This fixes http://crbug.com/124652 .
-                SkASSERT(phase <= len);
-                if (phase == len) {
-                    phase = 0;
-                }
-            } else if (phase >= len) {
+    // Adjust phase to be between 0 and len, "flipping" phase if negative.
+    // e.g., if len is 100, then phase of -20 (or -120) is equivalent to 80
+    if (adjustedPhase) {
+        if (phase < 0) {
+            phase = -phase;
+            if (phase > len) {
                 phase = SkScalarMod(phase, len);
             }
-            *adjustedPhase = phase;
+            phase = len - phase;
+
+            // Due to finite precision, it's possible that phase == len,
+            // even after the subtract (if len >>> phase), so fix that here.
+            // This fixes http://crbug.com/124652 .
+            SkASSERT(phase <= len);
+            if (phase == len) {
+                phase = 0;
+            }
+        } else if (phase >= len) {
+            phase = SkScalarMod(phase, len);
         }
-        SkASSERT(phase >= 0 && phase < len);
+        *adjustedPhase = phase;
+    }
+    SkASSERT(phase >= 0 && phase < len);
 
-        *initialDashLength = find_first_interval(intervals, phase,
-                                                initialDashIndex, count);
+    *initialDashLength = find_first_interval(intervals, phase,
+                                            initialDashIndex, count);
 
-        SkASSERT(*initialDashLength >= 0);
-        SkASSERT(*initialDashIndex >= 0 && *initialDashIndex < count);
-    } else {
-        *initialDashLength = -1;    // signal bad dash intervals
-    }
+    SkASSERT(*initialDashLength >= 0);
+    SkASSERT(*initialDashIndex >= 0 && *initialDashIndex < count);
+    return true;
 }
 
 static void outset_for_stroke(SkRect* rect, const SkStrokeRec& rec) {
     SkScalar radius = SkScalarHalf(rec.getWidth());
     if (0 == radius) {
         radius = SK_Scalar1;    // hairlines
     }
     if (SkPaint::kMiter_Join == rec.getJoin()) {
         radius = SkScalarMul(radius, rec.getMiter());
     }
@@ skipping 128 matching lines @@
     SkVector fTangent;
     SkVector fNormal;
     SkScalar fPathLength;
 };
 
 
 bool SkDashPath::FilterDashPath(SkPath* dst, const SkPath& src, SkStrokeRec* rec,
                                 const SkRect* cullRect, const SkScalar aIntervals[],
                                 int32_t count, SkScalar initialDashLength, int32_t initialDashIndex,
                                 SkScalar intervalLength) {
 

[robertphillips, 2016/03/16 19:00:52]

Is this comment right - was it ever right?

[caryclark, 2016/03/16 19:19:19]

Done.

     // we do nothing if the src wants to be filled, or if our dashlength is 0
-    if (rec->isFillStyle() || initialDashLength < 0) {
+    if (rec->isFillStyle()) {
         return false;
     }
 
     const SkScalar* intervals = aIntervals;
     SkScalar        dashCount = 0;
     int             segCount = 0;
 
     SkPath cullPathStorage;
     const SkPath* srcPtr = &src;
     if (cull_path(src, *rec, cullRect, intervalLength, &cullPathStorage)) {
@@ skipping 59 matching lines @@
             if (index == count) {
                 index = 0;
             }
 
             // fetch our next dlen
             dlen = intervals[index];
         }
 
         // extend if we ended on a segment and we need to join up with the (skipped) initial segment
         if (meas.isClosed() && is_even(initialDashIndex) &&
-            initialDashLength > 0) {
+            initialDashLength >= 0) {
             meas.getSegment(0, initialDashLength, dst, !addedSegment);
             ++segCount;
         }
     } while (meas.nextContour());
 
     if (segCount > 1) {
         dst->setConvexity(SkPath::kConcave_Convexity);
     }
 
     return true;
 }
 
 bool SkDashPath::FilterDashPath(SkPath* dst, const SkPath& src, SkStrokeRec* rec,
                                 const SkRect* cullRect, const SkPathEffect::DashInfo& info) {
     SkScalar initialDashLength = 0;
     int32_t initialDashIndex = 0;
     SkScalar intervalLength = 0;
-    CalcDashParameters(info.fPhase, info.fIntervals, info.fCount,
-                       &initialDashLength, &initialDashIndex, &intervalLength);
+    if (!CalcDashParameters(info.fPhase, info.fIntervals, info.fCount,
+                       &initialDashLength, &initialDashIndex, &intervalLength)) {
+        return false;
+    }
     return FilterDashPath(dst, src, rec, cullRect, info.fIntervals, info.fCount, initialDashLength,
                           initialDashIndex, intervalLength);
 }