Fix assert caused by floating point error in tessellating path renderer.

src/gpu/GrTessellator.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTessellator.h"
 
 #include "GrPathUtils.h"
@@ skipping 235 matching lines @@
         , fRight(nullptr)
         , fPrevEdgeAbove(nullptr)
         , fNextEdgeAbove(nullptr)
         , fPrevEdgeBelow(nullptr)
         , fNextEdgeBelow(nullptr)
         , fLeftPoly(nullptr)
         , fRightPoly(nullptr)
         , fLeftPolyPrev(nullptr)
         , fLeftPolyNext(nullptr)
         , fRightPolyPrev(nullptr)
-        , fRightPolyNext(nullptr) {
+        , fRightPolyNext(nullptr)
+        , fUsedInLeftPoly(false)
+        , fUsedInRightPoly(false) {
             recompute();
         }
     int      fWinding;          // 1 == edge goes downward; -1 = edge goes upward.
     Vertex*  fTop;              // The top vertex in vertex-sort-order (sweep_lt).
     Vertex*  fBottom;           // The bottom vertex in vertex-sort-order.
     Edge*    fLeft;             // The linked list of edges in the active edge list.
     Edge*    fRight;            // "
     Edge*    fPrevEdgeAbove;    // The linked list of edges in the bottom Vertex's "edges above".
     Edge*    fNextEdgeAbove;    // "
     Edge*    fPrevEdgeBelow;    // The linked list of edges in the top Vertex's "edges below".
     Edge*    fNextEdgeBelow;    // "
     Poly*    fLeftPoly;         // The Poly to the left of this edge, if any.
     Poly*    fRightPoly;        // The Poly to the right of this edge, if any.
     Edge*    fLeftPolyPrev;
     Edge*    fLeftPolyNext;
     Edge*    fRightPolyPrev;
     Edge*    fRightPolyNext;
+    bool     fUsedInLeftPoly;
+    bool     fUsedInRightPoly;
     double   fDX;               // The line equation for this edge, in implicit form.
     double   fDY;               // fDY * x + fDX * y + fC = 0, for point (x, y) on the line.
     double   fC;
     double dist(const SkPoint& p) const {
         return fDY * p.fX - fDX * p.fY + fC;
     }
     bool isRightOf(Vertex* v) const {
         return dist(v->fPoint) < 0.0;
     }
     bool isLeftOf(Vertex* v) const {
@@ skipping 65 matching lines @@
             , fNext(nullptr) {
             this->addEdge(edge);
         }
         Side          fSide;
         Edge*         fFirstEdge;
         Edge*         fLastEdge;
         MonotonePoly* fPrev;
         MonotonePoly* fNext;
         void addEdge(Edge* edge) {
             if (fSide == kRight_Side) {
+                if (edge->fUsedInRightPoly) {
+                    return;
+                }
                 list_insert<Edge, &Edge::fRightPolyPrev, &Edge::fRightPolyNext>(
                     edge, fLastEdge, nullptr, &fFirstEdge, &fLastEdge);
+                edge->fUsedInRightPoly = true;
             } else {
+                if (edge->fUsedInLeftPoly) {
+                    return;
+                }
                 list_insert<Edge, &Edge::fLeftPolyPrev, &Edge::fLeftPolyNext>(
                     edge, fLastEdge, nullptr, &fFirstEdge, &fLastEdge);
+                edge->fUsedInLeftPoly = true;
             }
         }
 
         SkPoint* emit(SkPoint* data) {
             Edge* e = fFirstEdge;
             e->fTop->fPrev = e->fTop->fNext = nullptr;
             VertexList vertices;
             vertices.append(e->fTop);
             while (e != nullptr) {
                 e->fBottom->fPrev = e->fBottom->fNext = nullptr;
@@ skipping 26 matching lines @@
                         v = v->fPrev;
                     }
                 } else {
                     v = v->fNext;
                 }
             }
             return data;
         }
     };
     Poly* addEdge(Edge* e, Side side, SkChunkAlloc& alloc) {
-        LOG("addEdge (%g,%g)-(%g,%g) to poly %d, %s side\n",
-               e->fTop->fPoint.fX, e->fTop->fPoint.fY, e->fBottom->fPoint.fX, e->fBottom->fPoint.fY,
-               fID, side == kLeft_Side ? "left" : "right");
+        LOG("addEdge (%g -> %g) to poly %d, %s side\n",
+               e->fTop->fID, e->fBottom->fID, fID, side == kLeft_Side ? "left" : "right");
         Poly* partner = fPartner;
         Poly* poly = this;
         if (partner) {
             fPartner = partner->fPartner = nullptr;
         }
         if (!fTail) {
             fHead = fTail = ALLOC_NEW(MonotonePoly, (e, side), alloc);
             fCount += 2;
         } else if (e->fBottom == fTail->fLastEdge->fBottom) {
             return poly;
@@ skipping 1017 matching lines @@
         }
     }
     int actualCount = static_cast<int>(vertsEnd - *verts);
     SkASSERT(actualCount <= count);
     SkASSERT(pointsEnd - points == actualCount);
     delete[] points;
     return actualCount;
 }
 
 } // namespace