pathops coincidence and security rewrite

src/pathops/SkPathOpsTypes.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkPathOpsTypes_DEFINED
 #define SkPathOpsTypes_DEFINED
 
 #include <float.h>  // for FLT_EPSILON
 #include <math.h>   // for fabs, sqrt
 
 #include "SkFloatingPoint.h"
 #include "SkPath.h"
 #include "SkPathOps.h"
 #include "SkPathOpsDebug.h"
 #include "SkScalar.h"
 
 enum SkPathOpsMask {
     kWinding_PathOpsMask = -1,
     kNo_PathOpsMask = 0,
     kEvenOdd_PathOpsMask = 1
 };
 
+class SkChunkAlloc;
 class SkOpCoincidence;
 class SkOpContour;
 class SkOpContourHead;
 class SkIntersections;
 class SkIntersectionHelper;
 
 class SkOpGlobalState {
 public:
-    SkOpGlobalState(SkOpCoincidence* coincidence, SkOpContourHead* head
-                    SkDEBUGPARAMS(bool debugSkipAssert)
+    SkOpGlobalState(SkOpContourHead* head,
+                    SkChunkAlloc* allocator  SkDEBUGPARAMS(bool debugSkipAssert)
                     SkDEBUGPARAMS(const char* testName));
 
     enum Phase {
         kIntersecting,
         kWalking,
         kFixWinding,
     };
 
     enum {
         kMaxWindingTries = 10
     };
 
+    SkChunkAlloc* allocator() {
+        return fAllocator;
+    }
+
     bool angleCoincidence() const {
         return fAngleCoincidence;
     }
 
     void bumpNested() {
         ++fNested;
     }
 
     void clearNested() {
         fNested = 0;
     }
 
     SkOpCoincidence* coincidence() {
         return fCoincidence;
     }
 
     SkOpContourHead* contourHead() {
         return fContourHead;
     }
 
 #ifdef SK_DEBUG
-    const struct SkOpAngle* debugAngle(int id) const;
+    const class SkOpAngle* debugAngle(int id) const;
+    const SkOpCoincidence* debugCoincidence() const;
     SkOpContour* debugContour(int id);
     const class SkOpPtT* debugPtT(int id) const;
     bool debugRunFail() const;
     const class SkOpSegment* debugSegment(int id) const;
     bool debugSkipAssert() const { return fDebugSkipAssert; }
     const class SkOpSpanBase* debugSpan(int id) const;
     const char* debugTestName() const { return fDebugTestName; }
 #endif
 
 #if DEBUG_T_SECT_LOOP_COUNT
     void debugAddLoopCount(SkIntersections* , const SkIntersectionHelper& ,
         const SkIntersectionHelper& );
     void debugDoYourWorst(SkOpGlobalState* );
     void debugLoopReport();
     void debugResetLoopCounts();
 #endif
 
+#if DEBUG_COINCIDENCE
+    void debugSetCheckHealth(bool check) { fDebugCheckHealth = check; }
+    bool debugCheckHealth() const { return fDebugCheckHealth; }
+#endif
+
     int nested() const {
         return fNested;
     }
 
 #ifdef SK_DEBUG
     int nextAngleID() {
         return ++fAngleID;
     }
 
     int nextCoinID() {
@@ skipping 17 matching lines @@
     }
 #endif
 
     Phase phase() const {
         return fPhase;
     }
 
     void setAngleCoincidence() {
         fAngleCoincidence = true;
     }
+
+    void setCoincidence(SkOpCoincidence* coincidence) {
+        fCoincidence = coincidence;
+    }
     
     void setContourHead(SkOpContourHead* contourHead) {
         fContourHead = contourHead;
     }
 
     void setPhase(Phase phase) {
         SkASSERT(fPhase != phase);
         fPhase = phase;
     }
 
     // called in very rare cases where angles are sorted incorrectly -- signfies op will fail
     void setWindingFailed() {
         fWindingFailed = true;
     }
 
     bool windingFailed() const {
         return fWindingFailed;
     }
 
 private:
+    SkChunkAlloc* fAllocator;
     SkOpCoincidence* fCoincidence;
     SkOpContourHead* fContourHead;
     int fNested;
     bool fWindingFailed;
     bool fAngleCoincidence;
     Phase fPhase;
 #ifdef SK_DEBUG
     const char* fDebugTestName;
     int fAngleID;
     int fCoinID;
     int fContourID;
     int fPtTID;
     int fSegmentID;
     int fSpanID;
     bool fDebugSkipAssert;
 #endif
 #if DEBUG_T_SECT_LOOP_COUNT
     int fDebugLoopCount[3];
     SkPath::Verb fDebugWorstVerb[6];
     SkPoint fDebugWorstPts[24];
     float fDebugWorstWeight[6];
 #endif
+#if DEBUG_COINCIDENCE
+    bool fDebugCheckHealth;
+#endif
 };
 
 // Use Almost Equal when comparing coordinates. Use epsilon to compare T values.
 bool AlmostEqualUlps(float a, float b);
 inline bool AlmostEqualUlps(double a, double b) {
     return AlmostEqualUlps(SkDoubleToScalar(a), SkDoubleToScalar(b));
 }
 
+bool AlmostEqualUlpsNoNormalCheck(float a, float b);
+inline bool AlmostEqualUlpsNoNormalCheck(double a, double b) {
+    return AlmostEqualUlpsNoNormalCheck(SkDoubleToScalar(a), SkDoubleToScalar(b));
+}
+
 bool AlmostEqualUlps_Pin(float a, float b);
 inline bool AlmostEqualUlps_Pin(double a, double b) {
     return AlmostEqualUlps_Pin(SkDoubleToScalar(a), SkDoubleToScalar(b));
 }
 
 // Use Almost Dequal when comparing should not special case denormalized values.
 bool AlmostDequalUlps(float a, float b);
 bool AlmostDequalUlps(double a, double b);
 
 bool NotAlmostEqualUlps(float a, float b);
@@ skipping 56 matching lines @@
 const double FLT_EPSILON_SQUARED = FLT_EPSILON * FLT_EPSILON;
 const double FLT_EPSILON_SQRT = sqrt(FLT_EPSILON);
 const double FLT_EPSILON_INVERSE = 1 / FLT_EPSILON;
 const double DBL_EPSILON_ERR = DBL_EPSILON * 4;  // FIXME: tune -- allow a few bits of error
 const double DBL_EPSILON_SUBDIVIDE_ERR = DBL_EPSILON * 16;
 const double ROUGH_EPSILON = FLT_EPSILON * 64;
 const double MORE_ROUGH_EPSILON = FLT_EPSILON * 256;
 const double WAY_ROUGH_EPSILON = FLT_EPSILON * 2048;
 const double BUMP_EPSILON = FLT_EPSILON * 4096;
 
+const SkScalar INVERSE_NUMBER_RANGE = FLT_EPSILON_ORDERABLE_ERR;
+
 inline bool zero_or_one(double x) {
     return x == 0 || x == 1;
 }
 
 inline bool approximately_zero(double x) {
     return fabs(x) < FLT_EPSILON;
 }
 
 inline bool precisely_zero(double x) {
     return fabs(x) < DBL_EPSILON_ERR;
@@ skipping 32 matching lines @@
 }
 
 inline bool roughly_zero(double x) {
     return fabs(x) < ROUGH_EPSILON;
 }
 
 inline bool approximately_zero_inverse(double x) {
     return fabs(x) > FLT_EPSILON_INVERSE;
 }
 
-// OPTIMIZATION: if called multiple times with the same denom, we want to pass 1/y instead
 inline bool approximately_zero_when_compared_to(double x, double y) {
     return x == 0 || fabs(x) < fabs(y * FLT_EPSILON);
 }
 
 inline bool precisely_zero_when_compared_to(double x, double y) {
     return x == 0 || fabs(x) < fabs(y * DBL_EPSILON);
 }
 
+inline bool roughly_zero_when_compared_to(double x, double y) {
+    return x == 0 || fabs(x) < fabs(y * ROUGH_EPSILON);
+}
+
 // Use this for comparing Ts in the range of 0 to 1. For general numbers (larger and smaller) use
 // AlmostEqualUlps instead.
 inline bool approximately_equal(double x, double y) {
     return approximately_zero(x - y);
 }
 
 inline bool precisely_equal(double x, double y) {
     return precisely_zero(x - y);
 }
 
@@ skipping 219 matching lines @@
 */
 inline int SkDSideBit(double x) {
     return 1 << SKDSide(x);
 }
 
 inline double SkPinT(double t) {
     return precisely_less_than_zero(t) ? 0 : precisely_greater_than_one(t) ? 1 : t;
 }
 
 #endif