pathops coincidence and security rewrite

tests/PathOpsAngleTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "PathOpsTestCommon.h"
 #include "SkIntersections.h"
 #include "SkOpContour.h"
 #include "SkOpSegment.h"
@@ skipping 176 matching lines @@
                 angle, rAngle, diff, (int) (diff / FLT_EPSILON));
     }
 }
 
 class PathOpsAngleTester {
 public:
     static int After(SkOpAngle& lh, SkOpAngle& rh) {
         return lh.after(&rh);
     }
 
+    static int AllOnOneSide(SkOpAngle& lh, SkOpAngle& rh) {
+        return lh.allOnOneSide(&rh);
+    }
+
     static int ConvexHullOverlaps(SkOpAngle& lh, SkOpAngle& rh) {
         return lh.convexHullOverlaps(&rh);
     }
 
     static int Orderable(SkOpAngle& lh, SkOpAngle& rh) {
         return lh.orderable(&rh);
     }
 
     static int EndsIntersect(SkOpAngle& lh, SkOpAngle& rh) {
         return lh.endsIntersect(&rh);
@@ skipping 21 matching lines @@
     { {{{313.0155029296875, 207.90290832519531}, {320.05078125, 227.58743286132812}}}, 2, {} },
     { {{{313.0155029296875, 207.90290832519531}, {313.98246891063195, 219.33615203830394},
             {320.05078125, 227.58743286132812}}}, 3, {} },
 };
 
 static const int circleDataSetSize = (int) SK_ARRAY_COUNT(circleDataSet);
 
 DEF_TEST(PathOpsAngleCircle, reporter) {
     SkChunkAlloc allocator(4096);
     SkOpContourHead contour;
-    SkOpGlobalState state(nullptr, &contour  SkDEBUGPARAMS(false) SkDEBUGPARAMS(nullptr));
+    SkOpGlobalState state(&contour, &allocator  SkDEBUGPARAMS(false) SkDEBUGPARAMS(nullptr));
     contour.init(&state, false, false);
     for (int index = 0; index < circleDataSetSize; ++index) {
         CircleData& data = circleDataSet[index];
         for (int idx2 = 0; idx2 < data.fPtCount; ++idx2) {
             data.fShortPts[idx2] = data.fPts.fPts[idx2].asSkPoint();
         }
         switch (data.fPtCount) {
             case 2:
-                contour.addLine(data.fShortPts, &allocator);
+                contour.addLine(data.fShortPts);
                 break;
             case 3:
-                contour.addQuad(data.fShortPts, &allocator);
+                contour.addQuad(data.fShortPts);
                 break;
             case 4:
-                contour.addCubic(data.fShortPts, &allocator);
+                contour.addCubic(data.fShortPts);
                 break;
         }
     }
     SkOpSegment* first = contour.first();
-    first->debugAddAngle(0, 1, &allocator);
+    first->debugAddAngle(0, 1);
     SkOpSegment* next = first->next();
-    next->debugAddAngle(0, 1, &allocator);
+    next->debugAddAngle(0, 1);
     PathOpsAngleTester::Orderable(*first->debugLastAngle(), *next->debugLastAngle());
 }
 
 struct IntersectData {
     const SkDCubic fPts;
     const int fPtCount;
     double fTStart;
     double fTEnd;
     SkPoint fShortPts[4];
 };
@@ skipping 149 matching lines @@
 
 static const int intersectDataSetsSize = (int) SK_ARRAY_COUNT(intersectDataSetSizes);
 
 struct FourPoints {
     SkPoint pts[4];
 };
 
 DEF_TEST(PathOpsAngleAfter, reporter) {
     SkChunkAlloc allocator(4096);
     SkOpContourHead contour;
-    SkOpGlobalState state(nullptr, &contour  SkDEBUGPARAMS(false) SkDEBUGPARAMS(nullptr));
+    SkOpGlobalState state(&contour, &allocator  SkDEBUGPARAMS(false) SkDEBUGPARAMS(nullptr));
     contour.init(&state, false, false);
     for (int index = intersectDataSetsSize - 1; index >= 0; --index) {
         IntersectData* dataArray = intersectDataSets[index];
         const int dataSize = intersectDataSetSizes[index];
         for (int index2 = 0; index2 < dataSize - 2; ++index2) {
             allocator.reset();
             contour.reset();
             for (int index3 = 0; index3 < 3; ++index3) {
                 IntersectData& data = dataArray[index2 + index3];
                 SkPoint* temp = (SkPoint*) SkOpTAllocator<FourPoints>::Allocate(&allocator);
                 for (int idx2 = 0; idx2 < data.fPtCount; ++idx2) {
                     temp[idx2] = data.fPts.fPts[idx2].asSkPoint();
                 }
                 switch (data.fPtCount) {
                     case 2: {
-                        contour.addLine(temp, &allocator);
+                        contour.addLine(temp);
                         } break;
                     case 3: {
-                        contour.addQuad(temp, &allocator);
+                        contour.addQuad(temp);
                         } break;
                     case 4: {
-                        contour.addCubic(temp, &allocator);
+                        contour.addCubic(temp);
                         } break;
                 }
             }
             SkOpSegment* seg1 = contour.first();
-            seg1->debugAddAngle(dataArray[index2 + 0].fTStart, dataArray[index2 + 0].fTEnd, &allocator);
+            seg1->debugAddAngle(dataArray[index2 + 0].fTStart, dataArray[index2 + 0].fTEnd);
             SkOpSegment* seg2 = seg1->next();
-            seg2->debugAddAngle(dataArray[index2 + 1].fTStart, dataArray[index2 + 1].fTEnd, &allocator);
+            seg2->debugAddAngle(dataArray[index2 + 1].fTStart, dataArray[index2 + 1].fTEnd);
             SkOpSegment* seg3 = seg2->next();
-            seg3->debugAddAngle(dataArray[index2 + 2].fTStart, dataArray[index2 + 2].fTEnd, &allocator);
+            seg3->debugAddAngle(dataArray[index2 + 2].fTStart, dataArray[index2 + 2].fTEnd);
             SkOpAngle& angle1 = *seg1->debugLastAngle();
             SkOpAngle& angle2 = *seg2->debugLastAngle();
             SkOpAngle& angle3 = *seg3->debugLastAngle();
             PathOpsAngleTester::SetNext(angle1, angle3);
        // These data sets are seeded when the set itself fails, so likely the dataset does not
        // match the expected result. The tests above return 1 when first added, but
        // return 0 after the bug is fixed.
             SkDEBUGCODE(int result =) PathOpsAngleTester::After(angle2, angle1);
             SkASSERT(result == 0 || result == 1);
         }
     }
 }
 
-void SkOpSegment::debugAddAngle(double startT, double endT, SkChunkAlloc* allocator) {
+void SkOpSegment::debugAddAngle(double startT, double endT) {
     SkOpPtT* startPtT = startT == 0 ? fHead.ptT() : startT == 1 ? fTail.ptT()
-            : this->addT(startT, kNoAlias, allocator);
+            : this->addT(startT, kNoAliasMatch, nullptr);
     SkOpPtT* endPtT = endT == 0 ? fHead.ptT() : endT == 1 ? fTail.ptT()
-            : this->addT(endT, kNoAlias, allocator);
-    SkOpAngle* angle = SkOpTAllocator<SkOpAngle>::Allocate(allocator);
+            : this->addT(endT, kNoAliasMatch, nullptr);
+    SkOpAngle* angle = SkOpTAllocator<SkOpAngle>::Allocate(this->globalState()->allocator());
     SkOpSpanBase* startSpan = &fHead;
     while (startSpan->ptT() != startPtT) {
         startSpan = startSpan->upCast()->next();
     }
     SkOpSpanBase* endSpan = &fHead;
     while (endSpan->ptT() != endPtT) {
         endSpan = endSpan->upCast()->next();
     }
     angle->set(startSpan, endSpan);
     if (startT < endT) {
         startSpan->upCast()->setToAngle(angle);
         endSpan->setFromAngle(angle);
     } else {
         endSpan->upCast()->setToAngle(angle);
         startSpan->setFromAngle(angle);
     }
 }
+
+DEF_TEST(PathOpsAngleAllOnOneSide, reporter) {
+    SkChunkAlloc allocator(4096);
+    SkOpContourHead contour;
+    SkOpGlobalState state(&contour, &allocator  SkDEBUGPARAMS(false) SkDEBUGPARAMS(nullptr));
+    contour.init(&state, false, false);
+    SkPoint conicPts[3] = {{494.37100219726562f, 224.66200256347656f},
+        {494.37360910682298f, 224.6729026561527f},
+        {494.37600708007813f, 224.68400573730469f}};
+    SkPoint linePts[2] = {{494.371002f, 224.662003f}, {494.375000f, 224.675995f}};
+    for (int i = 10; i >= 0; --i) {
+        SkPoint modLinePts[2] = { linePts[0], linePts[1] };
+        modLinePts[1].fX += i * .1f;
+        contour.addLine(modLinePts);
+        contour.addQuad(conicPts);
+   //     contour.addConic(conicPts, 0.999935746f, &allocator);
+        SkOpSegment* first = contour.first();
+        first->debugAddAngle(0, 1);
+        SkOpSegment* next = first->next();
+        next->debugAddAngle(0, 1);
+        /* int result = */
+            PathOpsAngleTester::AllOnOneSide(*first->debugLastAngle(), *next->debugLastAngle());
+  //      SkDebugf("i=%d result=%d\n", i , result);
+  //      SkDebugf("");
+    }
+}