10363.diff

commit f026d896dce856dd3c757c4c341b2df6876e1d28
Author: Robert Phillips <robertphillips@google.com>
Date:   Fri Sep 14 11:07:00 2018 -0400

    Preserve fLastMoveToIndex in SkPath::transform
    
    This should remedy some of the SkPath::reverseAddPath fuzzer failures
    
    Change-Id: Ic9fe6106b4a0693084b75f0544b672cea78be3cc
    Reviewed-on: https://skia-review.googlesource.com/154625
    Reviewed-by: Cary Clark <caryclark@google.com>
    Commit-Queue: Robert Phillips <robertphillips@google.com>

diff --git a/src/core/SkPath.cpp b/src/core/SkPath.cpp
index 2808c12ed4..bfe9cc23c9 100644
--- a/src/core/SkPath.cpp
+++ b/src/core/SkPath.cpp
@@ -1711,60 +1711,60 @@ SkPath& SkPath::reversePathTo(const SkPath& path) {
 SkPath& SkPath::reverseAddPath(const SkPath& srcPath) {
     // Detect if we're trying to add ourself
     const SkPath* src = &srcPath;
     SkTLazy<SkPath> tmp;
     if (this == src) {
         src = tmp.set(srcPath);
     }
 
-    SkPathRef::Editor ed(&fPathRef, src->fPathRef->countPoints(), src->fPathRef->countVerbs());
+    SkPathRef::Editor ed(&fPathRef, src->countVerbs(), src->countPoints());
 
     const SkPoint* pts = src->fPathRef->pointsEnd();
-    // we will iterator through src's verbs backwards
+    // we will iterate through src's verbs backwards
     const uint8_t* verbs = src->fPathRef->verbsMemBegin(); // points at the last verb
     const uint8_t* verbsEnd = src->fPathRef->verbs(); // points just past the first verb
     const SkScalar* conicWeights = src->fPathRef->conicWeightsEnd();
 
     bool needMove = true;
     bool needClose = false;
     while (verbs < verbsEnd) {
         uint8_t v = *(verbs++);
         int n = pts_in_verb(v);
 
         if (needMove) {
             --pts;
             this->moveTo(pts->fX, pts->fY);
             needMove = false;
         }
         pts -= n;
         switch (v) {
             case kMove_Verb:
                 if (needClose) {
                     this->close();
                     needClose = false;
                 }
                 needMove = true;
                 pts += 1;   // so we see the point in "if (needMove)" above
                 break;
             case kLine_Verb:
                 this->lineTo(pts[0]);
                 break;
             case kQuad_Verb:
                 this->quadTo(pts[1], pts[0]);
                 break;
             case kConic_Verb:
                 this->conicTo(pts[1], pts[0], *--conicWeights);
                 break;
             case kCubic_Verb:
                 this->cubicTo(pts[2], pts[1], pts[0]);
                 break;
             case kClose_Verb:
                 needClose = true;
                 break;
             default:
                 SkDEBUGFAIL("unexpected verb");
         }
     }
     return *this;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1792,79 +1792,80 @@ static void subdivide_cubic_to(SkPath* path, const SkPoint pts[4],
 void SkPath::transform(const SkMatrix& matrix, SkPath* dst) const {
     SkDEBUGCODE(this->validate();)
     if (dst == nullptr) {
         dst = (SkPath*)this;
     }
 
     if (matrix.hasPerspective()) {
         SkPath  tmp;
         tmp.fFillType = fFillType;
 
         SkPath::Iter    iter(*this, false);
         SkPoint         pts[4];
         SkPath::Verb    verb;
 
         while ((verb = iter.next(pts, false)) != kDone_Verb) {
             switch (verb) {
                 case kMove_Verb:
                     tmp.moveTo(pts[0]);
                     break;
                 case kLine_Verb:
                     tmp.lineTo(pts[1]);
                     break;
                 case kQuad_Verb:
                     // promote the quad to a conic
                     tmp.conicTo(pts[1], pts[2],
                                 SkConic::TransformW(pts, SK_Scalar1, matrix));
                     break;
                 case kConic_Verb:
                     tmp.conicTo(pts[1], pts[2],
                                 SkConic::TransformW(pts, iter.conicWeight(), matrix));
                     break;
                 case kCubic_Verb:
                     subdivide_cubic_to(&tmp, pts);
                     break;
                 case kClose_Verb:
                     tmp.close();
                     break;
                 default:
                     SkDEBUGFAIL("unknown verb");
                     break;
             }
         }
 
         dst->swap(tmp);
         SkPathRef::Editor ed(&dst->fPathRef);
         matrix.mapPoints(ed.points(), ed.pathRef()->countPoints());
         dst->fFirstDirection = SkPathPriv::kUnknown_FirstDirection;
     } else {
         SkPathRef::CreateTransformedCopy(&dst->fPathRef, *fPathRef.get(), matrix);
 
         if (this != dst) {
+            dst->fLastMoveToIndex = fLastMoveToIndex;
             dst->fFillType = fFillType;
             dst->fConvexity.store(fConvexity);
             dst->fIsVolatile = fIsVolatile;
         }
 
         if (SkPathPriv::kUnknown_FirstDirection == fFirstDirection) {
             dst->fFirstDirection = SkPathPriv::kUnknown_FirstDirection;
         } else {
             SkScalar det2x2 =
                 matrix.get(SkMatrix::kMScaleX) * matrix.get(SkMatrix::kMScaleY) -
                 matrix.get(SkMatrix::kMSkewX)  * matrix.get(SkMatrix::kMSkewY);
             if (det2x2 < 0) {
                 dst->fFirstDirection = SkPathPriv::OppositeFirstDirection(
                         (SkPathPriv::FirstDirection)fFirstDirection.load());
             } else if (det2x2 > 0) {
                 dst->fFirstDirection = fFirstDirection.load();
             } else {
                 dst->fConvexity = kUnknown_Convexity;
                 dst->fFirstDirection = SkPathPriv::kUnknown_FirstDirection;
             }
         }
 
         SkDEBUGCODE(dst->validate();)
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////