pathops coincidence and security rewrite

src/pathops/SkPathOpsPoint.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 SkPathOpsPoint_DEFINED
 #define SkPathOpsPoint_DEFINED
 
 #include "SkPathOpsTypes.h"
@@ skipping 40 matching lines @@
         SkVector v = {SkDoubleToScalar(fX), SkDoubleToScalar(fY)};
         return v;
     }
 
     // only used by testing
     double cross(const SkDVector& a) const {
         return fX * a.fY - fY * a.fX;
     }
 
     // similar to cross, this bastardization considers nearly coincident to be zero
+    // uses ulps epsilon == 16
     double crossCheck(const SkDVector& a) const {
         double xy = fX * a.fY;
         double yx = fY * a.fX;
         return AlmostEqualUlps(xy, yx) ? 0 : xy - yx;
     }
 
+    // allow tinier numbers
+    double crossNoNormalCheck(const SkDVector& a) const {
+        double xy = fX * a.fY;
+        double yx = fY * a.fX;
+        return AlmostEqualUlpsNoNormalCheck(xy, yx) ? 0 : xy - yx;
+    }
+
     double dot(const SkDVector& a) const {
         return fX * a.fX + fY * a.fY;
     }
 
     double length() const {
         return sqrt(lengthSquared());
     }
 
     double lengthSquared() const {
         return fX * fX + fY * fY;
     }
+
+    void normalize() {
+        double inverseLength = 1 / this->length();
+        fX *= inverseLength;
+        fY *= inverseLength;
+    }
 };
 
 struct SkDPoint {
     double fX;
     double fY;
 
     void set(const SkPoint& pt) {
         fX = pt.fX;
         fY = pt.fY;
     }
@@ skipping 69 matching lines @@
         if (!RoughlyEqualUlps(a.fX, b.fX) || !RoughlyEqualUlps(a.fY, b.fY)) {
             return false;
         }
         SkDPoint dA, dB;
         dA.set(a);
         dB.set(b);
         double dist = dA.distance(dB);  // OPTIMIZATION: can we compare against distSq instead ?
         float tiniest = SkTMin(SkTMin(SkTMin(a.fX, b.fX), a.fY), b.fY);
         float largest = SkTMax(SkTMax(SkTMax(a.fX, b.fX), a.fY), b.fY);
         largest = SkTMax(largest, -tiniest);
-        return AlmostPequalUlps((double) largest, largest + dist); // is dist within ULPS tolerance?
+        return AlmostDequalUlps((double) largest, largest + dist); // is dist within ULPS tolerance?
     }
 
     // only used by testing
     bool approximatelyZero() const {
         return approximately_zero(fX) && approximately_zero(fY);
     }
 
     SkPoint asSkPoint() const {
         SkPoint pt = {SkDoubleToScalar(fX), SkDoubleToScalar(fY)};
         return pt;
@@ skipping 41 matching lines @@
         return RoughlyEqualUlps((double) largest, largest + dist); // is dist within ULPS tolerance?
     }
 
     // utilities callable by the user from the debugger when the implementation code is linked in
     void dump() const;
     static void Dump(const SkPoint& pt);
     static void DumpHex(const SkPoint& pt);
 };
 
 #endif