path ops -- use standard max, min, double-is-nan

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 78 matching lines @@
 
     void operator-=(const SkDVector& v) {
         fX -= v.fX;
         fY -= v.fY;
     }
 
     // note: this can not be implemented with
     // return approximately_equal(a.fY, fY) && approximately_equal(a.fX, fX);
     // because that will not take the magnitude of the values
     bool approximatelyEqual(const SkDPoint& a) const {
-        double denom = SkTMax<double>(fabs(fX), SkTMax<double>(fabs(fY),
-                SkTMax<double>(fabs(a.fX), fabs(a.fY))));
+        double denom = SkTMax(fabs(fX), SkTMax(fabs(fY),
+                SkTMax(fabs(a.fX), fabs(a.fY))));
         if (denom == 0) {
             return true;
         }
         double inv = 1 / denom;
         return approximately_equal(fX * inv, a.fX * inv)
                 && approximately_equal(fY * inv, a.fY * inv);
     }
 
     bool approximatelyEqual(const SkPoint& a) const {
-        double denom = SkTMax<double>(fabs(fX), SkTMax<double>(fabs(fY),
-                SkScalarToDouble(SkTMax<SkScalar>(fabsf(a.fX), fabsf(a.fY)))));
+        double denom = SkTMax(fabs(fX), SkTMax(fabs(fY),
+                SkScalarToDouble(SkTMax(fabsf(a.fX), fabsf(a.fY)))));
         if (denom == 0) {
             return true;
         }
         double inv = 1 / denom;
         return approximately_equal(fX * inv, a.fX * inv)
                 && approximately_equal(fY * inv, a.fY * inv);
     }
 
     bool approximatelyEqualHalf(const SkDPoint& a) const {
-        double denom = SkTMax<double>(fabs(fX), SkTMax<double>(fabs(fY),
-                SkTMax<double>(fabs(a.fX), fabs(a.fY))));
+        double denom = SkTMax(fabs(fX), SkTMax(fabs(fY),
+                SkTMax(fabs(a.fX), fabs(a.fY))));
         if (denom == 0) {
             return true;
         }
         double inv = 1 / denom;
         return approximately_equal_half(fX * inv, a.fX * inv)
                 && approximately_equal_half(fY * inv, a.fY * inv);
     }
 
     bool approximatelyZero() const {
         return approximately_zero(fX) && approximately_zero(fY);
@@ skipping 17 matching lines @@
     double moreRoughlyEqual(const SkDPoint& a) const {
         return more_roughly_equal(a.fY, fY) && more_roughly_equal(a.fX, fX);
     }
 
     double roughlyEqual(const SkDPoint& a) const {
         return roughly_equal(a.fY, fY) && roughly_equal(a.fX, fX);
     }
 };
 
 #endif