limit the number of points in SkDashPathEffect::asPoints

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 158 matching lines @@
         fTangent.rotateCCW(&fNormal);
         fNormal.scale(SkScalarHalf(rec->getWidth()));
 
         // now estimate how many quads will be added to the path
         //     resulting segments = pathLen * intervalCount / intervalLen
         //     resulting points = 4 * segments
 
         SkScalar ptCount = SkScalarMulDiv(pathLength,
                                           SkIntToScalar(intervalCount),
                                           intervalLength);
+        ptCount = SkTMin(ptCount, SkDashPath::kMaxDashCount);

[caryclark, 2016/07/21 12:22:59]

Don't need the SkDashPath:: prefix here

         int n = SkScalarCeilToInt(ptCount) << 2;
         dst->incReserve(n);
 
         // we will take care of the stroking
         rec->setFillStyle();
         return true;
     }
 
     void addSegment(SkScalar d0, SkScalar d1, SkPath* path) const {
         SkASSERT(d0 < fPathLength);
@@ skipping 59 matching lines @@
         int         index = initialDashIndex;
 
         // Since the path length / dash length ratio may be arbitrarily large, we can exert
         // significant memory pressure while attempting to build the filtered path. To avoid this,
         // we simply give up dashing beyond a certain threshold.
         //
         // The original bug report (http://crbug.com/165432) is based on a path yielding more than
         // 90 million dash segments and crashing the memory allocator. A limit of 1 million
         // segments seems reasonable: at 2 verbs per segment * 9 bytes per verb, this caps the
         // maximum dash memory overhead at roughly 17MB per path.
-        static const SkScalar kMaxDashCount = 1000000;
         dashCount += length * (count >> 1) / intervalLength;
         if (dashCount > kMaxDashCount) {
             dst->reset();
             return false;
         }
 
         // Using double precision to avoid looping indefinitely due to single precision rounding
         // (for extreme path_length/dash_length ratios). See test_infinite_dash() unittest.
         double  distance = 0;
         double  dlen = initialDashLength;
@@ skipping 67 matching lines @@
     SkScalar length = 0;
     for (int i = 0; i < count; i++) {
         if (intervals[i] < 0) {
             return false;
         }
         length += intervals[i];
     }
     // watch out for values that might make us go out of bounds
     return length > 0 && SkScalarIsFinite(phase) && SkScalarIsFinite(length);
 }