diff --git a/include/core/SkM44.h b/include/core/SkM44.h
index 1613662..d8c77ea 100644
--- a/include/core/SkM44.h
+++ b/include/core/SkM44.h
@@ -375,7 +375,7 @@
 
         @return  true if matrix has only finite elements
     */
-    bool isFinite() const { return SkScalarsAreFinite(fMat, 16); }
+    bool isFinite() const { return SkIsFinite(fMat, 16); }
 
     /** If this is invertible, return that in inverse and return true. If it is
      *  not invertible, return false and leave the inverse parameter unchanged.
diff --git a/include/core/SkMatrix.h b/include/core/SkMatrix.h
index 96a12f1..10ee699 100644
--- a/include/core/SkMatrix.h
+++ b/include/core/SkMatrix.h
@@ -12,6 +12,7 @@
 #include "include/core/SkRect.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkMacros.h"
 #include "include/private/base/SkTo.h"
 
@@ -1830,7 +1831,7 @@
 
         @return  true if matrix has only finite elements
     */
-    bool isFinite() const { return SkScalarsAreFinite(fMat, 9); }
+    bool isFinite() const { return SkIsFinite(fMat, 9); }
 
 private:
     /** Set if the matrix will map a rectangle to another rectangle. This
diff --git a/include/core/SkPoint3.h b/include/core/SkPoint3.h
index c20a9a4..af2443e 100644
--- a/include/core/SkPoint3.h
+++ b/include/core/SkPoint3.h
@@ -10,7 +10,7 @@
 
 #include "include/core/SkScalar.h"
 #include "include/private/base/SkAPI.h"
-#include "include/private/base/SkAssert.h"
+#include "include/private/base/SkFloatingPoint.h"
 
 struct SK_API SkPoint3 {
     SkScalar fX, fY, fZ;
@@ -114,17 +114,7 @@
      @return  true for values other than infinities and NaN
      */
     bool isFinite() const {
-        SkScalar accum = 0;
-        accum *= fX;
-        accum *= fY;
-        accum *= fZ;
-
-        // accum is either NaN or it is finite (zero).
-        SkASSERT(0 == accum || SkScalarIsNaN(accum));
-
-        // value==value will be true iff value is not NaN
-        // TODO: is it faster to say !accum or accum==accum?
-        return !SkScalarIsNaN(accum);
+        return SkIsFinite(fX, fY) && SkIsFinite(fZ);
     }
 
     /** Returns the dot product of a and b, treating them as 3D vectors
diff --git a/include/core/SkRect.h b/include/core/SkRect.h
index 096c7e1..a07bc50 100644
--- a/include/core/SkRect.h
+++ b/include/core/SkRect.h
@@ -709,18 +709,7 @@
         @return  true if no member is infinite or NaN
     */
     bool isFinite() const {
-        float accum = 0;
-        accum *= fLeft;
-        accum *= fTop;
-        accum *= fRight;
-        accum *= fBottom;
-
-        // accum is either NaN or it is finite (zero).
-        SkASSERT(0 == accum || std::isnan(accum));
-
-        // value==value will be true iff value is not NaN
-        // TODO: is it faster to say !accum or accum==accum?
-        return !std::isnan(accum);
+        return SkIsFinite(fLeft, fTop) && SkIsFinite(fRight, fBottom);
     }
 
     /** Returns left edge of SkRect, if sorted. Call isSorted() to see if SkRect is valid.
diff --git a/include/core/SkScalar.h b/include/core/SkScalar.h
index 6ede6e6..94b1ad6 100644
--- a/include/core/SkScalar.h
+++ b/include/core/SkScalar.h
@@ -63,23 +63,17 @@
 #define SkScalarToDouble(x)     static_cast<double>(x)
 #define SkDoubleToScalar(x)     sk_double_to_float(x)
 
-static inline bool SkScalarIsNaN(SkScalar x) { return x != x; }
+// DEPRECATED: use std::isnan instead.
+static inline bool SkScalarIsNaN(SkScalar x) { return SkIsNaN(x); }
 
-/** Returns true if x is not NaN and not infinite
- */
-static inline bool SkScalarIsFinite(SkScalar x) { return std::isfinite(x); }
+// DEPRECATED: use std::isfinite instead.
+static inline bool SkScalarIsFinite(SkScalar x) { return SkIsFinite(x); }
 
-static inline bool SkScalarsAreFinite(SkScalar a, SkScalar b) {
-    // Subtracting a value from itself will result in zero, except for NAN or ±Inf, which make NAN.
-    // A NAN is not equal to any value, so a NAN or ±Inf in either `a` or `b` will cause the
-    // comparison to evaluate as false.
-    // If both `a` and `b` are finite, the comparison will reduce to `0 == 0`, which is true.
-    return (a - a) == (b - b);
-}
+// DEPRECATED: use std::isfinite instead.
+static inline bool SkScalarsAreFinite(SkScalar a, SkScalar b) { return SkIsFinite(a, b); }
 
-static inline bool SkScalarsAreFinite(const SkScalar array[], int count) {
-    return sk_floats_are_finite(array, count);
-}
+// DEPRECATED: use std::isfinite instead.
+static inline bool SkScalarsAreFinite(const SkScalar p[], int n) { return SkIsFinite(p, n); }
 
 /** Returns the fractional part of the scalar. */
 static inline SkScalar SkScalarFraction(SkScalar x) {
diff --git a/include/core/SkStrokeRec.h b/include/core/SkStrokeRec.h
index 7db4c79..8617b25 100644
--- a/include/core/SkStrokeRec.h
+++ b/include/core/SkStrokeRec.h
@@ -13,6 +13,7 @@
 #include "include/core/SkTypes.h"
 #include "include/private/base/SkMacros.h"
 
+#include <cmath>
 #include <cstdint>
 
 class SkPath;
@@ -72,7 +73,7 @@
     }
 
     void setResScale(SkScalar rs) {
-        SkASSERT(rs > 0 && SkScalarIsFinite(rs));
+        SkASSERT(rs > 0 && std::isfinite(rs));
         fResScale = rs;
     }
 
diff --git a/include/private/base/SkFloatingPoint.h b/include/private/base/SkFloatingPoint.h
index 8efa33c..2cdf75c 100644
--- a/include/private/base/SkFloatingPoint.h
+++ b/include/private/base/SkFloatingPoint.h
@@ -36,13 +36,54 @@
 // as floatf(x + .5f), they would be 1 higher than expected.
 #define sk_float_round(x) (float)sk_double_round((double)(x))
 
-static inline bool sk_floats_are_finite(const float array[], int count) {
-    float prod = 0;
+static inline bool SkIsNaN(float x) {
+    return x != x;
+}
+
+static inline bool SkIsNaN(double x) {
+    return x != x;
+}
+
+// Subtracting a value from itself will result in zero, except for NAN or ±Inf, which make NAN.
+// This generates better code than `std::isfinite` when building with clang-cl (April 2024).
+static inline bool SkIsFinite(float x) {
+    return (x - x) == 0;
+}
+
+static inline bool SkIsFinite(double x) {
+    return (x - x) == 0;
+}
+
+// Subtracting a value from itself will result in zero, except for NAN or ±Inf, which make NAN.
+// A NAN is not equal to any value, so a NAN or ±Inf in either `a` or `b` will cause the
+// comparison to evaluate as false.
+// If both `a` and `b` are finite, the comparison will reduce to `0 == 0`, which is true.
+static inline bool SkIsFinite(float a, float b) {
+    return (a - a) == (b - b);
+}
+
+static inline bool SkIsFinite(double a, double b) {
+    return (a - a) == (b - b);
+}
+
+// Multiplying a group of values against zero will result in zero at each iteration, except for
+// NAN or ±Inf, which will result in NAN and continue resulting in NAN for the rest of the loop.
+static inline bool SkIsFinite(const float array[], int count) {
+    float prod = 0.0f;
     for (int i = 0; i < count; ++i) {
         prod *= array[i];
     }
-    // At this point, prod will either be NaN or 0
-    return prod == 0;   // if prod is NaN, this check will return false
+    // At this point, prod will either be NaN or 0.
+    return prod == 0.0f;
+}
+
+static inline bool SkIsFinite(const double array[], int count) {
+    double prod = 0.0;
+    for (int i = 0; i < count; ++i) {
+        prod *= array[i];
+    }
+    // At this point, prod will either be NaN or 0.
+    return prod == 0.0;
 }
 
 inline constexpr int SK_MaxS32FitsInFloat = 2147483520;
diff --git a/include/private/base/SkPoint_impl.h b/include/private/base/SkPoint_impl.h
index 6385bbe..e3843b2 100644
--- a/include/private/base/SkPoint_impl.h
+++ b/include/private/base/SkPoint_impl.h
@@ -9,7 +9,7 @@
 #define SkPoint_DEFINED
 
 #include "include/private/base/SkAPI.h"
-#include "include/private/base/SkAssert.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkSafe32.h"
 
 #include <cmath>
@@ -410,16 +410,7 @@
         @return  true for values other than infinities and NaN
     */
     bool isFinite() const {
-        float accum = 0;
-        accum *= fX;
-        accum *= fY;
-
-        // accum is either NaN or it is finite (zero).
-        SkASSERT(0 == accum || std::isnan(accum));
-
-        // value==value will be true iff value is not NaN
-        // TODO: is it faster to say !accum or accum==accum?
-        return !std::isnan(accum);
+        return SkIsFinite(fX, fY);
     }
 
     /** Returns true if SkPoint is equivalent to SkPoint constructed from (x, y).
diff --git a/modules/skottie/src/Skottie.cpp b/modules/skottie/src/Skottie.cpp
index b35d3d1..a33ff42 100644
--- a/modules/skottie/src/Skottie.cpp
+++ b/modules/skottie/src/Skottie.cpp
@@ -403,7 +403,7 @@
                duration = sk_ieee_float_divide(outPoint - inPoint, fps);
 
     if (size.isEmpty() || version.isEmpty() || fps <= 0 ||
-        !SkScalarIsFinite(inPoint) || !SkScalarIsFinite(outPoint) || !SkScalarIsFinite(duration)) {
+        !SkIsFinite(inPoint, outPoint) || !SkIsFinite(duration)) {
         if (fLogger) {
             const auto msg = SkStringPrintf(
                          "Invalid animation params (version: %s, size: [%f %f], frame rate: %f, "
diff --git a/modules/skottie/src/effects/LevelsEffect.cpp b/modules/skottie/src/effects/LevelsEffect.cpp
index 57f3d90..9b7a4a0 100644
--- a/modules/skottie/src/effects/LevelsEffect.cpp
+++ b/modules/skottie/src/effects/LevelsEffect.cpp
@@ -97,7 +97,7 @@
 
         for (size_t i = 0; i < 256; ++i) {
             const auto out = out_0 + dOut * std::pow(std::max(t, 0.0f), g);
-            SkASSERT(!SkScalarIsNaN(out));
+            SkASSERT(!SkIsNaN(out));
 
             lut_storage[i] = static_cast<uint8_t>(std::round(SkTPin(out, clip[0], clip[1]) * 255));
 
diff --git a/modules/skparagraph/include/TextStyle.h b/modules/skparagraph/include/TextStyle.h
index 607ac7c..4bc2fb9 100644
--- a/modules/skparagraph/include/TextStyle.h
+++ b/modules/skparagraph/include/TextStyle.h
@@ -22,14 +22,14 @@
 namespace textlayout {
 
 static inline bool nearlyZero(SkScalar x, SkScalar tolerance = SK_ScalarNearlyZero) {
-    if (SkScalarIsFinite(x)) {
+    if (SkIsFinite(x)) {
         return SkScalarNearlyZero(x, tolerance);
     }
     return false;
 }
 
 static inline bool nearlyEqual(SkScalar x, SkScalar y, SkScalar tolerance = SK_ScalarNearlyZero) {
-    if (SkScalarIsFinite(x) && SkScalarIsFinite(x)) {
+    if (SkIsFinite(x, y)) {
         return SkScalarNearlyEqual(x, y, tolerance);
     }
     // Inf == Inf, anything else is false
diff --git a/modules/skparagraph/src/ParagraphCache.cpp b/modules/skparagraph/src/ParagraphCache.cpp
index f9a3b84..f0ad958 100644
--- a/modules/skparagraph/src/ParagraphCache.cpp
+++ b/modules/skparagraph/src/ParagraphCache.cpp
@@ -14,7 +14,7 @@
 namespace {
     int32_t relax(SkScalar a) {
         // This rounding is done to match Flutter tests. Must be removed..
-        if (SkScalarIsFinite(a)) {
+        if (SkIsFinite(a)) {
           auto threshold = SkIntToScalar(1 << 12);
           return SkFloat2Bits(SkScalarRoundToScalar(a * threshold)/threshold);
         } else {
diff --git a/modules/skparagraph/src/ParagraphImpl.cpp b/modules/skparagraph/src/ParagraphImpl.cpp
index f394e8a..eec5557 100644
--- a/modules/skparagraph/src/ParagraphImpl.cpp
+++ b/modules/skparagraph/src/ParagraphImpl.cpp
@@ -141,7 +141,7 @@
         floorWidth = SkScalarFloorToScalar(floorWidth);
     }
 
-    if ((!SkScalarIsFinite(rawWidth) || fLongestLine <= floorWidth) &&
+    if ((!SkIsFinite(rawWidth) || fLongestLine <= floorWidth) &&
         fState >= kLineBroken &&
          fLines.size() == 1 && fLines.front().ellipsis() == nullptr) {
         // Most common case: one line of text (and one line is never justified, so no cluster shifts)
@@ -672,7 +672,7 @@
     const bool isLeftAligned = effectiveAlign == TextAlign::kLeft
         || (effectiveAlign == TextAlign::kJustify && fParagraphStyle.getTextDirection() == TextDirection::kLtr);
 
-    if (!SkScalarIsFinite(maxWidth) && !isLeftAligned) {
+    if (!SkIsFinite(maxWidth) && !isLeftAligned) {
         // Special case: clean all text in case of maxWidth == INF & align != left
         // We had to go through shaping though because we need all the measurement numbers
         fLines.clear();
diff --git a/modules/skparagraph/src/TextLine.cpp b/modules/skparagraph/src/TextLine.cpp
index 1052607..fc7e6d4 100644
--- a/modules/skparagraph/src/TextLine.cpp
+++ b/modules/skparagraph/src/TextLine.cpp
@@ -783,7 +783,7 @@
         return result;
     } else if (run->isPlaceholder()) {
         result.fTextShift = runOffsetInLine;
-        if (SkScalarIsFinite(run->fFontMetrics.fAscent)) {
+        if (SkIsFinite(run->fFontMetrics.fAscent)) {
           result.clip = SkRect::MakeXYWH(runOffsetInLine,
                                          sizes().runTop(run, this->fAscentStyle),
                                          run->advance().fX,
diff --git a/modules/skparagraph/src/TextWrapper.cpp b/modules/skparagraph/src/TextWrapper.cpp
index f3ce9cd..ca4d7dc 100644
--- a/modules/skparagraph/src/TextWrapper.cpp
+++ b/modules/skparagraph/src/TextWrapper.cpp
@@ -288,7 +288,7 @@
     auto maxLines = parent->paragraphStyle().getMaxLines();
     auto align = parent->paragraphStyle().effective_align();
     auto unlimitedLines = maxLines == std::numeric_limits<size_t>::max();
-    auto endlessLine = !SkScalarIsFinite(maxWidth);
+    auto endlessLine = !SkIsFinite(maxWidth);
     auto hasEllipsis = parent->paragraphStyle().ellipsized();
 
     auto disableFirstAscent = parent->paragraphStyle().getTextHeightBehavior() & TextHeightBehavior::kDisableFirstAscent;
diff --git a/modules/skparagraph/tests/SkParagraphTest.cpp b/modules/skparagraph/tests/SkParagraphTest.cpp
index 5be79bd..62d6c9e 100644
--- a/modules/skparagraph/tests/SkParagraphTest.cpp
+++ b/modules/skparagraph/tests/SkParagraphTest.cpp
@@ -6001,8 +6001,8 @@
     paragraph->paint(canvas.get(), 0, 0);
 
     auto impl = static_cast<ParagraphImpl*>(paragraph.get());
-    REPORTER_ASSERT(reporter, SkScalarIsFinite(impl->getPicture()->cullRect().height()));
-    REPORTER_ASSERT(reporter, SkScalarIsFinite(impl->getPicture()->cullRect().width()));
+    REPORTER_ASSERT(reporter, SkIsFinite(impl->getPicture()->cullRect().height()));
+    REPORTER_ASSERT(reporter, SkIsFinite(impl->getPicture()->cullRect().width()));
 }
 
 UNIX_ONLY_TEST(SkParagraph_LineMetricsTextAlign, reporter) {
diff --git a/src/base/SkCubics.cpp b/src/base/SkCubics.cpp
index 64a4beb..4fba299 100644
--- a/src/base/SkCubics.cpp
+++ b/src/base/SkCubics.cpp
@@ -78,7 +78,7 @@
     // If one of R2 Q3 is infinite or nan, subtracting them will also be infinite/nan.
     // If both are infinite or nan, the subtraction will be nan.
     // In either case, we have no finite roots.
-    if (!std::isfinite(R2MinusQ3)) {
+    if (!SkIsFinite(R2MinusQ3)) {
         return 0;
     }
     double adiv3 = a / 3;
@@ -180,7 +180,7 @@
         return start;
     }
     double right = SkCubics::EvalAt(A, B, C, D, stop);
-    if (!std::isfinite(left) || !std::isfinite(right)) {
+    if (!SkIsFinite(left, right)) {
         return -1; // Not going to deal with one or more endpoints being non-finite.
     }
     if ((left > 0 && right > 0) || (left < 0 && right < 0)) {
@@ -207,7 +207,7 @@
 
 int SkCubics::BinarySearchRootsValidT(double A, double B, double C, double D,
                                       double solution[3]) {
-    if (!std::isfinite(A) || !std::isfinite(B) || !std::isfinite(C) || !std::isfinite(D)) {
+    if (!SkIsFinite(A, B) || !SkIsFinite(C, D)) {
         return 0;
     }
     double regions[4] = {0, 0, 0, 1};
diff --git a/src/base/SkVx.h b/src/base/SkVx.h
index b40a8fb..33999ff 100644
--- a/src/base/SkVx.h
+++ b/src/base/SkVx.h
@@ -1003,7 +1003,7 @@
 SINT bool isfinite(const Vec<N, T>& v) {
     // Multiply all values together with 0. If they were all finite, the output is
     // 0 (also finite). If any were not, we'll get nan.
-    return std::isfinite(dot(v, Vec<N, T>(0)));
+    return SkIsFinite(dot(v, Vec<N, T>(0)));
 }
 
 // De-interleaving load of 4 vectors.
diff --git a/src/core/SkBlurMaskFilterImpl.cpp b/src/core/SkBlurMaskFilterImpl.cpp
index aa3d1de..045ae82 100644
--- a/src/core/SkBlurMaskFilterImpl.cpp
+++ b/src/core/SkBlurMaskFilterImpl.cpp
@@ -27,6 +27,7 @@
 #include "include/effects/SkImageFilters.h"
 #include "include/private/base/SkAlign.h"
 #include "include/private/base/SkAssert.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkTemplates.h"
 #include "src/base/SkTLazy.h"
 #include "src/core/SkBlitter_A8.h"
@@ -532,7 +533,7 @@
 void sk_register_blur_maskfilter_createproc() { SK_REGISTER_FLATTENABLE(SkBlurMaskFilterImpl); }
 
 sk_sp<SkMaskFilter> SkMaskFilter::MakeBlur(SkBlurStyle style, SkScalar sigma, bool respectCTM) {
-    if (SkScalarIsFinite(sigma) && sigma > 0) {
+    if (SkIsFinite(sigma) && sigma > 0) {
         return sk_sp<SkMaskFilter>(new SkBlurMaskFilterImpl(sigma, style, respectCTM));
     }
     return nullptr;
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 7f9ad01..d39ef07 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -35,6 +35,7 @@
 #include "include/core/SkTypes.h"
 #include "include/core/SkVertices.h"
 #include "include/private/base/SkDebug.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkSafe32.h"
 #include "include/private/base/SkTPin.h"
 #include "include/private/base/SkTemplates.h"
@@ -2076,7 +2077,7 @@
 static bool fillable(const SkRect& r) {
     SkScalar w = r.width();
     SkScalar h = r.height();
-    return SkScalarIsFinite(w) && w > 0 && SkScalarIsFinite(h) && h > 0;
+    return SkIsFinite(w, h) && w > 0 && h > 0;
 }
 
 static SkPaint clean_paint_for_lattice(const SkPaint* paint) {
diff --git a/src/core/SkContourMeasure.cpp b/src/core/SkContourMeasure.cpp
index 1f1bf9c..8c88119 100644
--- a/src/core/SkContourMeasure.cpp
+++ b/src/core/SkContourMeasure.cpp
@@ -437,7 +437,7 @@
 
     }
 
-    if (!SkScalarIsFinite(distance)) {
+    if (!SkIsFinite(distance)) {
         return nullptr;
     }
     if (fSegments.empty()) {
@@ -605,7 +605,7 @@
 }
 
 bool SkContourMeasure::getPosTan(SkScalar distance, SkPoint* pos, SkVector* tangent) const {
-    if (SkScalarIsNaN(distance)) {
+    if (SkIsNaN(distance)) {
         return false;
     }
 
@@ -621,7 +621,7 @@
 
     SkScalar        t;
     const Segment*  seg = this->distanceToSegment(distance, &t);
-    if (SkScalarIsNaN(t)) {
+    if (SkIsNaN(t)) {
         return false;
     }
 
@@ -672,11 +672,11 @@
     SkPoint  p;
     SkScalar startT, stopT;
     const Segment* seg = this->distanceToSegment(startD, &startT);
-    if (!SkScalarIsFinite(startT)) {
+    if (!SkIsFinite(startT)) {
         return false;
     }
     const Segment* stopSeg = this->distanceToSegment(stopD, &stopT);
-    if (!SkScalarIsFinite(stopT)) {
+    if (!SkIsFinite(stopT)) {
         return false;
     }
     SkASSERT(seg <= stopSeg);
diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp
index f0ba91e..78ba942 100644
--- a/src/core/SkDraw.cpp
+++ b/src/core/SkDraw.cpp
@@ -18,6 +18,7 @@
 #include "include/private/base/SkAssert.h"
 #include "include/private/base/SkDebug.h"
 #include "include/private/base/SkFixed.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkTemplates.h"
 #include "include/private/base/SkTo.h"
 #include "src/base/SkArenaAlloc.h"
@@ -265,7 +266,7 @@
                 n = MAX_DEV_PTS;
             }
             fCTM->mapPoints(devPts, pts, n);
-            if (!SkScalarsAreFinite(&devPts[0].fX, n * 2)) {
+            if (!SkIsFinite(&devPts[0].fX, n * 2)) {
                 return;
             }
             proc(rec, devPts, n, bltr);
diff --git a/src/core/SkDrawBase.cpp b/src/core/SkDrawBase.cpp
index 2c4a70a..4dce30d 100644
--- a/src/core/SkDrawBase.cpp
+++ b/src/core/SkDrawBase.cpp
@@ -20,6 +20,7 @@
 #include "include/private/base/SkAssert.h"
 #include "include/private/base/SkCPUTypes.h"
 #include "include/private/base/SkDebug.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkTemplates.h"
 #include "src/base/SkTLazy.h"
 #include "src/base/SkZip.h"
@@ -610,7 +611,7 @@
     }
 
     // needed?
-    if (!SkScalarsAreFinite(&pts[0].fX, count * 2)) {
+    if (!SkIsFinite(&pts[0].fX, count * 2)) {
         return;
     }
 
diff --git a/src/core/SkDraw_vertices.cpp b/src/core/SkDraw_vertices.cpp
index 48bb030..132988f 100644
--- a/src/core/SkDraw_vertices.cpp
+++ b/src/core/SkDraw_vertices.cpp
@@ -335,7 +335,7 @@
         dev3 = outerAlloc.makeArray<SkPoint3>(vertexCount);
         fCTM->mapHomogeneousPoints(dev3, info.positions(), vertexCount);
         // similar to the bounds check for 2d points (below)
-        if (!SkScalarsAreFinite((const SkScalar*)dev3, vertexCount * 3)) {
+        if (!SkIsFinite((const SkScalar*)dev3, vertexCount * 3)) {
             return;
         }
     } else {
diff --git a/src/core/SkEdgeBuilder.cpp b/src/core/SkEdgeBuilder.cpp
index 4cc560a..0be077b 100644
--- a/src/core/SkEdgeBuilder.cpp
+++ b/src/core/SkEdgeBuilder.cpp
@@ -13,6 +13,7 @@
 #include "include/core/SkTypes.h"
 #include "include/private/base/SkDebug.h"
 #include "include/private/base/SkFixed.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkSafe32.h"
 #include "include/private/base/SkTo.h"
 #include "src/base/SkSafeMath.h"
@@ -320,7 +321,7 @@
 
             while ((verb = clipper->next(pts)) != SkPath::kDone_Verb) {
                 const int count = SkPathPriv::PtsInIter(verb);
-                if (!SkScalarsAreFinite(&pts[0].fX, count*2)) {
+                if (!SkIsFinite(&pts[0].fX, count*2)) {
                     rec->fIsFinite = false;
                     return;
                 }
diff --git a/src/core/SkFont.cpp b/src/core/SkFont.cpp
index b079a53..7bb8235 100644
--- a/src/core/SkFont.cpp
+++ b/src/core/SkFont.cpp
@@ -19,6 +19,7 @@
 #include "include/core/SkTypeface.h"
 #include "include/core/SkTypes.h"
 #include "include/private/base/SkDebug.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkPoint_impl.h"
 #include "include/private/base/SkSpan_impl.h"
 #include "include/private/base/SkTemplates.h"
@@ -369,7 +370,7 @@
     } else {
         // approximate the scale since we can't get it directly from the matrix
         SkScalar maxScaleSq = SkMatrixPriv::DifferentialAreaScale(matrix, textLocation);
-        if (SkScalarIsFinite(maxScaleSq) && !SkScalarNearlyZero(maxScaleSq)) {
+        if (SkIsFinite(maxScaleSq) && !SkScalarNearlyZero(maxScaleSq)) {
             return font.getSize() * SkScalarSqrt(maxScaleSq);
         } else {
             return -font.getSize();
diff --git a/src/core/SkFontPriv.h b/src/core/SkFontPriv.h
index 03a6e50..7c2808f 100644
--- a/src/core/SkFontPriv.h
+++ b/src/core/SkFontPriv.h
@@ -76,9 +76,9 @@
                                                    const SkPoint& textLocation);
 
     static bool IsFinite(const SkFont& font) {
-        return SkScalarIsFinite(font.getSize()) &&
-               SkScalarIsFinite(font.getScaleX()) &&
-               SkScalarIsFinite(font.getSkewX());
+        return SkIsFinite(font.getSize()) &&
+               SkIsFinite(font.getScaleX()) &&
+               SkIsFinite(font.getSkewX());
     }
 
     // Returns the number of elements (characters or glyphs) in the array.
diff --git a/src/core/SkGeometry.cpp b/src/core/SkGeometry.cpp
index 70976a6..b935310 100644
--- a/src/core/SkGeometry.cpp
+++ b/src/core/SkGeometry.cpp
@@ -64,7 +64,7 @@
     }
 
     SkScalar r = numer / denom;
-    if (SkScalarIsNaN(r)) {
+    if (SkIsNaN(r)) {
         return 0;
     }
     SkASSERTF(r >= 0 && r < SK_Scalar1, "numer %f, denom %f, r %f", numer, denom, r);
@@ -108,7 +108,7 @@
     }
     dr = sqrt(dr);
     SkScalar R = SkDoubleToScalar(dr);
-    if (!SkScalarIsFinite(R)) {
+    if (!SkIsFinite(R)) {
         return return_check_zero(0);
     }
 
@@ -360,7 +360,7 @@
         return 1;
     }
     SkScalar t = numer / denom;
-    SkASSERT((0 <= t && t < 1) || SkScalarIsNaN(t));
+    SkASSERT((0 <= t && t < 1) || SkIsNaN(t));
     return t;
 }
 
@@ -1322,7 +1322,7 @@
     dst[1].fW = tmp2[2].fZ / root;
     SkASSERT(sizeof(dst[0]) == sizeof(SkScalar) * 7);
     SkASSERT(0 == offsetof(SkConic, fPts[0].fX));
-    return SkScalarsAreFinite(&dst[0].fPts[0].fX, 7 * 2);
+    return SkIsFinite(&dst[0].fPts[0].fX, 7 * 2);
 }
 
 void SkConic::chopAt(SkScalar t1, SkScalar t2, SkConic* dst) const {
@@ -1486,7 +1486,7 @@
 #define kMaxConicToQuadPOW2     5
 
 int SkConic::computeQuadPOW2(SkScalar tol) const {
-    if (tol < 0 || !SkScalarIsFinite(tol) || !SkPointPriv::AreFinite(fPts, 3)) {
+    if (tol < 0 || !SkIsFinite(tol) || !SkPointPriv::AreFinite(fPts, 3)) {
         return 0;
     }
 
@@ -1782,7 +1782,7 @@
     const SkPoint finalP = { x, y };
     const SkPoint& lastQ = quadrantPts[quadrant * 2];  // will already be a unit-vector
     const SkScalar dot = SkVector::DotProduct(lastQ, finalP);
-    if (SkScalarIsNaN(dot)) {
+    if (SkIsNaN(dot)) {
         return 0;
     }
     SkASSERT(0 <= dot && dot <= SK_Scalar1 + SK_ScalarNearlyZero);
diff --git a/src/core/SkGeometry.h b/src/core/SkGeometry.h
index 5a84035..f597aad 100644
--- a/src/core/SkGeometry.h
+++ b/src/core/SkGeometry.h
@@ -11,6 +11,7 @@
 #include "include/core/SkPoint.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "src/base/SkVx.h"
 
 #include <cstring>
@@ -348,12 +349,12 @@
     }
 
     void setW(SkScalar w) {
-        if (SkScalarIsFinite(w)) {
+        if (SkIsFinite(w)) {
             SkASSERT(w > 0);
         }
 
         // Guard against bad weights by forcing them to 1.
-        fW = w > 0 && SkScalarIsFinite(w) ? w : 1;
+        fW = w > 0 && SkIsFinite(w) ? w : 1;
     }
 
     /**
diff --git a/src/core/SkGlyphRunPainter.cpp b/src/core/SkGlyphRunPainter.cpp
index 14481dc..806e8b3 100644
--- a/src/core/SkGlyphRunPainter.cpp
+++ b/src/core/SkGlyphRunPainter.cpp
@@ -22,6 +22,7 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkSpan_impl.h"
 #include "include/private/base/SkTArray.h"
 #include "src/core/SkGlyph.h"
@@ -64,7 +65,7 @@
     int rejectedSize = 0;
     strike->lock();
     for (auto [glyphID, pos] : source) {
-        if (!SkScalarsAreFinite(pos.x(), pos.y())) {
+        if (!SkIsFinite(pos.x(), pos.y())) {
             continue;
         }
         const SkPackedGlyphID packedID{glyphID};
@@ -95,7 +96,7 @@
     int rejectedSize = 0;
     strike->lock();
     for (auto [glyphID, pos] : source) {
-        if (!SkScalarsAreFinite(pos.x(), pos.y())) {
+        if (!SkIsFinite(pos.x(), pos.y())) {
             continue;
         }
         const SkPackedGlyphID packedID{glyphID};
@@ -133,7 +134,7 @@
     int rejectedSize = 0;
     strike->lock();
     for (auto [glyphID, pos] : source) {
-        if (!SkScalarsAreFinite(pos.x(), pos.y())) {
+        if (!SkIsFinite(pos.x(), pos.y())) {
             continue;
         }
 
diff --git a/src/core/SkImageFilterTypes.cpp b/src/core/SkImageFilterTypes.cpp
index 55251b4..da41408 100644
--- a/src/core/SkImageFilterTypes.cpp
+++ b/src/core/SkImageFilterTypes.cpp
@@ -98,7 +98,7 @@
         // Perspective, which has a non-uniform scaling effect on the filter. Pick a single scale
         // factor that best matches where the filter will be evaluated.
         SkScalar approxScale = SkMatrixPriv::DifferentialAreaScale(transform, representativePoint);
-        if (SkScalarIsFinite(approxScale) && !SkScalarNearlyZero(approxScale)) {
+        if (SkIsFinite(approxScale) && !SkScalarNearlyZero(approxScale)) {
             // Now take the sqrt to go from an area scale factor to a scaling per X and Y
             approxScale = SkScalarSqrt(approxScale);
         } else {
diff --git a/src/core/SkImageFilterTypes.h b/src/core/SkImageFilterTypes.h
index 43b2116..f86af4c 100644
--- a/src/core/SkImageFilterTypes.h
+++ b/src/core/SkImageFilterTypes.h
@@ -21,6 +21,7 @@
 #include "include/core/SkSurfaceProps.h"
 #include "include/core/SkTileMode.h"
 #include "include/core/SkTypes.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkTArray.h"
 #include "include/private/base/SkTPin.h"
 #include "include/private/base/SkTo.h"
@@ -75,7 +76,7 @@
     Vector(SkScalar x, SkScalar y) : fX(x), fY(y) {}
     explicit Vector(const SkVector& v) : fX(v.fX), fY(v.fY) {}
 
-    bool isFinite() const { return SkScalarsAreFinite(fX, fY); }
+    bool isFinite() const { return SkIsFinite(fX, fY); }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/SkM44.cpp b/src/core/SkM44.cpp
index 7d7f6e4..9e9dd53 100644
--- a/src/core/SkM44.cpp
+++ b/src/core/SkM44.cpp
@@ -278,7 +278,7 @@
 
 SkM44& SkM44::setRotate(SkV3 axis, SkScalar radians) {
     SkScalar len = axis.length();
-    if (len > 0 && SkScalarIsFinite(len)) {
+    if (len > 0 && SkIsFinite(len)) {
         this->setRotateUnit(axis * (SK_Scalar1 / len), radians);
     } else {
         this->setIdentity();
diff --git a/src/core/SkMatrix.cpp b/src/core/SkMatrix.cpp
index 245a0ab..bfaf915 100644
--- a/src/core/SkMatrix.cpp
+++ b/src/core/SkMatrix.cpp
@@ -823,7 +823,7 @@
                 SkScalar invY = sk_ieee_float_divide(1.f, fMat[kMScaleY]);
                 // Denormalized (non-zero) scale factors will overflow when inverted, in which case
                 // the inverse matrix would not be finite, so return false.
-                if (!SkScalarsAreFinite(invX, invY)) {
+                if (!SkIsFinite(invX, invY)) {
                     return false;
                 }
 
@@ -1497,7 +1497,7 @@
             results[1] = apluscdiv2 + x;
         }
     }
-    if (!SkScalarIsFinite(results[0])) {
+    if (!SkIsFinite(results[0])) {
         return false;
     }
     // Due to the floating point inaccuracy, there might be an error in a, b, c
@@ -1508,7 +1508,7 @@
     }
     results[0] = SkScalarSqrt(results[0]);
     if (kBoth_MinMaxOrBoth == MIN_MAX_OR_BOTH) {
-        if (!SkScalarIsFinite(results[1])) {
+        if (!SkIsFinite(results[1])) {
             return false;
         }
         if (results[1] < 0) {
@@ -1563,7 +1563,7 @@
 
     const SkScalar sx = SkVector::Length(this->getScaleX(), this->getSkewY());
     const SkScalar sy = SkVector::Length(this->getSkewX(), this->getScaleY());
-    if (!SkScalarIsFinite(sx) || !SkScalarIsFinite(sy) ||
+    if (!SkIsFinite(sx) || !SkIsFinite(sy) ||
         SkScalarNearlyZero(sx) || SkScalarNearlyZero(sy)) {
         return false;
     }
@@ -1878,7 +1878,7 @@
     // Not sure how to handle perspective differently, so we just don't try (yet)
     SkScalar sx = SkPoint::Length(matrix[SkMatrix::kMScaleX], matrix[SkMatrix::kMSkewY]);
     SkScalar sy = SkPoint::Length(matrix[SkMatrix::kMSkewX],  matrix[SkMatrix::kMScaleY]);
-    if (SkScalarsAreFinite(sx, sy)) {
+    if (SkIsFinite(sx, sy)) {
         SkScalar scale = std::max(sx, sy);
         if (scale > 0) {
             return scale;
diff --git a/src/core/SkMatrixInvert.cpp b/src/core/SkMatrixInvert.cpp
index ea8d367..7fe20b1 100644
--- a/src/core/SkMatrixInvert.cpp
+++ b/src/core/SkMatrixInvert.cpp
@@ -25,7 +25,7 @@
         outMatrix[3] =  a00 * invdet;
         // If 1/det overflows to infinity (i.e. det is denormalized) or any of the inverted matrix
         // values is non-finite, return zero to indicate a non-invertible matrix.
-        if (!SkScalarsAreFinite(outMatrix, 4)) {
+        if (!SkIsFinite(outMatrix, 4)) {
             determinant = 0.0f;
         }
     }
@@ -62,7 +62,7 @@
         outMatrix[8] = ( a11 * a00 - a01 * a10) * invdet;
         // If 1/det overflows to infinity (i.e. det is denormalized) or any of the inverted matrix
         // values is non-finite, return zero to indicate a non-invertible matrix.
-        if (!SkScalarsAreFinite(outMatrix, 9)) {
+        if (!SkIsFinite(outMatrix, 9)) {
             determinant = 0.0f;
         }
     }
@@ -136,7 +136,7 @@
 
         // If 1/det overflows to infinity (i.e. det is denormalized) or any of the inverted matrix
         // values is non-finite, return zero to indicate a non-invertible matrix.
-        if (!SkScalarsAreFinite(outMatrix, 16)) {
+        if (!SkIsFinite(outMatrix, 16)) {
             determinant = 0.0f;
         }
     }
diff --git a/src/core/SkMipmap.cpp b/src/core/SkMipmap.cpp
index ba2d548..5a46c53 100644
--- a/src/core/SkMipmap.cpp
+++ b/src/core/SkMipmap.cpp
@@ -205,13 +205,13 @@
     const float scale = std::sqrt(scaleSize.width() * scaleSize.height());
 #endif
 
-    if (scale >= SK_Scalar1 || scale <= 0 || !SkScalarIsFinite(scale)) {
+    if (scale >= SK_Scalar1 || scale <= 0 || !SkIsFinite(scale)) {
         return -1;
     }
 
     // The -0.5 bias here is to emulate GPU's sharpen mipmap option.
     float L = std::max(-SkScalarLog2(scale) - 0.5f, 0.f);
-    if (!SkScalarIsFinite(L)) {
+    if (!SkIsFinite(L)) {
         return -1;
     }
     return L;
diff --git a/src/core/SkPath.cpp b/src/core/SkPath.cpp
index 3ca857a..bd21fc8 100644
--- a/src/core/SkPath.cpp
+++ b/src/core/SkPath.cpp
@@ -754,7 +754,7 @@
     // check for <= 0 or NaN with this test
     if (!(w > 0)) {
         this->lineTo(x2, y2);
-    } else if (!SkScalarIsFinite(w)) {
+    } else if (!SkIsFinite(w)) {
         this->lineTo(x1, y1);
         this->lineTo(x2, y2);
     } else if (SK_Scalar1 == w) {
@@ -1309,7 +1309,7 @@
     int segments = SkScalarCeilToInt(SkScalarAbs(thetaArc / (2 * SK_ScalarPI / 3)));
     SkScalar thetaWidth = thetaArc / segments;
     SkScalar t = SkScalarTan(0.5f * thetaWidth);
-    if (!SkScalarIsFinite(t)) {
+    if (!SkIsFinite(t)) {
         return *this;
     }
     SkScalar startTheta = theta1;
@@ -1807,8 +1807,8 @@
         // A special case: if both points are NaN, SkPoint::operation== returns
         // false, but the iterator expects that they are treated as the same.
         // (consider SkPoint is a 2-dimension float point).
-        if (SkScalarIsNaN(fLastPt.fX) || SkScalarIsNaN(fLastPt.fY) ||
-            SkScalarIsNaN(fMoveTo.fX) || SkScalarIsNaN(fMoveTo.fY)) {
+        if (SkIsNaN(fLastPt.fX) || SkIsNaN(fLastPt.fY) ||
+            SkIsNaN(fMoveTo.fX) || SkIsNaN(fMoveTo.fY)) {
             return kClose_Verb;
         }
 
@@ -2225,7 +2225,7 @@
 private:
     DirChange directionChange(const SkVector& curVec) {
         SkScalar cross = SkPoint::CrossProduct(fLastVec, curVec);
-        if (!SkScalarIsFinite(cross)) {
+        if (!SkIsFinite(cross)) {
                 return kUnknown_DirChange;
         }
         if (cross == 0) {
@@ -3760,7 +3760,7 @@
         b *= dscale;
         c *= dscale;
         // check if we're not finite, or normal is zero-length
-        if (!std::isfinite(a) || !std::isfinite(b) || !std::isfinite(c) ||
+        if (!SkIsFinite(a, b) || !SkIsFinite(c) ||
             (a == 0 && b == 0)) {
             fA = fB = 0;
             fC = SK_Scalar1;
diff --git a/src/core/SkPathBuilder.cpp b/src/core/SkPathBuilder.cpp
index 4a2ef01..c0b7899 100644
--- a/src/core/SkPathBuilder.cpp
+++ b/src/core/SkPathBuilder.cpp
@@ -10,6 +10,7 @@
 #include "include/core/SkMatrix.h"
 #include "include/core/SkRRect.h"
 #include "include/private/SkPathRef.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkSafe32.h"
 #include "src/base/SkVx.h"
 #include "src/core/SkGeometry.h"
@@ -541,7 +542,7 @@
     int segments = SkScalarCeilToInt(SkScalarAbs(thetaArc / (2 * SK_ScalarPI / 3)));
     SkScalar thetaWidth = thetaArc / segments;
     SkScalar t = SkScalarTan(0.5f * thetaWidth);
-    if (!SkScalarIsFinite(t)) {
+    if (!SkIsFinite(t)) {
         return *this;
     }
     SkScalar startTheta = theta1;
diff --git a/src/core/SkPoint.cpp b/src/core/SkPoint.cpp
index 9409f36..6538320 100644
--- a/src/core/SkPoint.cpp
+++ b/src/core/SkPoint.cpp
@@ -53,7 +53,7 @@
     x *= dscale;
     y *= dscale;
     // check if we're not finite, or we're zero-length
-    if (!std::isfinite(x) || !std::isfinite(y) || (x == 0 && y == 0)) {
+    if (!SkIsFinite(x, y) || (x == 0 && y == 0)) {
         pt->set(0, 0);
         return false;
     }
@@ -78,7 +78,7 @@
 
 float SkPoint::Length(float dx, float dy) {
     float mag2 = dx * dx + dy * dy;
-    if (std::isfinite(mag2)) {
+    if (SkIsFinite(mag2)) {
         return std::sqrt(mag2);
     } else {
         double xx = dx;
@@ -117,7 +117,7 @@
     temp *= det;
     // It's possible we have a degenerate line vector, or we're so far away it looks degenerate
     // In this case, return squared distance to point A.
-    if (!std::isfinite(temp)) {
+    if (!SkIsFinite(temp)) {
         return LengthSqd(v);
     }
     return temp;
@@ -160,7 +160,7 @@
         temp *= det;
         // It's possible we have a degenerate segment, or we're so far away it looks degenerate
         // In this case, return squared distance to point A.
-        if (!std::isfinite(temp)) {
+        if (!SkIsFinite(temp)) {
             return LengthSqd(v);
         }
         return temp;
diff --git a/src/core/SkPoint3.cpp b/src/core/SkPoint3.cpp
index c5e5b6d..bb573a5 100644
--- a/src/core/SkPoint3.cpp
+++ b/src/core/SkPoint3.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "include/core/SkPoint3.h"
+#include "include/private/base/SkFloatingPoint.h"
 
 #include <cmath>
 
@@ -27,7 +28,7 @@
 
 SkScalar SkPoint3::Length(SkScalar x, SkScalar y, SkScalar z) {
     float magSq = get_length_squared(x, y, z);
-    if (SkScalarIsFinite(magSq)) {
+    if (SkIsFinite(magSq)) {
         return std::sqrt(magSq);
     } else {
         double xx = x;
@@ -54,7 +55,7 @@
     // sqrtf does not provide enough precision; since sqrt takes a double,
     // there's no additional penalty to storing invScale in a double
     double invScale;
-    if (std::isfinite(magSq)) {
+    if (SkIsFinite(magSq)) {
         invScale = magSq;
     } else {
         // our magSq step overflowed to infinity, so use doubles instead.
@@ -70,7 +71,7 @@
     fX *= scale;
     fY *= scale;
     fZ *= scale;
-    if (!std::isfinite(fX) || !std::isfinite(fY) || !std::isfinite(fZ)) {
+    if (!SkIsFinite(fX, fY) || !SkIsFinite(fZ)) {
         this->set(0, 0, 0);
         return false;
     }
diff --git a/src/core/SkPointPriv.h b/src/core/SkPointPriv.h
index c8a6d52..b607f67 100644
--- a/src/core/SkPointPriv.h
+++ b/src/core/SkPointPriv.h
@@ -20,13 +20,13 @@
     };
 
     static bool AreFinite(const SkPoint array[], int count) {
-        return SkScalarsAreFinite(&array[0].fX, count << 1);
+        return SkIsFinite(&array[0].fX, count << 1);
     }
 
     static const SkScalar* AsScalars(const SkPoint& pt) { return &pt.fX; }
 
     static bool CanNormalize(SkScalar dx, SkScalar dy) {
-        return SkScalarsAreFinite(dx, dy) && (dx || dy);
+        return SkIsFinite(dx, dy) && (dx || dy);
     }
 
     static SkScalar DistanceToLineBetweenSqd(const SkPoint& pt, const SkPoint& a,
diff --git a/src/core/SkRRect.cpp b/src/core/SkRRect.cpp
index 57991b7..2b4d76f 100644
--- a/src/core/SkRRect.cpp
+++ b/src/core/SkRRect.cpp
@@ -54,7 +54,7 @@
         return;
     }
 
-    if (!SkScalarsAreFinite(xRad, yRad)) {
+    if (!SkIsFinite(xRad, yRad)) {
         xRad = yRad = 0;    // devolve into a simple rect
     }
 
@@ -118,8 +118,7 @@
         return;
     }
 
-    const SkScalar array[4] = { leftRad, topRad, rightRad, bottomRad };
-    if (!SkScalarsAreFinite(array, 4)) {
+    if (!SkIsFinite(leftRad, topRad) || !SkIsFinite(rightRad, bottomRad)) {
         this->setRect(rect);    // devolve into a simple rect
         return;
     }
@@ -192,7 +191,7 @@
         return;
     }
 
-    if (!SkScalarsAreFinite(&radii[0].fX, 8)) {
+    if (!SkIsFinite(&radii[0].fX, 8)) {
         this->setRect(rect);    // devolve into a simple rect
         return;
     }
diff --git a/src/core/SkScan_Hairline.cpp b/src/core/SkScan_Hairline.cpp
index 7b5473e..d389a5d 100644
--- a/src/core/SkScan_Hairline.cpp
+++ b/src/core/SkScan_Hairline.cpp
@@ -13,6 +13,7 @@
 #include "include/core/SkScalar.h"
 #include "include/private/base/SkAssert.h"
 #include "include/private/base/SkFixed.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkMath.h"
 #include "include/private/base/SkSafe32.h"
 #include "src/base/SkMathPriv.h"
@@ -278,7 +279,7 @@
 }
 
 static SkRect compute_nocheck_quad_bounds(const SkPoint pts[3]) {
-    SkASSERT(SkScalarsAreFinite(&pts[0].fX, 6));
+    SkASSERT(SkIsFinite(&pts[0].fX, 6));
 
     float2 min = float2::Load(pts);
     float2 max = min;
@@ -411,7 +412,7 @@
 }
 
 static SkRect compute_nocheck_cubic_bounds(const SkPoint pts[4]) {
-    SkASSERT(SkScalarsAreFinite(&pts[0].fX, 8));
+    SkASSERT(SkIsFinite(&pts[0].fX, 8));
 
     float2 min = float2::Load(pts);
     float2 max = min;
diff --git a/src/core/SkString.cpp b/src/core/SkString.cpp
index 08aac66..53c1d9a 100644
--- a/src/core/SkString.cpp
+++ b/src/core/SkString.cpp
@@ -8,6 +8,7 @@
 #include "include/core/SkString.h"
 
 #include "include/private/base/SkDebug.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkMalloc.h"
 #include "include/private/base/SkTPin.h"
 #include "include/private/base/SkTo.h"
@@ -163,11 +164,11 @@
 char* SkStrAppendScalar(char string[], SkScalar value) {
     // Handle infinity and NaN ourselves to ensure consistent cross-platform results.
     // (e.g.: `inf` versus `1.#INF00`, `nan` versus `-nan` for high-bit-set NaNs)
-    if (SkScalarIsNaN(value)) {
+    if (SkIsNaN(value)) {
         strcpy(string, "nan");
         return string + 3;
     }
-    if (!SkScalarIsFinite(value)) {
+    if (!SkIsFinite(value)) {
         if (value > 0) {
             strcpy(string, "inf");
             return string + 3;
diff --git a/src/core/SkStroke.cpp b/src/core/SkStroke.cpp
index 4d607f7..b442ca3 100644
--- a/src/core/SkStroke.cpp
+++ b/src/core/SkStroke.cpp
@@ -697,7 +697,7 @@
     // SkFindConicMaxCurvature would be a better solution, once we know how to
     // implement it. Quad curvature is a reasonable substitute
     SkScalar t = SkFindQuadMaxCurvature(conic.fPts);
-    if (0 == t || SkScalarIsNaN(t)) {
+    if (0 == t || SkIsNaN(t)) {
         return kLine_ReductionType;
     }
     conic.evalAt(t, reduction, nullptr);
@@ -925,7 +925,7 @@
              byLen  * axLen         -   ayLen          * bxLen         ( == denom )
      */
     SkScalar denom = aLen.cross(bLen);
-    if (denom == 0 || !SkScalarIsFinite(denom)) {
+    if (denom == 0 || !SkIsFinite(denom)) {
         quadPts->fOppositeTangents = aLen.dot(bLen) < 0;
         return STROKER_RESULT(kDegenerate_ResultType, depth, quadPts, "denom == 0");
     }
@@ -1183,7 +1183,7 @@
             }
         }
     }
-    if (!SkScalarIsFinite(quadPts->fQuad[2].fX) || !SkScalarIsFinite(quadPts->fQuad[2].fY)) {
+    if (!SkIsFinite(quadPts->fQuad[2].fX) || !SkIsFinite(quadPts->fQuad[2].fY)) {
         DEBUG_CUBIC_RECURSION_TRACK_DEPTH(fRecursionDepth);
         return false;  // just abort if projected quad isn't representable
     }
diff --git a/src/core/SkStroke.h b/src/core/SkStroke.h
index ff98784..3587348 100644
--- a/src/core/SkStroke.h
+++ b/src/core/SkStroke.h
@@ -14,6 +14,7 @@
 #include "include/private/base/SkAssert.h"
 #include "include/private/base/SkTo.h"
 
+#include <cmath>
 #include <cstdint>
 
 class SkPath;
@@ -37,11 +38,11 @@
     SkStroke(const SkPaint&);
     SkStroke(const SkPaint&, SkScalar width);   // width overrides paint.getStrokeWidth()
 
-    SkPaint::Cap    getCap() const { return (SkPaint::Cap)fCap; }
-    void        setCap(SkPaint::Cap);
+    SkPaint::Cap getCap() const { return (SkPaint::Cap)fCap; }
+    void         setCap(SkPaint::Cap);
 
-    SkPaint::Join   getJoin() const { return (SkPaint::Join)fJoin; }
-    void        setJoin(SkPaint::Join);
+    SkPaint::Join getJoin() const { return (SkPaint::Join)fJoin; }
+    void          setJoin(SkPaint::Join);
 
     void    setMiterLimit(SkScalar);
     void    setWidth(SkScalar);
@@ -59,7 +60,7 @@
      */
     SkScalar getResScale() const { return fResScale; }
     void setResScale(SkScalar rs) {
-        SkASSERT(rs > 0 && SkScalarIsFinite(rs));
+        SkASSERT(rs > 0 && std::isfinite(rs));
         fResScale = rs;
     }
 
diff --git a/src/core/SkValidationUtils.h b/src/core/SkValidationUtils.h
index 491f202..5acb286 100644
--- a/src/core/SkValidationUtils.h
+++ b/src/core/SkValidationUtils.h
@@ -28,8 +28,7 @@
 static inline bool SkIsValidRect(const SkRect& rect) {
     return (rect.fLeft <= rect.fRight) &&
            (rect.fTop <= rect.fBottom) &&
-           SkScalarIsFinite(rect.width()) &&
-           SkScalarIsFinite(rect.height());
+           SkIsFinite(rect.width(), rect.height());
 }
 
 #endif
diff --git a/src/effects/Sk1DPathEffect.cpp b/src/effects/Sk1DPathEffect.cpp
index 98da0d4..969f162 100644
--- a/src/effects/Sk1DPathEffect.cpp
+++ b/src/effects/Sk1DPathEffect.cpp
@@ -17,6 +17,7 @@
 #include "include/core/SkScalar.h"
 #include "include/core/SkStrokeRec.h"
 #include "include/core/SkTypes.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "src/core/SkPathEffectBase.h"
 #include "src/core/SkReadBuffer.h"
 #include "src/core/SkWriteBuffer.h"
@@ -248,7 +249,7 @@
 
 sk_sp<SkPathEffect> SkPath1DPathEffect::Make(const SkPath& path, SkScalar advance, SkScalar phase,
                                              Style style) {
-    if (advance <= 0 || !SkScalarIsFinite(advance) || !SkScalarIsFinite(phase) || path.isEmpty()) {
+    if (advance <= 0 || !SkIsFinite(advance, phase) || path.isEmpty()) {
         return nullptr;
     }
     return sk_sp<SkPathEffect>(new SkPath1DPathEffectImpl(path, advance, phase, style));
diff --git a/src/effects/SkBlenders.cpp b/src/effects/SkBlenders.cpp
index b3680b1..d82da2b 100644
--- a/src/effects/SkBlenders.cpp
+++ b/src/effects/SkBlenders.cpp
@@ -14,16 +14,14 @@
 #include "include/core/SkData.h"
 #include "include/core/SkScalar.h"
 #include "include/effects/SkRuntimeEffect.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "src/core/SkKnownRuntimeEffects.h"
 
 sk_sp<SkBlender> SkBlenders::Arithmetic(float k1, float k2, float k3, float k4,
                                         bool enforcePremul) {
     using namespace SkKnownRuntimeEffects;
 
-    if (!SkScalarIsFinite(k1) ||
-        !SkScalarIsFinite(k2) ||
-        !SkScalarIsFinite(k3) ||
-        !SkScalarIsFinite(k4)) {
+    if (!SkIsFinite(k1, k2) || !SkIsFinite(k3, k4)) {
         return nullptr;
     }
 
diff --git a/src/effects/SkCornerPathEffect.cpp b/src/effects/SkCornerPathEffect.cpp
index e19c6c6..a301072 100644
--- a/src/effects/SkCornerPathEffect.cpp
+++ b/src/effects/SkCornerPathEffect.cpp
@@ -14,6 +14,7 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "src/core/SkPathEffectBase.h"
 #include "src/core/SkReadBuffer.h"
 #include "src/core/SkWriteBuffer.h"
@@ -178,7 +179,7 @@
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
 sk_sp<SkPathEffect> SkCornerPathEffect::Make(SkScalar radius) {
-    return SkScalarIsFinite(radius) && (radius > 0) ?
+    return SkIsFinite(radius) && (radius > 0) ?
             sk_sp<SkPathEffect>(new SkCornerPathEffectImpl(radius)) : nullptr;
 }
 
diff --git a/src/effects/SkDashPathEffect.cpp b/src/effects/SkDashPathEffect.cpp
index 49ed5fe..e5755c9 100644
--- a/src/effects/SkDashPathEffect.cpp
+++ b/src/effects/SkDashPathEffect.cpp
@@ -16,6 +16,7 @@
 #include "include/core/SkRect.h"
 #include "include/core/SkStrokeRec.h"
 #include "include/private/base/SkAlign.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkMalloc.h"
 #include "include/private/base/SkTemplates.h"
 #include "include/private/base/SkTo.h"
@@ -272,7 +273,7 @@
         // otherwise cause the results->fPoints allocation below to OOM.
         // Cap it to a sane value.
         SkScalar numIntervals = len2 / fIntervalLength;
-        if (!SkScalarIsFinite(numIntervals) || numIntervals > SkDashPath::kMaxDashCount) {
+        if (!SkIsFinite(numIntervals) || numIntervals > SkDashPath::kMaxDashCount) {
             return false;
         }
         int numMidPoints = SkScalarFloorToInt(numIntervals);
diff --git a/src/effects/SkDiscretePathEffect.cpp b/src/effects/SkDiscretePathEffect.cpp
index 727ca4ae..a019791 100644
--- a/src/effects/SkDiscretePathEffect.cpp
+++ b/src/effects/SkDiscretePathEffect.cpp
@@ -17,6 +17,7 @@
 #include "include/core/SkTypes.h"
 #include "include/effects/SkDiscretePathEffect.h"
 #include "include/private/base/SkFixed.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "src/core/SkPathEffectBase.h"
 #include "src/core/SkPointPriv.h"
 #include "src/core/SkReadBuffer.h"
@@ -80,8 +81,8 @@
     SkDiscretePathEffectImpl(SkScalar segLength, SkScalar deviation, uint32_t seedAssist)
         : fSegLength(segLength), fPerterb(deviation), fSeedAssist(seedAssist)
     {
-        SkASSERT(SkScalarIsFinite(segLength));
-        SkASSERT(SkScalarIsFinite(deviation));
+        SkASSERT(SkIsFinite(segLength));
+        SkASSERT(SkIsFinite(deviation));
         SkASSERT(segLength > SK_ScalarNearlyZero);
     }
 
@@ -177,7 +178,7 @@
 
 sk_sp<SkPathEffect> SkDiscretePathEffect::Make(SkScalar segLength, SkScalar deviation,
                                                uint32_t seedAssist) {
-    if (!SkScalarIsFinite(segLength) || !SkScalarIsFinite(deviation)) {
+    if (!SkIsFinite(segLength, deviation)) {
         return nullptr;
     }
     if (segLength <= SK_ScalarNearlyZero) {
diff --git a/src/effects/SkEmbossMaskFilter.cpp b/src/effects/SkEmbossMaskFilter.cpp
index febd715..3d431f8 100644
--- a/src/effects/SkEmbossMaskFilter.cpp
+++ b/src/effects/SkEmbossMaskFilter.cpp
@@ -12,6 +12,7 @@
 #include "include/core/SkPoint.h"
 #include "include/core/SkPoint3.h"
 #include "include/core/SkTypes.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "src/core/SkBlurMask.h"
 #include "src/core/SkReadBuffer.h"
 #include "src/core/SkWriteBuffer.h"
@@ -24,7 +25,7 @@
 #include <cstring>
 
 sk_sp<SkMaskFilter> SkEmbossMaskFilter::Make(SkScalar blurSigma, const Light& light) {
-    if (!SkScalarIsFinite(blurSigma) || blurSigma <= 0) {
+    if (!SkIsFinite(blurSigma) || blurSigma <= 0) {
         return nullptr;
     }
 
@@ -66,7 +67,7 @@
     : fLight(light), fBlurSigma(blurSigma)
 {
     SkASSERT(fBlurSigma > 0);
-    SkASSERT(SkScalarsAreFinite(fLight.fDirection, 3));
+    SkASSERT(SkIsFinite(fLight.fDirection, 3));
 }
 
 SkMask::Format SkEmbossMaskFilter::getFormat() const {
diff --git a/src/effects/SkTrimPathEffect.cpp b/src/effects/SkTrimPathEffect.cpp
index abd2522..b5e1e16 100644
--- a/src/effects/SkTrimPathEffect.cpp
+++ b/src/effects/SkTrimPathEffect.cpp
@@ -14,6 +14,7 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkTPin.h"
 #include "src/core/SkReadBuffer.h"
 #include "src/core/SkWriteBuffer.h"
@@ -130,7 +131,7 @@
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
 sk_sp<SkPathEffect> SkTrimPathEffect::Make(SkScalar startT, SkScalar stopT, Mode mode) {
-    if (!SkScalarsAreFinite(startT, stopT)) {
+    if (!SkIsFinite(startT, stopT)) {
         return nullptr;
     }
 
diff --git a/src/effects/colorfilters/SkMatrixColorFilter.cpp b/src/effects/colorfilters/SkMatrixColorFilter.cpp
index 18a2187..2bad15c 100644
--- a/src/effects/colorfilters/SkMatrixColorFilter.cpp
+++ b/src/effects/colorfilters/SkMatrixColorFilter.cpp
@@ -90,7 +90,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 static sk_sp<SkColorFilter> MakeMatrix(const float array[20], SkMatrixColorFilter::Domain domain) {
-    if (!sk_floats_are_finite(array, 20)) {
+    if (!SkIsFinite(array, 20)) {
         return nullptr;
     }
     return sk_make_sp<SkMatrixColorFilter>(array, domain);
diff --git a/src/effects/colorfilters/SkRuntimeColorFilter.cpp b/src/effects/colorfilters/SkRuntimeColorFilter.cpp
index 2d8693d..687e23d 100644
--- a/src/effects/colorfilters/SkRuntimeColorFilter.cpp
+++ b/src/effects/colorfilters/SkRuntimeColorFilter.cpp
@@ -13,7 +13,6 @@
 #include "include/core/SkColorFilter.h"
 #include "include/core/SkData.h"
 #include "include/core/SkMatrix.h"
-#include "include/core/SkScalar.h"
 #include "include/core/SkString.h"
 #include "include/effects/SkLumaColorFilter.h"
 #include "include/effects/SkOverdrawColorFilter.h"
@@ -21,6 +20,7 @@
 #include "include/private/SkColorData.h"
 #include "include/private/SkSLSampleUsage.h"
 #include "include/private/base/SkDebug.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkTArray.h"
 #include "src/core/SkEffectPriv.h"
 #include "src/core/SkKnownRuntimeEffects.h"
@@ -120,7 +120,7 @@
     if (!cf0 && !cf1) {
         return nullptr;
     }
-    if (SkScalarIsNaN(weight)) {
+    if (SkIsNaN(weight)) {
         return nullptr;
     }
 
diff --git a/src/effects/imagefilters/SkBlurImageFilter.cpp b/src/effects/imagefilters/SkBlurImageFilter.cpp
index 291c33c..7a0550b 100644
--- a/src/effects/imagefilters/SkBlurImageFilter.cpp
+++ b/src/effects/imagefilters/SkBlurImageFilter.cpp
@@ -107,7 +107,7 @@
 sk_sp<SkImageFilter> SkImageFilters::Blur(
         SkScalar sigmaX, SkScalar sigmaY, SkTileMode tileMode, sk_sp<SkImageFilter> input,
         const CropRect& cropRect) {
-    if (!SkScalarsAreFinite(sigmaX, sigmaY) || sigmaX < 0.f || sigmaY < 0.f) {
+    if (!SkIsFinite(sigmaX, sigmaY) || sigmaX < 0.f || sigmaY < 0.f) {
         // Non-finite or negative sigmas are error conditions. We allow 0 sigma for X and/or Y
         // for 1D blurs; onFilterImage() will detect when no visible blurring would occur based on
         // the Context mapping.
@@ -987,7 +987,7 @@
 
     // Disable bluring on axes that are not finite, or that are small enough that the blur is
     // effectively an identity.
-    if (!SkScalarIsFinite(sigma.width()) || (!gpuBacked && calculate_window(sigma.width()) <= 1)
+    if (!SkIsFinite(sigma.width()) || (!gpuBacked && calculate_window(sigma.width()) <= 1)
 #if defined(SK_GANESH) || defined(SK_GRAPHITE)
         || (gpuBacked && skgpu::BlurIsEffectivelyIdentity(sigma.width()))
 #endif
@@ -995,7 +995,7 @@
         sigma = skif::LayerSpace<SkSize>({0.f, sigma.height()});
     }
 
-    if (!SkScalarIsFinite(sigma.height()) || (!gpuBacked && calculate_window(sigma.height()) <= 1)
+    if (!SkIsFinite(sigma.height()) || (!gpuBacked && calculate_window(sigma.height()) <= 1)
 #if defined(SK_GANESH) || defined(SK_GRAPHITE)
         || (gpuBacked && skgpu::BlurIsEffectivelyIdentity(sigma.height()))
 #endif
diff --git a/src/effects/imagefilters/SkLightingImageFilter.cpp b/src/effects/imagefilters/SkLightingImageFilter.cpp
index 08f05a7..38fde08 100644
--- a/src/effects/imagefilters/SkLightingImageFilter.cpp
+++ b/src/effects/imagefilters/SkLightingImageFilter.cpp
@@ -20,6 +20,7 @@
 #include "include/core/SkTypes.h"
 #include "include/effects/SkRuntimeEffect.h"
 #include "include/private/base/SkCPUTypes.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkSpan_impl.h"
 #include "src/core/SkImageFilterTypes.h"
 #include "src/core/SkImageFilter_Base.h"
@@ -281,19 +282,16 @@
                                    const SkImageFilters::CropRect& cropRect) {
     // According to the spec, ks and kd can be any non-negative number:
     // http://www.w3.org/TR/SVG/filters.html#feSpecularLightingElement
-    if (!SkScalarIsFinite(material.fK) || material.fK < 0.f ||
-        !SkScalarIsFinite(material.fShininess) ||
-        !SkScalarIsFinite(ZValue(material.fSurfaceDepth))) {
+    if (!SkIsFinite(material.fK) || material.fK < 0.f ||
+        !SkIsFinite(material.fShininess, ZValue(material.fSurfaceDepth))) {
         return nullptr;
     }
 
     // Ensure light values are finite, and the cosine should be between -1 and 1
     if (!SkPoint(light.fLocationXY).isFinite() ||
-        !SkScalarIsFinite(ZValue(light.fLocationZ)) ||
         !skif::Vector(light.fDirectionXY).isFinite() ||
-        !SkScalarIsFinite(ZValue(light.fDirectionZ)) ||
-        !SkScalarIsFinite(light.fFalloffExponent) ||
-        !SkScalarIsFinite(light.fCosCutoffAngle) ||
+        !SkIsFinite(ZValue(light.fLocationZ), ZValue(light.fDirectionZ)) ||
+        !SkIsFinite(light.fFalloffExponent, light.fCosCutoffAngle) ||
         light.fCosCutoffAngle < -1.f || light.fCosCutoffAngle > 1.f) {
         return nullptr;
     }
diff --git a/src/effects/imagefilters/SkMagnifierImageFilter.cpp b/src/effects/imagefilters/SkMagnifierImageFilter.cpp
index 399e36e..9d85d03 100644
--- a/src/effects/imagefilters/SkMagnifierImageFilter.cpp
+++ b/src/effects/imagefilters/SkMagnifierImageFilter.cpp
@@ -21,6 +21,7 @@
 #include "include/core/SkSpan.h"
 #include "include/core/SkTypes.h"
 #include "include/effects/SkRuntimeEffect.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "src/core/SkImageFilterTypes.h"
 #include "src/core/SkImageFilter_Base.h"
 #include "src/core/SkKnownRuntimeEffects.h"
@@ -85,8 +86,8 @@
                                                sk_sp<SkImageFilter> input,
                                                const CropRect& cropRect) {
     if (lensBounds.isEmpty() || !lensBounds.isFinite() ||
-        zoomAmount <= 0.f || !SkScalarIsFinite(zoomAmount) ||
-        inset < 0.f || !SkScalarIsFinite(inset)) {
+        zoomAmount <= 0.f || inset < 0.f ||
+        !SkIsFinite(zoomAmount, inset)) {
         return nullptr; // invalid
     }
     // The magnifier automatically restricts its output based on the size of the image it receives
diff --git a/src/gpu/BlurUtils.cpp b/src/gpu/BlurUtils.cpp
index afbac5f..f8773d4 100644
--- a/src/gpu/BlurUtils.cpp
+++ b/src/gpu/BlurUtils.cpp
@@ -274,8 +274,8 @@
 }
 
 int ComputeIntegralTableWidth(float sixSigma) {
-    // Check for NaN
-    if (std::isnan(sixSigma)) {
+    // Check for NaN/infinity
+    if (!SkIsFinite(sixSigma)) {
         return 0;
     }
     // Avoid overflow, covers both multiplying by 2 and finding next power of 2:
diff --git a/src/gpu/ganesh/GrBlurUtils.cpp b/src/gpu/ganesh/GrBlurUtils.cpp
index e2d6c24..4e987b2 100644
--- a/src/gpu/ganesh/GrBlurUtils.cpp
+++ b/src/gpu/ganesh/GrBlurUtils.cpp
@@ -424,7 +424,7 @@
                                                                   float* solidRadius,
                                                                   float* textureRadius) {
     float circleR = circle.width() / 2.0f;
-    if (!std::isfinite(circleR) || circleR < SK_ScalarNearlyZero) {
+    if (!SkIsFinite(circleR) || circleR < SK_ScalarNearlyZero) {
         return nullptr;
     }
 
diff --git a/src/gpu/ganesh/geometry/GrAAConvexTessellator.cpp b/src/gpu/ganesh/geometry/GrAAConvexTessellator.cpp
index 606508b..20cfbde 100644
--- a/src/gpu/ganesh/geometry/GrAAConvexTessellator.cpp
+++ b/src/gpu/ganesh/geometry/GrAAConvexTessellator.cpp
@@ -50,7 +50,7 @@
         return false;
     }
     *t = (v.fX * n1.fY - v.fY * n1.fX) / perpDot;
-    return SkScalarIsFinite(*t);
+    return SkIsFinite(*t);
 }
 
 // This is a special case version of intersect where we have the vector
@@ -64,7 +64,7 @@
         return false;
     }
     *t = v.dot(perp) / perpDot;
-    return SkScalarIsFinite(*t);
+    return SkIsFinite(*t);
 }
 
 static bool duplicate_pt(const SkPoint& p0, const SkPoint& p1) {
diff --git a/src/gpu/ganesh/geometry/GrPathUtils.cpp b/src/gpu/ganesh/geometry/GrPathUtils.cpp
index 937a90b..9e8307a 100644
--- a/src/gpu/ganesh/geometry/GrPathUtils.cpp
+++ b/src/gpu/ganesh/geometry/GrPathUtils.cpp
@@ -17,7 +17,6 @@
 #include "src/gpu/tessellate/WangsFormula.h"
 
 #include <algorithm>
-#include <cmath>
 
 using namespace skia_private;
 
@@ -161,7 +160,7 @@
     double a8 = x0*y1-x1*y0;
     double det = a2 + a5 + a8;
 
-    if (!std::isfinite(det)
+    if (!SkIsFinite(det)
         || SkScalarNearlyZero((float)det, SK_ScalarNearlyZero * SK_ScalarNearlyZero)) {
         // The quad is degenerate. Hopefully this is rare. Find the pts that are
         // farthest apart to compute a line (unless it is really a pt).
@@ -498,7 +497,7 @@
     if (!p[0].isFinite() || !p[1].isFinite() || !p[2].isFinite() || !p[3].isFinite()) {
         return;
     }
-    if (!SkScalarIsFinite(tolScale)) {
+    if (!SkIsFinite(tolScale)) {
         return;
     }
     SkPoint chopped[10];
@@ -519,7 +518,7 @@
     if (!p[0].isFinite() || !p[1].isFinite() || !p[2].isFinite() || !p[3].isFinite()) {
         return;
     }
-    if (!SkScalarIsFinite(tolScale)) {
+    if (!SkIsFinite(tolScale)) {
         return;
     }
     SkPoint chopped[10];
diff --git a/src/gpu/ganesh/geometry/GrQuad.h b/src/gpu/ganesh/geometry/GrQuad.h
index 97a5a40..8048f8b 100644
--- a/src/gpu/ganesh/geometry/GrQuad.h
+++ b/src/gpu/ganesh/geometry/GrQuad.h
@@ -100,8 +100,9 @@
             accum *= fY[i];
             accum *= fW[i];
         }
-        SkASSERT(0 == accum || SkScalarIsNaN(accum));
-        return !SkScalarIsNaN(accum);
+        SkASSERT(0 == accum || SkIsNaN(accum));
+
+        return accum == 0.0f;
     }
 
     float x(int i) const { return fX[i]; }
diff --git a/src/gpu/ganesh/geometry/GrTriangulator.cpp b/src/gpu/ganesh/geometry/GrTriangulator.cpp
index dd215bb..6e5ffdd 100644
--- a/src/gpu/ganesh/geometry/GrTriangulator.cpp
+++ b/src/gpu/ganesh/geometry/GrTriangulator.cpp
@@ -10,6 +10,7 @@
 #include "include/core/SkPathTypes.h"
 #include "include/core/SkRect.h"
 #include "include/private/base/SkDebug.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkMath.h"
 #include "include/private/base/SkTPin.h"
 #include "src/base/SkVx.h"
@@ -519,8 +520,7 @@
                                          int pointsLeft) const {
     SkScalar d1 = SkPointPriv::DistanceToLineSegmentBetweenSqd(p1, p0, p3);
     SkScalar d2 = SkPointPriv::DistanceToLineSegmentBetweenSqd(p2, p0, p3);
-    if (pointsLeft < 2 || (d1 < tolSqd && d2 < tolSqd) ||
-        !SkScalarIsFinite(d1) || !SkScalarIsFinite(d2)) {
+    if (pointsLeft < 2 || (d1 < tolSqd && d2 < tolSqd) || !SkIsFinite(d1, d2)) {
         this->appendPointToContour(p3, contour);
         return;
     }
diff --git a/src/gpu/ganesh/ops/AAConvexPathRenderer.cpp b/src/gpu/ganesh/ops/AAConvexPathRenderer.cpp
index 32c7d0f..300dddd 100644
--- a/src/gpu/ganesh/ops/AAConvexPathRenderer.cpp
+++ b/src/gpu/ganesh/ops/AAConvexPathRenderer.cpp
@@ -120,7 +120,7 @@
         // undo the translate of p0 to the origin.
         *c = center + p0;
     }
-    return !SkScalarIsNaN(c->fX) && !SkScalarIsNaN(c->fY) && c->isFinite();
+    return !SkIsNaN(c->fX) && !SkIsNaN(c->fY) && c->isFinite();
 }
 
 bool compute_vectors(SegmentArray* segments,
diff --git a/src/gpu/ganesh/ops/AAHairLinePathRenderer.cpp b/src/gpu/ganesh/ops/AAHairLinePathRenderer.cpp
index 360c5ec..5769931 100644
--- a/src/gpu/ganesh/ops/AAHairLinePathRenderer.cpp
+++ b/src/gpu/ganesh/ops/AAHairLinePathRenderer.cpp
@@ -514,7 +514,7 @@
 
     SkScalar wInv = normA.fX * normB.fY - normA.fY * normB.fX;
     wInv = sk_ieee_float_divide(1.0f, wInv);
-    if (!SkScalarIsFinite(wInv)) {
+    if (!SkIsFinite(wInv)) {
         // lines are parallel, pick the point in between
         *result = (ptA + ptB)*SK_ScalarHalf;
         *result += normA;
diff --git a/src/gpu/graphite/ClipStack_graphite.cpp b/src/gpu/graphite/ClipStack_graphite.cpp
index 0a0ac6f..8eceb55 100644
--- a/src/gpu/graphite/ClipStack_graphite.cpp
+++ b/src/gpu/graphite/ClipStack_graphite.cpp
@@ -1114,7 +1114,7 @@
     }
 
     auto origSize = geometry.bounds().size();
-    if (!std::isfinite(origSize.x()) || !std::isfinite(origSize.y())) {
+    if (!SkIsFinite(origSize.x(), origSize.y())) {
         // Discard all non-finite geometry as if it were clipped out
         return kClippedOut;
     }
@@ -1141,7 +1141,7 @@
     // Some renderers make the drawn area larger than the geometry for anti-aliasing
     float rendererOutset = outsetBoundsForAA ? localToDevice.localAARadius(styledShape->bounds())
                                              : 0.f;
-    if (!SkScalarIsFinite(rendererOutset)) {
+    if (!SkIsFinite(rendererOutset)) {
         transformedShapeBounds = deviceBounds;
         infiniteBounds = true;
     } else {
diff --git a/src/gpu/graphite/geom/Transform.cpp b/src/gpu/graphite/geom/Transform.cpp
index 128f2db..a4abbcb 100644
--- a/src/gpu/graphite/geom/Transform.cpp
+++ b/src/gpu/graphite/geom/Transform.cpp
@@ -231,7 +231,7 @@
     // transformation moves between [1,max/min] so using 1/min as the local AA radius ensures that
     // the post-transformed point is at least 1px away from the original.
     float aaRadius = sk_ieee_float_divide(1.f, min);
-    if (std::isfinite(aaRadius)) {
+    if (SkIsFinite(aaRadius)) {
         return aaRadius;
     } else {
         return SK_FloatInfinity;
diff --git a/src/gpu/graphite/geom/Transform_graphite.h b/src/gpu/graphite/geom/Transform_graphite.h
index ed35300..f9b8cea 100644
--- a/src/gpu/graphite/geom/Transform_graphite.h
+++ b/src/gpu/graphite/geom/Transform_graphite.h
@@ -56,7 +56,7 @@
     static inline Transform Translate(float x, float y) {
         if (x == 0.f && y == 0.f) {
             return Identity();
-        } else if (SkScalarsAreFinite(x, y)) {
+        } else if (SkIsFinite(x, y)) {
             return Transform(SkM44::Translate(x, y), SkM44::Translate(-x, -y),
                              Type::kSimpleRectStaysRect, 1.f, 1.f);
         } else {
diff --git a/src/pathops/SkOpEdgeBuilder.cpp b/src/pathops/SkOpEdgeBuilder.cpp
index 7078f2d..ffdd07c 100644
--- a/src/pathops/SkOpEdgeBuilder.cpp
+++ b/src/pathops/SkOpEdgeBuilder.cpp
@@ -9,6 +9,7 @@
 #include "include/core/SkPath.h"
 #include "include/core/SkPoint.h"
 #include "include/core/SkTypes.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "src/base/SkTSort.h"
 #include "src/core/SkGeometry.h"
 #include "src/core/SkPathPriv.h"
@@ -217,7 +218,7 @@
                         if (SkChopQuadAtMaxCurvature(pointsPtr, pair) == 1) {
                             goto addOneQuad;
                         }
-                        if (!SkScalarsAreFinite(&pair[0].fX, std::size(pair) * 2)) {
+                        if (!SkIsFinite(&pair[0].fX, std::size(pair) * 2)) {
                             return false;
                         }
                         for (unsigned index = 0; index < std::size(pair); ++index) {
diff --git a/src/pathops/SkPathOpsCubic.cpp b/src/pathops/SkPathOpsCubic.cpp
index 138072d..64e0ad6 100644
--- a/src/pathops/SkPathOpsCubic.cpp
+++ b/src/pathops/SkPathOpsCubic.cpp
@@ -6,6 +6,7 @@
  */
 #include "src/pathops/SkPathOpsCubic.h"
 
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkTPin.h"
 #include "include/private/base/SkTo.h"
 #include "src/base/SkTSort.h"
@@ -728,7 +729,7 @@
             cubic[index] = 0;
         }
     }
-    return SkScalarsAreFinite(&pts->fX, kPointCount * 2);
+    return SkIsFinite(&pts->fX, kPointCount * 2);
 }
 
 double SkDCubic::top(const SkDCubic& dCurve, double startT, double endT, SkDPoint*topPt) const {
diff --git a/src/pathops/SkPathOpsDebug.cpp b/src/pathops/SkPathOpsDebug.cpp
index 1e686ac..ef00cac 100644
--- a/src/pathops/SkPathOpsDebug.cpp
+++ b/src/pathops/SkPathOpsDebug.cpp
@@ -415,22 +415,22 @@
         if (glitch.fOppEndSpan) {
             SkDebugf(" oppEndSpan=%d", glitch.fOppEndSpan->debugID());
         }
-        if (!SkScalarIsNaN(glitch.fStartT)) {
+        if (!SkIsNaN(glitch.fStartT)) {
             SkDebugf(" startT=%g", glitch.fStartT);
         }
-        if (!SkScalarIsNaN(glitch.fEndT)) {
+        if (!SkIsNaN(glitch.fEndT)) {
             SkDebugf(" endT=%g", glitch.fEndT);
         }
         if (glitch.fOppSegment) {
             SkDebugf(" segment=%d", glitch.fOppSegment->debugID());
         }
-        if (!SkScalarIsNaN(glitch.fOppStartT)) {
+        if (!SkIsNaN(glitch.fOppStartT)) {
             SkDebugf(" oppStartT=%g", glitch.fOppStartT);
         }
-        if (!SkScalarIsNaN(glitch.fOppEndT)) {
+        if (!SkIsNaN(glitch.fOppEndT)) {
             SkDebugf(" oppEndT=%g", glitch.fOppEndT);
         }
-        if (!SkScalarIsNaN(glitch.fPt.fX) || !SkScalarIsNaN(glitch.fPt.fY)) {
+        if (!SkIsNaN(glitch.fPt.fX) || !SkIsNaN(glitch.fPt.fY)) {
             SkDebugf(" pt=%g,%g", glitch.fPt.fX, glitch.fPt.fY);
         }
         DumpGlitchType(glitch.fType);
diff --git a/src/pathops/SkPathOpsPoint.h b/src/pathops/SkPathOpsPoint.h
index 9d70df0..053192b 100644
--- a/src/pathops/SkPathOpsPoint.h
+++ b/src/pathops/SkPathOpsPoint.h
@@ -95,7 +95,7 @@
     }
 
     bool isFinite() const {
-        return std::isfinite(fX) && std::isfinite(fY);
+        return SkIsFinite(fX, fY);
     }
 };
 
diff --git a/src/pathops/SkPathOpsTypes.cpp b/src/pathops/SkPathOpsTypes.cpp
index e516b1d..76147dc 100644
--- a/src/pathops/SkPathOpsTypes.cpp
+++ b/src/pathops/SkPathOpsTypes.cpp
@@ -40,7 +40,7 @@
 }
 
 static bool equal_ulps_pin(float a, float b, int epsilon, int depsilon) {
-    if (!SkScalarIsFinite(a) || !SkScalarIsFinite(b)) {
+    if (!SkIsFinite(a, b)) {
         return false;
     }
     if (arguments_denormalized(a, b, depsilon)) {
@@ -70,7 +70,7 @@
 }
 
 static bool not_equal_ulps_pin(float a, float b, int epsilon) {
-    if (!SkScalarIsFinite(a) || !SkScalarIsFinite(b)) {
+    if (!SkIsFinite(a, b)) {
         return false;
     }
     if (arguments_denormalized(a, b, epsilon)) {
diff --git a/src/shaders/SkColorShader.cpp b/src/shaders/SkColorShader.cpp
index 1ade7ca..90b5754 100644
--- a/src/shaders/SkColorShader.cpp
+++ b/src/shaders/SkColorShader.cpp
@@ -11,8 +11,8 @@
 #include "include/core/SkColorSpace.h"
 #include "include/core/SkData.h"
 #include "include/core/SkFlattenable.h"
-#include "include/core/SkScalar.h"
 #include "include/core/SkShader.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkTPin.h"
 #include "src/core/SkColorSpacePriv.h"
 #include "src/core/SkColorSpaceXformSteps.h"
@@ -103,7 +103,7 @@
 sk_sp<SkShader> Color(SkColor color) { return sk_make_sp<SkColorShader>(color); }
 
 sk_sp<SkShader> Color(const SkColor4f& color, sk_sp<SkColorSpace> space) {
-    if (!SkScalarsAreFinite(color.vec(), 4)) {
+    if (!SkIsFinite(color.vec(), 4)) {
         return nullptr;
     }
     return sk_make_sp<SkColor4Shader>(color, std::move(space));
diff --git a/src/shaders/SkPerlinNoiseShaderImpl.cpp b/src/shaders/SkPerlinNoiseShaderImpl.cpp
index d4780b6..e843763 100644
--- a/src/shaders/SkPerlinNoiseShaderImpl.cpp
+++ b/src/shaders/SkPerlinNoiseShaderImpl.cpp
@@ -119,7 +119,7 @@
     if (tileSize && !(tileSize->width() >= 0 && tileSize->height() >= 0)) {
         return false;
     }
-    if (!SkScalarIsFinite(seed)) {
+    if (!SkIsFinite(seed)) {
         return false;
     }
     return true;
diff --git a/src/shaders/SkPictureShader.cpp b/src/shaders/SkPictureShader.cpp
index b776dfc..924e536 100644
--- a/src/shaders/SkPictureShader.cpp
+++ b/src/shaders/SkPictureShader.cpp
@@ -19,6 +19,7 @@
 #include "include/core/SkSurface.h"
 #include "include/core/SkTileMode.h"
 #include "include/private/base/SkDebug.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "src/base/SkArenaAlloc.h"
 #include "src/core/SkEffectPriv.h"
 #include "src/core/SkImageInfoPriv.h"
@@ -191,7 +192,7 @@
         if (!totalM.decomposeScale(&size, nullptr)) {
             SkPoint center = {bounds.centerX(), bounds.centerY()};
             SkScalar area = SkMatrixPriv::DifferentialAreaScale(totalM, center);
-            if (!SkScalarIsFinite(area) || SkScalarNearlyZero(area)) {
+            if (!SkIsFinite(area) || SkScalarNearlyZero(area)) {
                 size = {1, 1};  // ill-conditioned matrix
             } else {
                 size.fWidth = size.fHeight = SkScalarSqrt(area);
diff --git a/src/shaders/gradients/SkGradientBaseShader.cpp b/src/shaders/gradients/SkGradientBaseShader.cpp
index 6cbdf02..d45d691 100644
--- a/src/shaders/gradients/SkGradientBaseShader.cpp
+++ b/src/shaders/gradients/SkGradientBaseShader.cpp
@@ -391,7 +391,7 @@
                 SkASSERT(t_l <= t_r);
                 if (t_l < t_r) {
                     float c_scale = sk_ieee_float_divide(1, t_r - t_l);
-                    if (std::isfinite(c_scale)) {
+                    if (SkIsFinite(c_scale)) {
                         init_stop_pos(ctx, stopCount, t_l, c_scale, c_l, c_r);
                         stopCount += 1;
                     }
diff --git a/src/shaders/gradients/SkLinearGradient.cpp b/src/shaders/gradients/SkLinearGradient.cpp
index b63c519..6126147 100644
--- a/src/shaders/gradients/SkLinearGradient.cpp
+++ b/src/shaders/gradients/SkLinearGradient.cpp
@@ -14,6 +14,7 @@
 #include "include/core/SkScalar.h"
 #include "include/core/SkShader.h"
 #include "include/effects/SkGradientShader.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkTArray.h"
 #include "src/core/SkReadBuffer.h"
 #include "src/core/SkWriteBuffer.h"
@@ -96,7 +97,7 @@
                                              SkTileMode mode,
                                              const Interpolation& interpolation,
                                              const SkMatrix* localMatrix) {
-    if (!pts || !SkScalarIsFinite((pts[1] - pts[0]).length())) {
+    if (!pts || !SkIsFinite((pts[1] - pts[0]).length())) {
         return nullptr;
     }
     if (!SkGradientBaseShader::ValidGradient(colors, colorCount, mode, interpolation)) {
diff --git a/src/shaders/gradients/SkSweepGradient.cpp b/src/shaders/gradients/SkSweepGradient.cpp
index 9efb733..cded4ca 100644
--- a/src/shaders/gradients/SkSweepGradient.cpp
+++ b/src/shaders/gradients/SkSweepGradient.cpp
@@ -111,7 +111,7 @@
     if (1 == colorCount) {
         return SkShaders::Color(colors[0], std::move(colorSpace));
     }
-    if (!SkScalarIsFinite(startAngle) || !SkScalarIsFinite(endAngle) || startAngle > endAngle) {
+    if (!SkIsFinite(startAngle, endAngle) || startAngle > endAngle) {
         return nullptr;
     }
     if (localMatrix && !localMatrix->invert(nullptr)) {
diff --git a/src/text/gpu/SubRunContainer.cpp b/src/text/gpu/SubRunContainer.cpp
index 0fe6e82..bb21c02 100644
--- a/src/text/gpu/SubRunContainer.cpp
+++ b/src/text/gpu/SubRunContainer.cpp
@@ -24,6 +24,7 @@
 #include "include/core/SkTypes.h"
 #include "include/effects/SkDashPathEffect.h"
 #include "include/private/SkColorData.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkOnce.h"
 #include "include/private/base/SkTArray.h"
 #include "include/private/base/SkTLogic.h"
@@ -1449,7 +1450,7 @@
     SkGlyphRect boundingRect = skglyph::empty_rect();
     StrikeMutationMonitor m{strike};
     for (const auto [glyphID, pos] : source) {
-        if (!SkScalarsAreFinite(pos.x(), pos.y())) {
+        if (!SkIsFinite(pos.x(), pos.y())) {
             continue;
         }
 
@@ -1503,7 +1504,7 @@
     SkGlyphRect boundingRect = skglyph::empty_rect();
     StrikeMutationMonitor m{strike};
     for (auto [glyphID, pos] : source) {
-        if (!SkScalarsAreFinite(pos.x(), pos.y())) {
+        if (!SkIsFinite(pos.x(), pos.y())) {
             continue;
         }
 
@@ -1546,7 +1547,7 @@
     SkGlyphRect boundingRect = skglyph::empty_rect();
     StrikeMutationMonitor m{strike};
     for (auto [glyphID, pos] : source) {
-        if (!SkScalarsAreFinite(pos.x(), pos.y())) {
+        if (!SkIsFinite(pos.x(), pos.y())) {
             continue;
         }
 
@@ -1583,7 +1584,7 @@
     int rejectedSize = 0;
     StrikeMutationMonitor m{strike};
     for (const auto [glyphID, pos] : source) {
-        if (!SkScalarsAreFinite(pos.x(), pos.y())) {
+        if (!SkIsFinite(pos.x(), pos.y())) {
             continue;
         }
 
@@ -1611,7 +1612,7 @@
     int rejectedSize = 0;
     StrikeMutationMonitor m{strike};
     for (const auto [glyphID, pos] : source) {
-        if (!SkScalarsAreFinite(pos.x(), pos.y())) {
+        if (!SkIsFinite(pos.x(), pos.y())) {
             continue;
         }
 
@@ -1888,7 +1889,7 @@
                 SkPoint center = glyphRunList.sourceBounds().center();
                 SkScalar maxAreaScale = SkMatrixPriv::DifferentialAreaScale(creationMatrix, center);
                 SkScalar perspectiveFactor = 1;
-                if (SkScalarIsFinite(maxAreaScale) && !SkScalarNearlyZero(maxAreaScale)) {
+                if (SkIsFinite(maxAreaScale) && !SkScalarNearlyZero(maxAreaScale)) {
                     perspectiveFactor = SkScalarSqrt(maxAreaScale);
                 }
 
diff --git a/src/utils/SkDashPath.cpp b/src/utils/SkDashPath.cpp
index b704b09..5a5c34d 100644
--- a/src/utils/SkDashPath.cpp
+++ b/src/utils/SkDashPath.cpp
@@ -254,7 +254,7 @@
 
         fPathLength = pathLength;
         fTangent.scale(sk_ieee_float_divide(1.0f, pathLength));
-        if (!SkScalarsAreFinite(fTangent.fX, fTangent.fY)) {
+        if (!SkIsFinite(fTangent.fX, fTangent.fY)) {
             return false;
         }
         SkPointPriv::RotateCCW(fTangent, &fNormal);
@@ -266,7 +266,7 @@
 
         SkScalar ptCount = pathLength * intervalCount / (float)intervalLength;
         ptCount = std::min(ptCount, SkDashPath::kMaxDashCount);
-        if (SkScalarIsNaN(ptCount)) {
+        if (SkIsNaN(ptCount)) {
             return false;
         }
         int n = SkScalarCeilToInt(ptCount) << 2;
@@ -485,5 +485,5 @@
         length += intervals[i];
     }
     // watch out for values that might make us go out of bounds
-    return length > 0 && SkScalarIsFinite(phase) && SkScalarIsFinite(length);
+    return length > 0 && SkIsFinite(phase, length);
 }
diff --git a/src/utils/SkPatchUtils.cpp b/src/utils/SkPatchUtils.cpp
index eee7bae..efc2d44 100644
--- a/src/utils/SkPatchUtils.cpp
+++ b/src/utils/SkPatchUtils.cpp
@@ -159,7 +159,7 @@
     for (int i = 0; i < count - 1; i++) {
         arcLength += SkPoint::Distance(points[i], points[i + 1]);
     }
-    return SkScalarIsFinite(arcLength) ? arcLength : -1;
+    return SkIsFinite(arcLength) ? arcLength : -1;
 }
 
 static SkScalar bilerp(SkScalar tx, SkScalar ty, SkScalar c00, SkScalar c10, SkScalar c01,
diff --git a/src/utils/SkPolyUtils.cpp b/src/utils/SkPolyUtils.cpp
index 2135208..c122bb7 100644
--- a/src/utils/SkPolyUtils.cpp
+++ b/src/utils/SkPolyUtils.cpp
@@ -95,7 +95,7 @@
 
 // special zero-length test when we're using vdotv as a denominator
 static inline bool zero_length(const SkPoint& v, SkScalar vdotv) {
-    return !(SkScalarsAreFinite(v.fX, v.fY) && vdotv);
+    return !(SkIsFinite(v.fX, v.fY) && vdotv);
 }
 
 // Compute the intersection 'p' between segments s0 and s1, if any.
@@ -348,7 +348,7 @@
     }
 
     // can't inset by a negative or non-finite amount
-    if (inset < -SK_ScalarNearlyZero || !SkScalarIsFinite(inset)) {
+    if (inset < -SK_ScalarNearlyZero || !SkIsFinite(inset)) {
         return false;
     }
 
@@ -492,11 +492,11 @@
     const SkScalar kRecipPixelsPerArcSegment = 0.25f;
 
     SkScalar rCos = v1.dot(v2);
-    if (!SkScalarIsFinite(rCos)) {
+    if (!SkIsFinite(rCos)) {
         return false;
     }
     SkScalar rSin = v1.cross(v2);
-    if (!SkScalarIsFinite(rSin)) {
+    if (!SkIsFinite(rSin)) {
         return false;
     }
     SkScalar theta = SkScalarATan2(rSin, rCos);
@@ -1204,7 +1204,7 @@
         return false;
     }
 
-    if (!SkScalarIsFinite(offset)) {
+    if (!SkIsFinite(offset)) {
         return false;
     }
 
@@ -1527,13 +1527,13 @@
         fNumVerts = 0;
         SkScalar width = bounds.width();
         SkScalar height = bounds.height();
-        if (!SkScalarIsFinite(width) || !SkScalarIsFinite(height)) {
+        if (!SkIsFinite(width, height)) {
             return false;
         }
 
         // We want vertexCount grid cells, roughly distributed to match the bounds ratio
         SkScalar hCount = SkScalarSqrt(sk_ieee_float_divide(vertexCount*width, height));
-        if (!SkScalarIsFinite(hCount)) {
+        if (!SkIsFinite(hCount)) {
             return false;
         }
         fHCount = std::max(std::min(SkScalarRoundToInt(hCount), vertexCount), 1);
diff --git a/src/utils/SkShadowTessellator.cpp b/src/utils/SkShadowTessellator.cpp
index 095a357..26bb874 100644
--- a/src/utils/SkShadowTessellator.cpp
+++ b/src/utils/SkShadowTessellator.cpp
@@ -293,7 +293,7 @@
             // if the umbra would collapse, we back off a bit on inner blur and adjust the alpha
             auto newInset = SkScalarSqrt(minDistSq) - kTolerance;
             auto ratio = 128 * (newInset / inset + 1);
-            SkASSERT(SkScalarIsFinite(ratio));
+            SkASSERT(SkIsFinite(ratio));
             // they aren't PMColors, but the interpolation algorithm is the same
             umbraColor = SkPMLerp(kUmbraColor, kPenumbraColor, (unsigned)ratio);
             inset = newInset;
@@ -936,7 +936,7 @@
     if (!this->computePathPolygon(path, ctm)) {
         return;
     }
-    if (fPathPolygon.size() < 3 || !SkScalarIsFinite(fArea)) {
+    if (fPathPolygon.size() < 3 || !SkIsFinite(fArea)) {
         fSucceeded = true; // We don't want to try to blur these cases, so we will
                            // return an empty SkVertices instead.
         return;
@@ -1037,7 +1037,7 @@
     if (!this->computeClipAndPathPolygons(path, ctm, shadowTransform)) {
         return;
     }
-    if (fClipPolygon.size() < 3 || fPathPolygon.size() < 3 || !SkScalarIsFinite(fArea)) {
+    if (fClipPolygon.size() < 3 || fPathPolygon.size() < 3 || !SkIsFinite(fArea)) {
         fSucceeded = true; // We don't want to try to blur these cases, so we will
                            // return an empty SkVertices instead.
         return;
@@ -1179,7 +1179,7 @@
                                                 bool directional) {
     if (!ctm.mapRect(path.getBounds()).isFinite() || !zPlane.isFinite() ||
         !lightPos.isFinite() || !(lightPos.fZ >= SK_ScalarNearlyZero) ||
-        !SkScalarIsFinite(lightRadius) || !(lightRadius >= SK_ScalarNearlyZero)) {
+        !SkIsFinite(lightRadius) || !(lightRadius >= SK_ScalarNearlyZero)) {
         return nullptr;
     }
     SkSpotShadowTessellator spotTess(path, ctm, zPlane, lightPos, lightRadius, transparent,
diff --git a/src/utils/SkShadowUtils.cpp b/src/utils/SkShadowUtils.cpp
index 21d917d..53ce311 100644
--- a/src/utils/SkShadowUtils.cpp
+++ b/src/utils/SkShadowUtils.cpp
@@ -22,6 +22,7 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkVertices.h"
 #include "include/private/SkIDChangeListener.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkTPin.h"
 #include "include/private/base/SkTemplates.h"
 #include "include/private/base/SkTo.h"
@@ -586,7 +587,7 @@
 
 static bool validate_rec(const SkDrawShadowRec& rec) {
     return rec.fLightPos.isFinite() && rec.fZPlaneParams.isFinite() &&
-           SkScalarIsFinite(rec.fLightRadius);
+           SkIsFinite(rec.fLightRadius);
 }
 
 void SkDevice::drawShadow(const SkPath& path, const SkDrawShadowRec& rec) {
diff --git a/tests/Float16Test.cpp b/tests/Float16Test.cpp
index d40be06..e1c21d2 100644
--- a/tests/Float16Test.cpp
+++ b/tests/Float16Test.cpp
@@ -49,7 +49,7 @@
 #endif
 
         float f = SkBits2Float(bits);
-        if (SkScalarIsNaN(f)) {
+        if (SkIsNaN(f)) {
 #ifndef SK_DEBUG
             // We want float->half and half->float to play well with infinities and max
             // representable values in the 16-bit precision, but NaNs should have been caught ahead
@@ -146,8 +146,8 @@
         } else if (e16 == kF16_Exp) {
             if (m16 != 0) {
                 // A NaN stays NaN
-                REPORTER_ASSERT(r, SkScalarIsNaN(actual2));
-                REPORTER_ASSERT(r, SkScalarIsNaN(actual4));
+                REPORTER_ASSERT(r, SkIsNaN(actual2));
+                REPORTER_ASSERT(r, SkIsNaN(actual4));
             } else {
                 // +/- infinity stays infinite
                 if (s16) {
diff --git a/tests/FloatingPointTest.cpp b/tests/FloatingPointTest.cpp
index f284256..9546765 100644
--- a/tests/FloatingPointTest.cpp
+++ b/tests/FloatingPointTest.cpp
@@ -126,7 +126,7 @@
     {
         uint64_t bits = sk_bit_cast<uint64_t>((double) INFINITY);
         double output = sk_bit_cast<double>(bits);
-        REPORTER_ASSERT(reporter, !std::isfinite(output), "%.16f is not infinity", output);
+        REPORTER_ASSERT(reporter, !SkIsFinite(output), "%.16f is not infinity", output);
     }
 }
 
diff --git a/tests/GLBackendSurfaceTest.cpp b/tests/GLBackendSurfaceTest.cpp
index 433c6c1..a11e8b3 100644
--- a/tests/GLBackendSurfaceTest.cpp
+++ b/tests/GLBackendSurfaceTest.cpp
@@ -38,7 +38,7 @@
 struct GrContextOptions;
 
 static bool sampler_params_invalid(const GrGLTextureParameters& parameters) {
-    return SkScalarIsNaN(parameters.samplerOverriddenState().fMaxLOD);
+    return SkIsNaN(parameters.samplerOverriddenState().fMaxLOD);
 }
 
 static bool nonsampler_params_invalid(const GrGLTextureParameters& parameters) {
diff --git a/tests/GeometryTest.cpp b/tests/GeometryTest.cpp
index 653e069..c99c365 100644
--- a/tests/GeometryTest.cpp
+++ b/tests/GeometryTest.cpp
@@ -267,7 +267,7 @@
         do {
             w *= 2;
             test_this_conic_to_quad(reporter, pts, w);
-        } while (SkScalarIsFinite(w));
+        } while (SkIsFinite(w));
         test_this_conic_to_quad(reporter, pts, SK_ScalarNaN);
     }
 }
diff --git a/tests/MathTest.cpp b/tests/MathTest.cpp
index 0b057be..809e9f5 100644
--- a/tests/MathTest.cpp
+++ b/tests/MathTest.cpp
@@ -180,25 +180,27 @@
     REPORTER_ASSERT(reporter, len > 0.999f && len < 1.001f);
 }
 
+template <typename T>
 static void unittest_isfinite(skiatest::Reporter* reporter) {
-    float nan = std::asin(2);
-    float inf = SK_ScalarInfinity;
-    float big = 3.40282e+038f;
+    const T inf = std::numeric_limits<T>::infinity();
+    const T big = std::numeric_limits<T>::max();
+    const T nan = inf * 0;
+    const T zero = 0;
 
-    REPORTER_ASSERT(reporter, !SkScalarIsNaN(inf));
-    REPORTER_ASSERT(reporter, !SkScalarIsNaN(-inf));
-    REPORTER_ASSERT(reporter, !SkScalarIsFinite(inf));
-    REPORTER_ASSERT(reporter, !SkScalarIsFinite(-inf));
+    REPORTER_ASSERT(reporter, !SkIsNaN(inf));
+    REPORTER_ASSERT(reporter, !SkIsNaN(-inf));
+    REPORTER_ASSERT(reporter, !SkIsFinite(inf));
+    REPORTER_ASSERT(reporter, !SkIsFinite(-inf));
 
-    REPORTER_ASSERT(reporter,  SkScalarIsNaN(nan));
-    REPORTER_ASSERT(reporter, !SkScalarIsNaN(big));
-    REPORTER_ASSERT(reporter, !SkScalarIsNaN(-big));
-    REPORTER_ASSERT(reporter, !SkScalarIsNaN(0));
+    REPORTER_ASSERT(reporter,  SkIsNaN(nan));
+    REPORTER_ASSERT(reporter, !SkIsNaN(big));
+    REPORTER_ASSERT(reporter, !SkIsNaN(-big));
+    REPORTER_ASSERT(reporter, !SkIsNaN(zero));
 
-    REPORTER_ASSERT(reporter, !SkScalarIsFinite(nan));
-    REPORTER_ASSERT(reporter,  SkScalarIsFinite(big));
-    REPORTER_ASSERT(reporter,  SkScalarIsFinite(-big));
-    REPORTER_ASSERT(reporter,  SkScalarIsFinite(0));
+    REPORTER_ASSERT(reporter, !SkIsFinite(nan));
+    REPORTER_ASSERT(reporter,  SkIsFinite(big));
+    REPORTER_ASSERT(reporter,  SkIsFinite(-big));
+    REPORTER_ASSERT(reporter,  SkIsFinite(zero));
 }
 
 static void unittest_half(skiatest::Reporter* reporter) {
@@ -237,7 +239,7 @@
     static const FloatUnion overflowHalf = { ((143 << 23) | (1023 << 13)) };
     h = SkFloatToHalf(overflowHalf.fF);
     f = SkHalfToFloat(h);
-    REPORTER_ASSERT(reporter, !SkScalarIsFinite(f) );
+    REPORTER_ASSERT(reporter, !SkIsFinite(f) );
 
     static const FloatUnion underflowHalf = { 101 << 23 };
     h = SkFloatToHalf(underflowHalf.fF);
@@ -247,12 +249,12 @@
     static const FloatUnion inf32 = { 255 << 23 };
     h = SkFloatToHalf(inf32.fF);
     f = SkHalfToFloat(h);
-    REPORTER_ASSERT(reporter, !SkScalarIsFinite(f) );
+    REPORTER_ASSERT(reporter, !SkIsFinite(f) );
 
     static const FloatUnion nan32 = { 255 << 23 | 1 };
     h = SkFloatToHalf(nan32.fF);
     f = SkHalfToFloat(h);
-    REPORTER_ASSERT(reporter, SkScalarIsNaN(f) );
+    REPORTER_ASSERT(reporter, SkIsNaN(f) );
 
 }
 
@@ -505,7 +507,7 @@
 
     {
         SkScalar x = SK_ScalarNaN;
-        REPORTER_ASSERT(reporter, SkScalarIsNaN(x));
+        REPORTER_ASSERT(reporter, SkIsNaN(x));
     }
 
     for (i = 0; i < 10000; i++) {
@@ -539,7 +541,8 @@
     }
 
     huge_vector_normalize(reporter);
-    unittest_isfinite(reporter);
+    unittest_isfinite<float>(reporter);
+    unittest_isfinite<double>(reporter);
     unittest_half(reporter);
     test_rsqrt(reporter, sk_float_rsqrt);
     test_rsqrt(reporter, sk_float_rsqrt_portable);
diff --git a/tests/PDFPrimitivesTest.cpp b/tests/PDFPrimitivesTest.cpp
index 70e832a..3eb0c3f 100644
--- a/tests/PDFPrimitivesTest.cpp
+++ b/tests/PDFPrimitivesTest.cpp
@@ -370,7 +370,7 @@
         ERRORF(reporter, "unscannable result: %s", floatString);
         return;
     }
-    if (std::isfinite(inputFloat) && roundTripFloat != inputFloat) {
+    if (SkIsFinite(inputFloat) && roundTripFloat != inputFloat) {
         ERRORF(reporter, "roundTripFloat (%.9g) != inputFloat (%.9g)",
                roundTripFloat, inputFloat);
     }
diff --git a/tests/PathOpsTestCommon.cpp b/tests/PathOpsTestCommon.cpp
index 5f7c96a..7c04939 100644
--- a/tests/PathOpsTestCommon.cpp
+++ b/tests/PathOpsTestCommon.cpp
@@ -259,16 +259,16 @@
 }
 
 bool ValidBounds(const SkPathOpsBounds& bounds) {
-    if (SkScalarIsNaN(bounds.fLeft)) {
+    if (SkIsNaN(bounds.fLeft)) {
         return false;
     }
-    if (SkScalarIsNaN(bounds.fTop)) {
+    if (SkIsNaN(bounds.fTop)) {
         return false;
     }
-    if (SkScalarIsNaN(bounds.fRight)) {
+    if (SkIsNaN(bounds.fRight)) {
         return false;
     }
-    return !SkScalarIsNaN(bounds.fBottom);
+    return !SkIsNaN(bounds.fBottom);
 }
 
 bool ValidConic(const SkDConic& conic) {
@@ -310,10 +310,10 @@
 
 bool ValidPoints(const SkPoint* pts, int count) {
     for (int index = 0; index < count; ++index) {
-        if (SkScalarIsNaN(pts[index].fX)) {
+        if (SkIsNaN(pts[index].fX)) {
             return false;
         }
-        if (SkScalarIsNaN(pts[index].fY)) {
+        if (SkIsNaN(pts[index].fY)) {
             return false;
         }
     }
diff --git a/tests/PointTest.cpp b/tests/PointTest.cpp
index 73e653f..a605d80 100644
--- a/tests/PointTest.cpp
+++ b/tests/PointTest.cpp
@@ -116,9 +116,9 @@
     length = force_as_float(reporter, length);
 
     // expect this to be non-finite, but dump the results if not.
-    if (SkScalarIsFinite(length)) {
+    if (SkIsFinite(length)) {
         SkDebugf("length(%g, %g) == %g\n", pt.fX, pt.fY, length);
-        REPORTER_ASSERT(reporter, !SkScalarIsFinite(length));
+        REPORTER_ASSERT(reporter, !SkIsFinite(length));
     }
 
     // this should succeed, even though we can't represent length
diff --git a/tests/QuadRootsTest.cpp b/tests/QuadRootsTest.cpp
index 5af7449..3f13ee6 100644
--- a/tests/QuadRootsTest.cpp
+++ b/tests/QuadRootsTest.cpp
@@ -364,7 +364,7 @@
                C = testCase.C,
                answerLo = testCase.answerLo,
                answerHi = testCase.answerHi;
-        if (std::isfinite(answerLo) && std::isfinite(answerHi)) {
+        if (SkIsFinite(answerLo, answerHi)) {
             SkASSERT(answerLo <= answerHi);
         }
         auto [discriminate, r0, r1] = SkQuads::Roots(A, -0.5*B, C);
diff --git a/tests/RectTest.cpp b/tests/RectTest.cpp
index 6bb0ccc..6b309f4 100644
--- a/tests/RectTest.cpp
+++ b/tests/RectTest.cpp
@@ -167,18 +167,18 @@
     const SkRect r = { -big, -big, big, big };
 
     REPORTER_ASSERT(reporter, r.isFinite());
-    REPORTER_ASSERT(reporter, !SkScalarIsFinite(r.width()));
-    REPORTER_ASSERT(reporter, !SkScalarIsFinite(r.height()));
+    REPORTER_ASSERT(reporter, !SkIsFinite(r.width()));
+    REPORTER_ASSERT(reporter, !SkIsFinite(r.height()));
 
     // ensure we can compute center even when the width/height might overflow
-    REPORTER_ASSERT(reporter, SkScalarIsFinite(r.centerX()));
-    REPORTER_ASSERT(reporter, SkScalarIsFinite(r.centerY()));
+    REPORTER_ASSERT(reporter, SkIsFinite(r.centerX()));
+    REPORTER_ASSERT(reporter, SkIsFinite(r.centerY()));
 
 
     // ensure we can compute halfWidth and halfHeight even when width/height might overflow,
     // i.e. for use computing the radii filling a rectangle.
-    REPORTER_ASSERT(reporter, SkScalarIsFinite(SkRectPriv::HalfWidth(r)));
-    REPORTER_ASSERT(reporter, SkScalarIsFinite(SkRectPriv::HalfHeight(r)));
+    REPORTER_ASSERT(reporter, SkIsFinite(SkRectPriv::HalfWidth(r)));
+    REPORTER_ASSERT(reporter, SkIsFinite(SkRectPriv::HalfHeight(r)));
 }
 
 DEF_TEST(Rect_subtract, reporter) {
diff --git a/tests/ScalarTest.cpp b/tests/ScalarTest.cpp
index 382b86c..8b8fb1d 100644
--- a/tests/ScalarTest.cpp
+++ b/tests/ScalarTest.cpp
@@ -97,7 +97,7 @@
 }
 
 static bool isFinite_float(float x) {
-    return SkToBool(std::isfinite(x));
+    return SkToBool(SkIsFinite(x));
 }
 
 static bool isFinite_mulzero(float x) {
@@ -128,16 +128,16 @@
 static void test_floatclass(skiatest::Reporter* reporter, float value, FloatClass fc) {
     // our sk_float_is... function may return int instead of bool,
     // hence the double ! to turn it into a bool
-    REPORTER_ASSERT(reporter, !!std::isfinite(value) == (fc == kFinite));
-    REPORTER_ASSERT(reporter, !!std::isinf(value)    == (fc == kInfinite));
-    REPORTER_ASSERT(reporter, !!std::isnan(value)    == (fc == kNaN));
+    REPORTER_ASSERT(reporter, !!SkIsFinite(value) == (fc == kFinite));
+    REPORTER_ASSERT(reporter, !!std::isinf(value) == (fc == kInfinite));
+    REPORTER_ASSERT(reporter, !!SkIsNaN(value)    == (fc == kNaN));
 }
 
 #if defined _WIN32
-#pragma warning ( push )
+#pragma warning(push)
 // we are intentionally causing an overflow here
 //      (warning C4756: overflow in constant arithmetic)
-#pragma warning ( disable : 4756 )
+#pragma warning(disable : 4756)
 #endif
 
 static void test_isfinite(skiatest::Reporter* reporter) {
diff --git a/tests/SkRasterPipelineTest.cpp b/tests/SkRasterPipelineTest.cpp
index b2795bc..c161ae0 100644
--- a/tests/SkRasterPipelineTest.cpp
+++ b/tests/SkRasterPipelineTest.cpp
@@ -2971,7 +2971,7 @@
             }
             for (int j = i; j < 4; j++) {
                 for (auto f : buffer[j]) {
-                    REPORTER_ASSERT(r, SkScalarIsNaN(f));
+                    REPORTER_ASSERT(r, SkIsNaN(f));
                 }
             }
         }
diff --git a/tests/SkStrikeTest.cpp b/tests/SkStrikeTest.cpp
index 4e6a912..c16d3a9 100644
--- a/tests/SkStrikeTest.cpp
+++ b/tests/SkStrikeTest.cpp
@@ -81,7 +81,7 @@
         rejectedSize = 0;
     StrikeMutationMonitor m{strike};
     for (auto [glyphID, pos] : source) {
-        if (!SkScalarsAreFinite(pos.x(), pos.y())) {
+        if (!SkIsFinite(pos.x(), pos.y())) {
             continue;
         }
         const SkPackedGlyphID packedID{glyphID};
diff --git a/tools/testrunners/benchmark/BazelBenchmarkTestRunner.cpp b/tools/testrunners/benchmark/BazelBenchmarkTestRunner.cpp
index ff138db..8e2dba3 100644
--- a/tools/testrunners/benchmark/BazelBenchmarkTestRunner.cpp
+++ b/tools/testrunners/benchmark/BazelBenchmarkTestRunner.cpp
@@ -274,7 +274,7 @@
                 // https://skia.googlesource.com/skia/+/a063eaeaf1e09e4d6f42e0f44a5723622a46d21c/bench/ResultsWriter.h#51.
                 //
                 // Don't record if NaN or Inf.
-                if (std::isfinite(singleMeasurement.measurement)) {
+                if (SkIsFinite(singleMeasurement.measurement)) {
                     fJson.beginObject();
                     fJson.appendCString("value", singleMeasurement.value.c_str());
                     fJson.appendDoubleDigits("measurement", singleMeasurement.measurement, 16);
diff --git a/tools/viewer/FilterBoundsSlide.cpp b/tools/viewer/FilterBoundsSlide.cpp
index 24858c5..abab955 100644
--- a/tools/viewer/FilterBoundsSlide.cpp
+++ b/tools/viewer/FilterBoundsSlide.cpp
@@ -143,7 +143,7 @@
                 SkPoint(mapping.paramToLayer(skif::ParameterSpace<SkPoint>(testPoints[i]))));
         SkColor4f color = {0.f, 0.f, 0.f, 1.f};
 
-        if (SkScalarIsFinite(scale)) {
+        if (SkIsFinite(scale)) {
             float logScale = SkScalarLog2(scale);
             for (int j = 0; j <= kStopCount; ++j) {
                 if (j == kStopCount) {