Add special handling of rectori case for gpu

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"
@@ skipping 219 matching lines @@
 
 bool SkDashPathEffect::filterPath(SkPath* dst, const SkPath& src,
                               SkStrokeRec* rec, const SkRect* cullRect) const {
     // we do nothing if the src wants to be filled, or if our dashlength is 0
     if (rec->isFillStyle() || fInitialDashLength < 0) {
         return false;
     }
 
     const SkScalar* intervals = fIntervals;
     SkScalar        dashCount = 0;
+    int             segCount = 0;
 
     SkPath cullPathStorage;
     const SkPath* srcPtr = &src;
     if (cull_path(src, *rec, cullRect, fIntervalLength, &cullPathStorage)) {
         srcPtr = &cullPathStorage;
     }
 
     SpecialLineRec lineRec;
     bool specialLine = lineRec.init(*srcPtr, dst, rec, fCount >> 1, fIntervalLength);
 
@@ skipping 34 matching lines @@
         // 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 = SkScalarMul(fInitialDashLength, scale);
 
         while (distance < length) {
             SkASSERT(dlen >= 0);
             addedSegment = false;
             if (is_even(index) && dlen > 0 && !skipFirstSegment) {
                 addedSegment = true;
+                ++segCount;
 
                 if (specialLine) {
                     lineRec.addSegment(SkDoubleToScalar(distance),
                                        SkDoubleToScalar(distance + dlen),
                                        dst);
                 } else {
                     meas.getSegment(SkDoubleToScalar(distance),
                                     SkDoubleToScalar(distance + dlen),
                                     dst, true);
                 }
@@ skipping 11 matching lines @@
             }
 
             // fetch our next dlen
             dlen = SkScalarMul(intervals[index], scale);
         }
 
         // extend if we ended on a segment and we need to join up with the (skipped) initial segment
         if (meas.isClosed() && is_even(fInitialDashIndex) &&
                 fInitialDashLength > 0) {
             meas.getSegment(0, SkScalarMul(fInitialDashLength, scale), dst, !addedSegment);
+            ++segCount;
         }
     } while (meas.nextContour());
 
+    if (segCount > 1) {
+        dst->setConvexity(SkPath::kConcave_Convexity);
+    }
+
     return true;
 }
 
 // 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,
@@ skipping 205 matching lines @@
 SkDashPathEffect::SkDashPathEffect(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
     fInitialDashIndex = buffer.readInt();
     fInitialDashLength = buffer.readScalar();
     fIntervalLength = buffer.readScalar();
     fScaleToFit = buffer.readBool();
 
     fCount = buffer.getArrayCount();
     fIntervals = (SkScalar*)sk_malloc_throw(sizeof(SkScalar) * fCount);
     buffer.readScalarArray(fIntervals);
 }