fuzzer fixes

src/core/SkStroke.cpp

 /*
  * Copyright 2008 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 "SkStrokerPriv.h"
 #include "SkGeometry.h"
 #include "SkPath.h"
@@ skipping 253 matching lines @@
                           const SkVector& normalAB, const SkVector& unitNormalAB,
                           SkVector* normalBC, SkVector* unitNormalBC);
     void setRayPts(const SkPoint& tPt, SkVector* dxy, SkPoint* onPt, SkPoint* tangent) const;
     static bool SlightAngle(SkQuadConstruct* );
     ResultType strokeCloseEnough(const SkPoint stroke[3], const SkPoint ray[2],
                                  SkQuadConstruct*  STROKER_DEBUG_PARAMS(int depth) ) const;
     ResultType tangentsMeet(const SkPoint cubic[4], SkQuadConstruct* );
 #endif
 
     void    finishContour(bool close, bool isLine);
-    void    preJoinTo(const SkPoint&, SkVector* normal, SkVector* unitNormal,
+    bool    preJoinTo(const SkPoint&, SkVector* normal, SkVector* unitNormal,
                       bool isLine);
     void    postJoinTo(const SkPoint&, const SkVector& normal,
                        const SkVector& unitNormal);
 
     void    line_to(const SkPoint& currPt, const SkVector& normal);
 #ifdef SK_LEGACY_STROKE_CURVES
     void    quad_to(const SkPoint pts[3],
                     const SkVector& normalAB, const SkVector& unitNormalAB,
                     SkVector* normalBC, SkVector* unitNormalBC,
                     int subDivide);
     void    cubic_to(const SkPoint pts[4],
                     const SkVector& normalAB, const SkVector& unitNormalAB,
                     SkVector* normalCD, SkVector* unitNormalCD,
                     int subDivide);
 #endif
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkPathStroker::preJoinTo(const SkPoint& currPt, SkVector* normal,
+bool SkPathStroker::preJoinTo(const SkPoint& currPt, SkVector* normal,
                               SkVector* unitNormal, bool currIsLine) {
     SkASSERT(fSegmentCount >= 0);
 
     SkScalar    prevX = fPrevPt.fX;
     SkScalar    prevY = fPrevPt.fY;
 
-    SkAssertResult(set_normal_unitnormal(fPrevPt, currPt, fRadius, normal,
-                                         unitNormal));
+    if (!set_normal_unitnormal(fPrevPt, currPt, fRadius, normal, unitNormal)) {
+        return false;
+    }
 
     if (fSegmentCount == 0) {
         fFirstNormal = *normal;
         fFirstUnitNormal = *unitNormal;
         fFirstOuterPt.set(prevX + normal->fX, prevY + normal->fY);
 
         fOuter.moveTo(fFirstOuterPt.fX, fFirstOuterPt.fY);
         fInner.moveTo(prevX - normal->fX, prevY - normal->fY);
     } else {    // we have a previous segment
         fJoiner(&fOuter, &fInner, fPrevUnitNormal, fPrevPt, *unitNormal,
                 fRadius, fInvMiterLimit, fPrevIsLine, currIsLine);
     }
     fPrevIsLine = currIsLine;
+    return true;
 }
 
 void SkPathStroker::postJoinTo(const SkPoint& currPt, const SkVector& normal,
                                const SkVector& unitNormal) {
     fPrevPt = currPt;
     fPrevUnitNormal = unitNormal;
     fPrevNormal = normal;
     fSegmentCount += 1;
 }
 
@@ skipping 85 matching lines @@
     fOuter.lineTo(currPt.fX + normal.fX, currPt.fY + normal.fY);
     fInner.lineTo(currPt.fX - normal.fX, currPt.fY - normal.fY);
 }
 
 void SkPathStroker::lineTo(const SkPoint& currPt) {
     if (SkPath::IsLineDegenerate(fPrevPt, currPt)) {
         return;
     }
     SkVector    normal, unitNormal;
 
-    this->preJoinTo(currPt, &normal, &unitNormal, true);
+    if (!this->preJoinTo(currPt, &normal, &unitNormal, true)) {
+        return;
+    }
     this->line_to(currPt, normal);
     this->postJoinTo(currPt, normal, unitNormal);
 }
 
 #ifdef SK_LEGACY_STROKE_CURVES
 void SkPathStroker::quad_to(const SkPoint pts[3],
                       const SkVector& normalAB, const SkVector& unitNormalAB,
                       SkVector* normalBC, SkVector* unitNormalBC,
                       int subDivide) {
     if (!set_normal_unitnormal(pts[1], pts[2], fRadius,
@@ skipping 357 matching lines @@
     if (kDegenerate_ReductionType == reductionType) {
         this->lineTo(reduction);
         SkStrokerPriv::JoinProc saveJoiner = fJoiner;
         fJoiner = SkStrokerPriv::JoinFactory(SkPaint::kRound_Join);
         this->lineTo(pt2);
         fJoiner = saveJoiner;
         return;
     }
     SkASSERT(kQuad_ReductionType == reductionType);
     SkVector normalAB, unitAB, normalBC, unitBC;
-    this->preJoinTo(pt1, &normalAB, &unitAB, false);
+    if (!this->preJoinTo(pt1, &normalAB, &unitAB, false)) {
+        this->lineTo(pt2);
+        return;
+    }
     SkQuadConstruct quadPts;
     this->init(kOuter_StrokeType, &quadPts, 0, 1);
-    if (!this->conicStroke(conic, &quadPts)) {
-        return;
-    }
+    (void) this->conicStroke(conic, &quadPts);
     this->init(kInner_StrokeType, &quadPts, 0, 1);
-    if (!this->conicStroke(conic, &quadPts)) {
-        return;
-    }
+    (void) this->conicStroke(conic, &quadPts);
     this->setConicEndNormal(conic, normalAB, unitAB, &normalBC, &unitBC);
     this->postJoinTo(pt2, normalBC, unitBC);
 }
 #endif
 
 void SkPathStroker::quadTo(const SkPoint& pt1, const SkPoint& pt2) {
 #ifndef SK_LEGACY_STROKE_CURVES
     const SkPoint quad[3] = { fPrevPt, pt1, pt2 };
     SkPoint reduction;
     ReductionType reductionType = CheckQuadLinear(quad, &reduction);
     if (kPoint_ReductionType == reductionType) {
         return;
     }
     if (kLine_ReductionType == reductionType) {
         this->lineTo(pt2);
         return;
     }
     if (kDegenerate_ReductionType == reductionType) {
         this->lineTo(reduction);
         SkStrokerPriv::JoinProc saveJoiner = fJoiner;
         fJoiner = SkStrokerPriv::JoinFactory(SkPaint::kRound_Join);
         this->lineTo(pt2);
         fJoiner = saveJoiner;
         return;
     }
     SkASSERT(kQuad_ReductionType == reductionType);
     SkVector normalAB, unitAB, normalBC, unitBC;
-    this->preJoinTo(pt1, &normalAB, &unitAB, false);
+    if (!this->preJoinTo(pt1, &normalAB, &unitAB, false)) {
+        this->lineTo(pt2);
+        return;
+    }
     SkQuadConstruct quadPts;
     this->init(kOuter_StrokeType, &quadPts, 0, 1);
-    if (!this->quadStroke(quad, &quadPts)) {
-        return;
-    }
+    (void) this->quadStroke(quad, &quadPts);
     this->init(kInner_StrokeType, &quadPts, 0, 1);
-    if (!this->quadStroke(quad, &quadPts)) {
-        return;
-    }
+    (void) this->quadStroke(quad, &quadPts);
     this->setQuadEndNormal(quad, normalAB, unitAB, &normalBC, &unitBC);
 #else
     bool    degenerateAB = SkPath::IsLineDegenerate(fPrevPt, pt1);
     bool    degenerateBC = SkPath::IsLineDegenerate(pt1, pt2);
 
     if (degenerateAB | degenerateBC) {
         if (degenerateAB ^ degenerateBC) {
             this->lineTo(pt2);
         }
         return;
@@ skipping 541 matching lines @@
         }
         if (kDegenerate3_ReductionType == reductionType) {
             this->lineTo(reduction[2]);
         }
         this->lineTo(pt3);
         fJoiner = saveJoiner;
         return;
     }
     SkASSERT(kQuad_ReductionType == reductionType);
     SkVector normalAB, unitAB, normalCD, unitCD;
-    this->preJoinTo(*tangentPt, &normalAB, &unitAB, false);
+    if (!this->preJoinTo(*tangentPt, &normalAB, &unitAB, false)) {
+        this->lineTo(pt3);
+        return;
+    }
     SkScalar tValues[2];
     int count = SkFindCubicInflections(cubic, tValues);
     SkScalar lastT = 0;
     for (int index = 0; index <= count; ++index) {
         SkScalar nextT = index < count ? tValues[index] : 1;
         SkQuadConstruct quadPts;
         this->init(kOuter_StrokeType, &quadPts, lastT, nextT);
-        if (!this->cubicStroke(cubic, &quadPts)) {
-            break;
-        }
+        (void) this->cubicStroke(cubic, &quadPts);
         this->init(kInner_StrokeType, &quadPts, lastT, nextT);
-        if (!this->cubicStroke(cubic, &quadPts)) {
-            break;
-        }
+        (void) this->cubicStroke(cubic, &quadPts);
         lastT = nextT;
     }
     // emit the join even if one stroke succeeded but the last one failed
     // this avoids reversing an inner stroke with a partial path followed by another moveto
     this->setCubicEndNormal(cubic, normalAB, unitAB, &normalCD, &unitCD);
 #else
     bool    degenerateAB = SkPath::IsLineDegenerate(fPrevPt, pt1);
     bool    degenerateBC = SkPath::IsLineDegenerate(pt1, pt2);
     bool    degenerateCD = SkPath::IsLineDegenerate(pt2, pt3);
 
@@ skipping 307 matching lines @@
         default:
             break;
     }
 
     if (fWidth < SkMinScalar(rw, rh) && !fDoFill) {
         r = rect;
         r.inset(radius, radius);
         dst->addRect(r, reverse_direction(dir));
     }
 }