allow one zero length dash

src/effects/SkDashPathEffect.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDashPathEffect.h"
 
 #include "SkDashPathPriv.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkStrokeRec.h"
 
 SkDashPathEffect::SkDashPathEffect(const SkScalar intervals[], int count, SkScalar phase)
         : fPhase(0)
-        , fInitialDashLength(0)
+        , fInitialDashLength(-1)
         , fInitialDashIndex(0)
         , fIntervalLength(0) {
     SkASSERT(intervals);
     SkASSERT(count > 1 && SkAlign2(count) == count);
 
     fIntervals = (SkScalar*)sk_malloc_throw(sizeof(SkScalar) * count);
     fCount = count;
     for (int i = 0; i < count; i++) {
         SkASSERT(intervals[i] >= 0);
         fIntervals[i] = intervals[i];
     }
 
     // set the internal data members
-    SkDashPath::CalcDashParameters(phase, fIntervals, fCount,
+    fValidParameters = SkDashPath::CalcDashParameters(phase, fIntervals, fCount,
             &fInitialDashLength, &fInitialDashIndex, &fIntervalLength, &fPhase);
 }
 
 SkDashPathEffect::~SkDashPathEffect() {
     sk_free(fIntervals);
 }
 
 bool SkDashPathEffect::filterPath(SkPath* dst, const SkPath& src,
                               SkStrokeRec* rec, const SkRect* cullRect) const {
+    if (!fValidParameters) {
+        return false;
+    }
     return SkDashPath::FilterDashPath(dst, src, rec, cullRect, fIntervals, fCount,
                                       fInitialDashLength, fInitialDashIndex, fIntervalLength);
 }
 
 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()) {
@@ skipping 104 matching lines @@
 // Currently asPoints is more restrictive then it needs to be. In the future
 // we need to:
 //      allow kRound_Cap capping (could allow rotations in the matrix with this)
 //      allow paths to be returned
 bool SkDashPathEffect::asPoints(PointData* results,
                                 const SkPath& src,
                                 const SkStrokeRec& rec,
                                 const SkMatrix& matrix,
                                 const SkRect* cullRect) const {
     // width < 0 -> fill && width == 0 -> hairline so requiring width > 0 rules both out
-    if (fInitialDashLength < 0 || 0 >= rec.getWidth()) {
+    if (!fValidParameters || 0 >= rec.getWidth()) {
         return false;
     }
 
     // TODO: this next test could be eased up. We could allow any number of
     // intervals as long as all the ons match and all the offs match.
     // Additionally, they do not necessarily need to be integers.
     // We cannot allow arbitrary intervals since we want the returned points
     // to be uniformly sized.
     if (fCount != 2 ||
         !SkScalarNearlyEqual(fIntervals[0], fIntervals[1]) ||
@@ skipping 215 matching lines @@
     if ((count < 2) || !SkIsAlign2(count)) {
         return nullptr;
     }
     for (int i = 0; i < count; i++) {
         if (intervals[i] < 0) {
             return nullptr;
         }
     }
     return new SkDashPathEffect(intervals, count, phase);
 }