pathops coincidence and security rewrite

src/pathops/SkOpEdgeBuilder.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkGeometry.h"
 #include "SkOpEdgeBuilder.h"
 #include "SkReduceOrder.h"
 
@@ skipping 18 matching lines @@
 int SkOpEdgeBuilder::count() const {
     SkOpContour* contour = fContoursHead;
     int count = 0;
     while (contour) {
         count += contour->count() > 0;
         contour = contour->next();
     }
     return count;
 }
 
-bool SkOpEdgeBuilder::finish(SkChunkAlloc* allocator) {
+bool SkOpEdgeBuilder::finish() {
     fOperand = false;
-    if (fUnparseable || !walk(allocator)) {
+    if (fUnparseable || !walk()) {
         return false;
     }
     complete();
     if (fCurrentContour && !fCurrentContour->count()) {
         fContoursHead->remove(fCurrentContour);
     }
     return true;
 }
 
 void SkOpEdgeBuilder::closeContour(const SkPoint& curveEnd, const SkPoint& curveStart) {
@@ skipping 103 matching lines @@
     }
     *fPathVerbs.append() = SkPath::kDone_Verb;
     return fPathVerbs.count() - 1;
 }
 
 bool SkOpEdgeBuilder::close() {
     complete();
     return true;
 }
 
-bool SkOpEdgeBuilder::walk(SkChunkAlloc* allocator) {
+bool SkOpEdgeBuilder::walk() {
     uint8_t* verbPtr = fPathVerbs.begin();
     uint8_t* endOfFirstHalf = &verbPtr[fSecondHalf];
     SkPoint* pointsPtr = fPathPts.begin() - 1;
     SkScalar* weightPtr = fWeights.begin();
     SkPath::Verb verb;
     while ((verb = (SkPath::Verb) *verbPtr) != SkPath::kDone_Verb) {
         if (verbPtr == endOfFirstHalf) {
             fOperand = true;
         }
         verbPtr++;
         switch (verb) {
             case SkPath::kMove_Verb:
                 if (fCurrentContour && fCurrentContour->count()) {
                     if (fAllowOpenContours) {
                         complete();
                     } else if (!close()) {
                         return false;
                     }
                 }
                 if (!fCurrentContour) {
-                    fCurrentContour = fContoursHead->appendContour(allocator);
+                    fCurrentContour = fContoursHead->appendContour();
                 }
                 fCurrentContour->init(fGlobalState, fOperand,
                     fXorMask[fOperand] == kEvenOdd_PathOpsMask);
                 pointsPtr += 1;
                 continue;
             case SkPath::kLine_Verb:
-                fCurrentContour->addLine(pointsPtr, fAllocator);
+                fCurrentContour->addLine(pointsPtr);
                 break;
             case SkPath::kQuad_Verb:
-                fCurrentContour->addQuad(pointsPtr, fAllocator);
+                fCurrentContour->addQuad(pointsPtr);
                 break;
             case SkPath::kConic_Verb:
-                fCurrentContour->addConic(pointsPtr, *weightPtr++, fAllocator);
+                fCurrentContour->addConic(pointsPtr, *weightPtr++);
                 break;
             case SkPath::kCubic_Verb: {
                 // Split complex cubics (such as self-intersecting curves or
                 // ones with difficult curvature) in two before proceeding.
                 // This can be required for intersection to succeed.
                 SkScalar splitT;
                 if (SkDCubic::ComplexBreak(pointsPtr, &splitT)) {
                     SkPoint cubicPair[7];
                     SkChopCubicAt(pointsPtr, cubicPair, splitT);
                     if (!SkScalarsAreFinite(&cubicPair[0].fX, SK_ARRAY_COUNT(cubicPair) * 2)) {
                         return false;
                     }
                     SkPoint cStorage[2][4];
                     SkPath::Verb v1 = SkReduceOrder::Cubic(&cubicPair[0], cStorage[0]);
                     SkPath::Verb v2 = SkReduceOrder::Cubic(&cubicPair[3], cStorage[1]);
                     if (v1 != SkPath::kMove_Verb && v2 != SkPath::kMove_Verb) {
                         SkPoint* curve1 = v1 == SkPath::kCubic_Verb ? &cubicPair[0] : cStorage[0];
                         SkPoint* curve2 = v2 == SkPath::kCubic_Verb ? &cubicPair[3] : cStorage[1];
                         for (int index = 0; index < SkPathOpsVerbToPoints(v1); ++index) {
                             force_small_to_zero(&curve1[index]);
                         }
                         for (int index = 0; index < SkPathOpsVerbToPoints(v2); ++index) {
                             force_small_to_zero(&curve2[index]);
                         }
-                        fCurrentContour->addCurve(v1, curve1, fAllocator);
-                        fCurrentContour->addCurve(v2, curve2, fAllocator);
+                        fCurrentContour->addCurve(v1, curve1);
+                        fCurrentContour->addCurve(v2, curve2);
                     } else {
-                        fCurrentContour->addCubic(pointsPtr, fAllocator);
+                        fCurrentContour->addCubic(pointsPtr);
                     }
                 } else {
-                    fCurrentContour->addCubic(pointsPtr, fAllocator);
+                    fCurrentContour->addCubic(pointsPtr);
                 }
                 } break;
             case SkPath::kClose_Verb:
                 SkASSERT(fCurrentContour);
                 if (!close()) {
                     return false;
                 }
                 continue;
             default:
                 SkDEBUGFAIL("bad verb");
                 return false;
         }
         SkASSERT(fCurrentContour);
         fCurrentContour->debugValidate();
         pointsPtr += SkPathOpsVerbToPoints(verb);
     }
    if (fCurrentContour && fCurrentContour->count() &&!fAllowOpenContours && !close()) {
        return false;
    }
    return true;
 }