Bug 1660405 - Move away from mozilla::IsFinite in favor of std::isfin…

…ite. r=sergesanspaille Differential Revision: https://phabricator.services.mozilla.com/D173036
iaxat · Mar 22, 2023 · 426691b · 426691b
1 parent cc4638d
commit 426691b
Show file tree

Hide file tree

Showing 56 changed files with 138 additions and 143 deletions.
diff --git a/dom/animation/AnimationEffect.cpp b/dom/animation/AnimationEffect.cpp
@@ -183,7 +183,7 @@ ComputedTiming AnimationEffect::GetComputedTimingAt(
   }
 
   // Factor in iteration start offset.
-  if (IsFinite(overallProgress)) {
+  if (std::isfinite(overallProgress)) {
     overallProgress += result.mIterationStart;
   }
 
@@ -200,7 +200,7 @@ ComputedTiming AnimationEffect::GetComputedTimingAt(
   // Convert the overall progress to a fraction of a single iteration--the
   // simply iteration progress.
   // https://drafts.csswg.org/web-animations/#simple-iteration-progress
-  double progress = IsFinite(overallProgress)
+  double progress = std::isfinite(overallProgress)
                         ? fmod(overallProgress, 1.0)
                         : fmod(result.mIterationStart, 1.0);
 
@@ -260,7 +260,7 @@ ComputedTiming AnimationEffect::GetComputedTimingAt(
     progress = fn->At(progress, result.mBeforeFlag);
   }
 
-  MOZ_ASSERT(IsFinite(progress), "Progress value should be finite");
+  MOZ_ASSERT(std::isfinite(progress), "Progress value should be finite");
   result.mProgress.SetValue(progress);
   return result;
 }

diff --git a/dom/base/DOMMatrix.cpp b/dom/base/DOMMatrix.cpp
@@ -512,7 +512,7 @@ void DOMMatrixReadOnly::Stringify(nsAString& aResult, ErrorResult& aRv) {
   nsAutoString matrixStr;
   auto AppendDouble = [&aRv, &cbuf, &matrixStr](double d,
                                                 bool isLastItem = false) {
-    if (!mozilla::IsFinite(d)) {
+    if (!std::isfinite(d)) {
       aRv.ThrowInvalidStateError(
           "Matrix with a non-finite element cannot be stringified.");
       return false;

diff --git a/dom/base/nsContentUtils.h b/dom/base/nsContentUtils.h
@@ -3608,28 +3608,28 @@ class TreeOrderComparator {
  * series is not finite.
  */
 #define NS_ENSURE_FINITE(f, rv) \
-  if (!mozilla::IsFinite(f)) {  \
+  if (!std::isfinite(f)) {      \
     return (rv);                \
   }
 
-#define NS_ENSURE_FINITE2(f1, f2, rv)    \
-  if (!mozilla::IsFinite((f1) + (f2))) { \
-    return (rv);                         \
+#define NS_ENSURE_FINITE2(f1, f2, rv) \
+  if (!std::isfinite((f1) + (f2))) {  \
+    return (rv);                      \
   }
 
-#define NS_ENSURE_FINITE4(f1, f2, f3, f4, rv)          \
-  if (!mozilla::IsFinite((f1) + (f2) + (f3) + (f4))) { \
-    return (rv);                                       \
+#define NS_ENSURE_FINITE4(f1, f2, f3, f4, rv)      \
+  if (!std::isfinite((f1) + (f2) + (f3) + (f4))) { \
+    return (rv);                                   \
   }
 
-#define NS_ENSURE_FINITE5(f1, f2, f3, f4, f5, rv)             \
-  if (!mozilla::IsFinite((f1) + (f2) + (f3) + (f4) + (f5))) { \
-    return (rv);                                              \
+#define NS_ENSURE_FINITE5(f1, f2, f3, f4, f5, rv)         \
+  if (!std::isfinite((f1) + (f2) + (f3) + (f4) + (f5))) { \
+    return (rv);                                          \
   }
 
-#define NS_ENSURE_FINITE6(f1, f2, f3, f4, f5, f6, rv)                \
-  if (!mozilla::IsFinite((f1) + (f2) + (f3) + (f4) + (f5) + (f6))) { \
-    return (rv);                                                     \
+#define NS_ENSURE_FINITE6(f1, f2, f3, f4, f5, f6, rv)            \
+  if (!std::isfinite((f1) + (f2) + (f3) + (f4) + (f5) + (f6))) { \
+    return (rv);                                                 \
   }
 
 // Deletes a linked list iteratively to avoid blowing up the stack (bug 460444).

diff --git a/dom/bindings/Codegen.py b/dom/bindings/Codegen.py
@@ -7354,7 +7354,7 @@ def getConversionCode(varName):
         template = template.rstrip()
         template += fill(
             """
-             else if (!mozilla::IsFinite(${readLoc})) {
+             else if (!std::isfinite(${readLoc})) {
               $*{nonFiniteCode}
             }
             """,

diff --git a/dom/bindings/PrimitiveConversions.h b/dom/bindings/PrimitiveConversions.h
@@ -198,7 +198,7 @@ inline bool PrimitiveConversionTraits_EnforceRange(
   static_assert(std::numeric_limits<T>::is_integer,
                 "This can only be applied to integers!");
 
-  if (!mozilla::IsFinite(d)) {
+  if (!std::isfinite(d)) {
     return cx.ThrowErrorMessage<MSG_ENFORCE_RANGE_NON_FINITE>(
         sourceDescription, TypeName<T>::value());
   }
@@ -242,7 +242,7 @@ inline bool PrimitiveConversionTraits_Clamp(JSContext* cx,
     return true;
   }
 
-  MOZ_ASSERT(mozilla::IsFinite(d));
+  MOZ_ASSERT(std::isfinite(d));
 
   // Banker's rounding (round ties towards even).
   // We move away from 0 by 0.5f and then truncate.  That gets us the right

diff --git a/dom/canvas/CanvasRenderingContext2D.cpp b/dom/canvas/CanvasRenderingContext2D.cpp
@@ -3208,7 +3208,8 @@ static void RoundRectImpl(
         aRadii,
     ErrorResult& aError) {
   // Step 1. If any of x, y, w, or h are infinite or NaN, then return.
-  if (!IsFinite(aX) || !IsFinite(aY) || !IsFinite(aW) || !IsFinite(aH)) {
+  if (!std::isfinite(aX) || !std::isfinite(aY) || !std::isfinite(aW) ||
+      !std::isfinite(aH)) {
     return;
   }
 
@@ -3240,7 +3241,7 @@ static void RoundRectImpl(
       const DOMPointInit& point = radius.GetAsDOMPointInit();
       // Step 5.1.1. If radius["x"] or radius["y"] is infinite or NaN, then
       // return.
-      if (!IsFinite(point.mX) || !IsFinite(point.mY)) {
+      if (!std::isfinite(point.mX) || !std::isfinite(point.mY)) {
         return;
       }
 
@@ -3261,7 +3262,7 @@ static void RoundRectImpl(
     // Step 5.2. If radius is a unrestricted double:
     double r = radius.GetAsUnrestrictedDouble();
     // Step 5.2.1. If radius is infinite or NaN, then return.
-    if (!IsFinite(r)) {
+    if (!std::isfinite(r)) {
       return;
     }
 
@@ -4257,7 +4258,7 @@ TextMetrics* CanvasRenderingContext2D::DrawOrMeasureText(
     return nullptr;
   }
 
-  if (!IsFinite(aX) || !IsFinite(aY)) {
+  if (!std::isfinite(aX) || !std::isfinite(aY)) {
     aError = NS_OK;
     // This may not be correct - what should TextMetrics contain in the case of
     // infinite width or height?

diff --git a/dom/canvas/CanvasUtils.h b/dom/canvas/CanvasUtils.h
@@ -70,7 +70,7 @@ bool CoerceDouble(const JS::Value& v, double* d);
 
 /* Float validation stuff */
 #define VALIDATE(_f) \
-  if (!IsFinite(_f)) return false
+  if (!std::isfinite(_f)) return false
 
 inline bool FloatValidate(double f1) {
   VALIDATE(f1);

diff --git a/dom/canvas/DrawTargetWebgl.cpp b/dom/canvas/DrawTargetWebgl.cpp
@@ -2709,8 +2709,8 @@ static Maybe<AAStroke::VertexBuffer> GenerateStrokeVertexBuffer(
                                  ToAAStrokeLineCap(aStrokeOptions->mLineCap),
                                  ToAAStrokeLineJoin(aStrokeOptions->mLineJoin),
                                  aStrokeOptions->mMiterLimit};
-  if (style.width <= 0.0f || !IsFinite(style.width) ||
-      style.miter_limit <= 0.0f || !IsFinite(style.miter_limit)) {
+  if (style.width <= 0.0f || !std::isfinite(style.width) ||
+      style.miter_limit <= 0.0f || !std::isfinite(style.miter_limit)) {
     return Nothing();
   }
   AAStroke::Stroker* s = AAStroke::aa_stroke_new(

diff --git a/dom/html/HTMLInputElement.cpp b/dom/html/HTMLInputElement.cpp
@@ -1859,7 +1859,7 @@ void HTMLInputElement::SetValueAsNumber(double aValueAsNumber,
                                         ErrorResult& aRv) {
   // TODO: return TypeError when HTMLInputElement is converted to WebIDL, see
   // bug 825197.
-  if (IsInfinite(aValueAsNumber)) {
+  if (std::isinf(aValueAsNumber)) {
     aRv.Throw(NS_ERROR_INVALID_ARG);
     return;
   }

diff --git a/dom/media/ChannelMediaDecoder.cpp b/dom/media/ChannelMediaDecoder.cpp
@@ -417,7 +417,7 @@ ChannelMediaDecoder::ComputePlaybackRate(const MediaChannelStatistics& aStats,
   MOZ_ASSERT(!NS_IsMainThread());
 
   int64_t length = aResource->GetLength();
-  if (mozilla::IsFinite<double>(aDuration) && aDuration > 0 && length >= 0 &&
+  if (std::isfinite(aDuration) && aDuration > 0 && length >= 0 &&
       length / aDuration < UINT32_MAX) {
     return {uint32_t(length / aDuration), true};
   }

diff --git a/dom/media/MediaDecoder.cpp b/dom/media/MediaDecoder.cpp
@@ -36,6 +36,7 @@
 #include "nsTArray.h"
 #include "WindowRenderer.h"
 #include <algorithm>
+#include <cmath>
 #include <limits>
 
 using namespace mozilla::dom;
@@ -246,7 +247,7 @@ double MediaDecoder::GetDuration() {
 
 bool MediaDecoder::IsInfinite() const {
   MOZ_ASSERT(NS_IsMainThread());
-  return mozilla::IsInfinite<double>(mDuration);
+  return std::isinf(mDuration);
 }
 
 #define INIT_MIRROR(name, val) \

diff --git a/dom/media/MediaMIMETypes.cpp b/dom/media/MediaMIMETypes.cpp
@@ -193,7 +193,7 @@ Maybe<MediaExtendedMIMEType> MakeMediaExtendedMIMEType(
   rv = parser.GetParameter("codecs", codecs);
   bool haveCodecs = NS_SUCCEEDED(rv);
 
-  if (!IsFinite(aConfig.mFramerate) || aConfig.mFramerate <= 0.0) {
+  if (!std::isfinite(aConfig.mFramerate) || aConfig.mFramerate <= 0.0) {
     return Nothing();
   }
 

diff --git a/dom/media/webaudio/AudioEventTimeline.h b/dom/media/webaudio/AudioEventTimeline.h
@@ -365,7 +365,7 @@ class AudioEventTimeline {
 
   const AudioTimelineEvent* GetPreviousEvent(double aTime) const;
 
-  static bool IsValid(double value) { return mozilla::IsFinite(value); }
+  static bool IsValid(double value) { return std::isfinite(value); }
 
   // This is a sorted array of the events in the timeline.  Queries of this
   // data structure should probably be more frequent than modifications to it,

diff --git a/dom/media/webaudio/PannerNode.cpp b/dom/media/webaudio/PannerNode.cpp
@@ -354,7 +354,7 @@ void PannerNode::SetPanningModel(PanningModelType aPanningModel) {
 static bool SetParamFromDouble(AudioParam* aParam, double aValue,
                                const char (&aParamName)[2], ErrorResult& aRv) {
   float value = static_cast<float>(aValue);
-  if (!mozilla::IsFinite(value)) {
+  if (!std::isfinite(value)) {
     aRv.ThrowTypeError<MSG_NOT_FINITE>(aParamName);
     return false;
   }

diff --git a/dom/media/webaudio/blink/Reverb.cpp b/dom/media/webaudio/blink/Reverb.cpp
@@ -61,7 +61,7 @@ static float calculateNormalizationScale(const nsTArray<const float*>& response,
   power = sqrt(power / (numberOfChannels * aLength));
 
   // Protect against accidental overload
-  if (!IsFinite(power) || std::isnan(power) || power < MinPower)
+  if (!std::isfinite(power) || std::isnan(power) || power < MinPower)
     power = MinPower;
 
   float scale = 1 / power;

diff --git a/dom/svg/DOMSVGLength.cpp b/dom/svg/DOMSVGLength.cpp
@@ -152,7 +152,7 @@ float DOMSVGLength::GetValue(ErrorResult& aRv) {
   if (nsCOMPtr<DOMSVGLengthList> lengthList = do_QueryInterface(mOwner)) {
     float value = InternalItem().GetValueInUserUnits(lengthList->Element(),
                                                      lengthList->Axis());
-    if (!IsFinite(value)) {
+    if (!std::isfinite(value)) {
       aRv.Throw(NS_ERROR_FAILURE);
     }
     return value;
@@ -196,7 +196,7 @@ void DOMSVGLength::SetValue(float aUserUnitValue, ErrorResult& aRv) {
                                                        lengthList->Axis());
     if (uuPerUnit > 0) {
       float newValue = aUserUnitValue / uuPerUnit;
-      if (IsFinite(newValue)) {
+      if (std::isfinite(newValue)) {
         AutoChangeLengthListNotifier notifier(this);
         internalItem.SetValueAndUnit(newValue, internalItem.GetUnit());
         return;
@@ -357,7 +357,7 @@ void DOMSVGLength::ConvertToSpecifiedUnits(uint16_t aUnit, ErrorResult& aRv) {
   } else {
     val = SVGLength(mValue, mUnit).GetValueInSpecifiedUnit(aUnit, nullptr, 0);
   }
-  if (IsFinite(val)) {
+  if (std::isfinite(val)) {
     if (HasOwner()) {
       AutoChangeLengthListNotifier notifier(this);
       InternalItem().SetValueAndUnit(val, aUnit);

diff --git a/dom/svg/DOMSVGTransform.cpp b/dom/svg/DOMSVGTransform.cpp
@@ -214,7 +214,7 @@ void DOMSVGTransform::SetSkewX(float angle, ErrorResult& rv) {
     return;
   }
 
-  if (!IsFinite(tan(angle * kRadPerDegree))) {
+  if (!std::isfinite(tan(angle * kRadPerDegree))) {
     rv.ThrowRangeError<MSG_INVALID_TRANSFORM_ANGLE_ERROR>();
     return;
   }
@@ -235,7 +235,7 @@ void DOMSVGTransform::SetSkewY(float angle, ErrorResult& rv) {
     return;
   }
 
-  if (!IsFinite(tan(angle * kRadPerDegree))) {
+  if (!std::isfinite(tan(angle * kRadPerDegree))) {
     rv.ThrowRangeError<MSG_INVALID_TRANSFORM_ANGLE_ERROR>();
     return;
   }

diff --git a/dom/svg/SVGAnimatedLength.cpp b/dom/svg/SVGAnimatedLength.cpp
@@ -320,7 +320,7 @@ nsresult SVGAnimatedLength::ConvertToSpecifiedUnits(uint16_t unitType,
       mBaseVal * GetPixelsPerUnit(aSVGElement, mSpecifiedUnitType);
   float valueInSpecifiedUnits = valueInUserUnits / pixelsPerUnit;
 
-  if (!IsFinite(valueInSpecifiedUnits)) {
+  if (!std::isfinite(valueInSpecifiedUnits)) {
     return NS_ERROR_ILLEGAL_VALUE;
   }
 
@@ -416,7 +416,7 @@ nsresult SVGAnimatedLength::SetBaseValue(float aValue, SVGElement* aSVGElement,
   }
 
   float valueInSpecifiedUnits = aValue / pixelsPerUnit;
-  if (!IsFinite(valueInSpecifiedUnits)) {
+  if (!std::isfinite(valueInSpecifiedUnits)) {
     return NS_ERROR_ILLEGAL_VALUE;
   }
 
@@ -439,7 +439,7 @@ nsresult SVGAnimatedLength::SetAnimValue(float aValue,
   float valueInSpecifiedUnits =
       aValue / GetPixelsPerUnit(aSVGElement, mSpecifiedUnitType);
 
-  if (IsFinite(valueInSpecifiedUnits)) {
+  if (std::isfinite(valueInSpecifiedUnits)) {
     SetAnimValueInSpecifiedUnits(valueInSpecifiedUnits, aSVGElement);
     return NS_OK;
   }

diff --git a/dom/svg/SVGAnimatedNumber.h b/dom/svg/SVGAnimatedNumber.h
@@ -75,7 +75,7 @@ class SVGAnimatedNumber {
 
     float BaseVal() override { return mVal->GetBaseValue(); }
     void SetBaseVal(float aValue) override {
-      MOZ_ASSERT(IsFinite(aValue));
+      MOZ_ASSERT(std::isfinite(aValue));
       mVal->SetBaseValue(aValue, mSVGElement);
     }
 

diff --git a/dom/svg/SVGAnimatedNumberPair.h b/dom/svg/SVGAnimatedNumberPair.h
@@ -86,7 +86,7 @@ class SVGAnimatedNumberPair {
 
     float BaseVal() override { return mVal->GetBaseValue(mIndex); }
     void SetBaseVal(float aValue) override {
-      MOZ_ASSERT(IsFinite(aValue));
+      MOZ_ASSERT(std::isfinite(aValue));
       mVal->SetBaseValue(aValue, mIndex, mSVGElement);
     }
 

diff --git a/dom/svg/SVGContentUtils.cpp b/dom/svg/SVGContentUtils.cpp
@@ -183,7 +183,7 @@ static DashState GetStrokeDashData(
     if (auto* shapeElement = SVGGeometryElement::FromNode(aElement)) {
       pathScale =
           shapeElement->GetPathLengthScale(SVGGeometryElement::eForStroking);
-      if (pathScale <= 0 || !IsFinite(pathScale)) {
+      if (pathScale <= 0 || !std::isfinite(pathScale)) {
         return eContinuousStroke;
       }
     }
@@ -720,7 +720,7 @@ bool SVGContentUtils::ParseNumber(RangedPtr<const char16_t>& aIter,
     return false;
   }
   floatType floatValue = floatType(value);
-  if (!IsFinite(floatValue)) {
+  if (!std::isfinite(floatValue)) {
     return false;
   }
   aValue = floatValue;

diff --git a/dom/svg/SVGLength.cpp b/dom/svg/SVGLength.cpp
@@ -122,16 +122,16 @@ float SVGLength::GetValueInSpecifiedUnit(uint8_t aUnit,
       SVGLength(0.0f, aUnit).GetUserUnitsPerUnit(aElement, aAxis);
 
   NS_ASSERTION(
-      userUnitsPerCurrentUnit >= 0 || !IsFinite(userUnitsPerCurrentUnit),
+      userUnitsPerCurrentUnit >= 0 || !std::isfinite(userUnitsPerCurrentUnit),
       "bad userUnitsPerCurrentUnit");
-  NS_ASSERTION(userUnitsPerNewUnit >= 0 || !IsFinite(userUnitsPerNewUnit),
+  NS_ASSERTION(userUnitsPerNewUnit >= 0 || !std::isfinite(userUnitsPerNewUnit),
                "bad userUnitsPerNewUnit");
 
   float value = mValue * userUnitsPerCurrentUnit / userUnitsPerNewUnit;
 
   // userUnitsPerCurrentUnit could be infinity, or userUnitsPerNewUnit could
   // be zero.
-  if (IsFinite(value)) {
+  if (std::isfinite(value)) {
     return value;
   }
   return std::numeric_limits<float>::quiet_NaN();

diff --git a/dom/svg/SVGLength.h b/dom/svg/SVGLength.h
@@ -122,7 +122,9 @@ class SVGLength {
 
  private:
 #ifdef DEBUG
-  bool IsValid() const { return IsFinite(mValue) && IsValidUnitType(mUnit); }
+  bool IsValid() const {
+    return std::isfinite(mValue) && IsValidUnitType(mUnit);
+  }
 #endif
 
   /**

diff --git a/dom/svg/SVGLengthListSMILType.cpp b/dom/svg/SVGLengthListSMILType.cpp
@@ -208,7 +208,7 @@ nsresult SVGLengthListSMILType::ComputeDistance(const SMILValue& aFrom,
   }
 
   float distance = sqrt(total);
-  if (!IsFinite(distance)) {
+  if (!std::isfinite(distance)) {
     return NS_ERROR_FAILURE;
   }
   aDistance = distance;

diff --git a/dom/svg/SVGMarkerElement.cpp b/dom/svg/SVGMarkerElement.cpp
@@ -111,7 +111,7 @@ void SVGMarkerElement::SetOrientToAuto() {
 
 void SVGMarkerElement::SetOrientToAngle(DOMSVGAngle& angle, ErrorResult& rv) {
   float f = angle.Value();
-  if (!IsFinite(f)) {
+  if (!std::isfinite(f)) {
     rv.ThrowTypeError("Unknown or invalid type");
     return;
   }