Stop calling std::isfinite(double) and then casting to float

third_party/WebKit/Source/modules/canvas2d/BaseRenderingContext2D.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/canvas2d/BaseRenderingContext2D.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/css/cssom/CSSURLImageValue.h"
@@ skipping 13 matching lines @@
 #include "platform/geometry/FloatQuad.h"
 #include "platform/graphics/Color.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/Image.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/StrokeData.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 
 namespace blink {
 
+namespace {
+
+bool IsFiniteFloat(float x) {
+  return std::isfinite(x);
+}
+
+bool IsFiniteFloat(double x) {
+  if (!std::isfinite(x))
+    return false;
+  constexpr double max_float_as_double =
+      static_cast<double>(std::numeric_limits<float>::max());
+  if (x > max_float_as_double)
+    return false;
+  return true;
+}
+}
+
 BaseRenderingContext2D::BaseRenderingContext2D()
     : m_clipAntialiasing(NotAntiAliased) {
   m_stateStack.append(CanvasRenderingContext2DState::create());
 }
 
 BaseRenderingContext2D::~BaseRenderingContext2D() {}
 
 CanvasRenderingContext2DState& BaseRenderingContext2D::modifiableState() {
   realizeSaves();
   return *m_stateStack.back();
@@ skipping 189 matching lines @@
   modifiableState().setFillStyle(canvasStyle);
   modifiableState().setUnparsedFillColor(colorString);
   modifiableState().clearResolvedFilter();
 }
 
 double BaseRenderingContext2D::lineWidth() const {
   return state().lineWidth();
 }
 
 void BaseRenderingContext2D::setLineWidth(double width) {
-  if (!std::isfinite(width) || width <= 0)
+  if (!IsFiniteFloat(width) || width <= 0)
     return;
   if (state().lineWidth() == width)
     return;
   modifiableState().setLineWidth(width);
 }
 
 String BaseRenderingContext2D::lineCap() const {
   return lineCapName(state().getLineCap());
 }
 
@@ skipping 17 matching lines @@
   if (state().getLineJoin() == join)
     return;
   modifiableState().setLineJoin(join);
 }
 
 double BaseRenderingContext2D::miterLimit() const {
   return state().miterLimit();
 }
 
 void BaseRenderingContext2D::setMiterLimit(double limit) {
-  if (!std::isfinite(limit) || limit <= 0)
+  if (!IsFiniteFloat(limit) || limit <= 0)
     return;
   if (state().miterLimit() == limit)
     return;
   modifiableState().setMiterLimit(limit);
 }
 
 double BaseRenderingContext2D::shadowOffsetX() const {
   return state().shadowOffset().width();
 }
 
 void BaseRenderingContext2D::setShadowOffsetX(double x) {
-  if (!std::isfinite(x))
+  if (!IsFiniteFloat(x))
     return;
   if (state().shadowOffset().width() == x)
     return;
   modifiableState().setShadowOffsetX(x);
 }
 
 double BaseRenderingContext2D::shadowOffsetY() const {
   return state().shadowOffset().height();
 }
 
 void BaseRenderingContext2D::setShadowOffsetY(double y) {
-  if (!std::isfinite(y))
+  if (!IsFiniteFloat(y))
     return;
   if (state().shadowOffset().height() == y)
     return;
   modifiableState().setShadowOffsetY(y);
 }
 
 double BaseRenderingContext2D::shadowBlur() const {
   return state().shadowBlur();
 }
 
 void BaseRenderingContext2D::setShadowBlur(double blur) {
-  if (!std::isfinite(blur) || blur < 0)
+  if (!IsFiniteFloat(blur) || blur < 0)
     return;
   if (state().shadowBlur() == blur)
     return;
   modifiableState().setShadowBlur(blur);
 }
 
 String BaseRenderingContext2D::shadowColor() const {
   return Color(state().shadowColor()).serialized();
 }
 
 void BaseRenderingContext2D::setShadowColor(const String& colorString) {
   Color color;
   if (!parseColorOrCurrentColor(color, colorString))
     return;
   if (state().shadowColor() == color)
     return;
   modifiableState().setShadowColor(color.rgb());
 }
 
 const Vector<double>& BaseRenderingContext2D::getLineDash() const {
   return state().lineDash();
 }
 
 static bool lineDashSequenceIsValid(const Vector<double>& dash) {
   for (size_t i = 0; i < dash.size(); i++) {
-    if (!std::isfinite(dash[i]) || dash[i] < 0)
+    if (!IsFiniteFloat(dash[i]) || dash[i] < 0)
       return false;
   }
   return true;
 }
 
 void BaseRenderingContext2D::setLineDash(const Vector<double>& dash) {
   if (!lineDashSequenceIsValid(dash))
     return;
   modifiableState().setLineDash(dash);
 }
 
 double BaseRenderingContext2D::lineDashOffset() const {
   return state().lineDashOffset();
 }
 
 void BaseRenderingContext2D::setLineDashOffset(double offset) {
-  if (!std::isfinite(offset) || state().lineDashOffset() == offset)
+  if (!IsFiniteFloat(offset) || state().lineDashOffset() == offset)
     return;
   modifiableState().setLineDashOffset(offset);
 }
 
 double BaseRenderingContext2D::globalAlpha() const {
   return state().globalAlpha();
 }
 
 void BaseRenderingContext2D::setGlobalAlpha(double alpha) {
   if (!(alpha >= 0 && alpha <= 1))
@@ skipping 51 matching lines @@
   const AffineTransform& transform = matrixTearOff->value();
   setTransform(transform.a(), transform.b(), transform.c(), transform.d(),
                transform.e(), transform.f());
 }
 
 void BaseRenderingContext2D::scale(double sx, double sy) {
   SkCanvas* c = drawingCanvas();
   if (!c)
     return;
 
-  if (!std::isfinite(sx) || !std::isfinite(sy))
+  if (!IsFiniteFloat(sx) || !IsFiniteFloat(sy))
     return;
 
   AffineTransform newTransform = state().transform();
   newTransform.scaleNonUniform(sx, sy);
   if (state().transform() == newTransform)
     return;
 
   modifiableState().setTransform(newTransform);
   if (!state().isTransformInvertible())
     return;
 
   c->scale(sx, sy);
   m_path.transform(AffineTransform().scaleNonUniform(1.0 / sx, 1.0 / sy));
 }
 
 void BaseRenderingContext2D::rotate(double angleInRadians) {
   SkCanvas* c = drawingCanvas();
   if (!c)
     return;
 
-  if (!std::isfinite(angleInRadians))
+  if (!IsFiniteFloat(angleInRadians))
     return;
 
   AffineTransform newTransform = state().transform();
   newTransform.rotateRadians(angleInRadians);
   if (state().transform() == newTransform)
     return;
 
   modifiableState().setTransform(newTransform);
   if (!state().isTransformInvertible())
     return;
   c->rotate(angleInRadians * (180.0 / piFloat));
   m_path.transform(AffineTransform().rotateRadians(-angleInRadians));
 }
 
 void BaseRenderingContext2D::translate(double tx, double ty) {
   SkCanvas* c = drawingCanvas();
   if (!c)
     return;
   if (!state().isTransformInvertible())
     return;
 
-  if (!std::isfinite(tx) || !std::isfinite(ty))
+  if (!IsFiniteFloat(tx) || !IsFiniteFloat(ty))
     return;
 
   AffineTransform newTransform = state().transform();
   newTransform.translate(tx, ty);
   if (state().transform() == newTransform)
     return;
 
   modifiableState().setTransform(newTransform);
   if (!state().isTransformInvertible())
     return;
   c->translate(tx, ty);
   m_path.transform(AffineTransform().translate(-tx, -ty));
 }
 
 void BaseRenderingContext2D::transform(double m11,
                                        double m12,
                                        double m21,
                                        double m22,
                                        double dx,
                                        double dy) {
   SkCanvas* c = drawingCanvas();
   if (!c)
     return;
 
-  if (!std::isfinite(m11) || !std::isfinite(m21) || !std::isfinite(dx) ||
-      !std::isfinite(m12) || !std::isfinite(m22) || !std::isfinite(dy))
+  if (!IsFiniteFloat(m11) || !IsFiniteFloat(m21) || !IsFiniteFloat(dx) ||
+      !IsFiniteFloat(m12) || !IsFiniteFloat(m22) || !IsFiniteFloat(dy))
     return;
 
   AffineTransform transform(m11, m12, m21, m22, dx, dy);
   AffineTransform newTransform = state().transform() * transform;
   if (state().transform() == newTransform)
     return;
 
   modifiableState().setTransform(newTransform);
   if (!state().isTransformInvertible())
     return;
@@ skipping 29 matching lines @@
 void BaseRenderingContext2D::setTransform(double m11,
                                           double m12,
                                           double m21,
                                           double m22,
                                           double dx,
                                           double dy) {
   SkCanvas* c = drawingCanvas();
   if (!c)
     return;
 
-  if (!std::isfinite(m11) || !std::isfinite(m21) || !std::isfinite(dx) ||
-      !std::isfinite(m12) || !std::isfinite(m22) || !std::isfinite(dy))
+  if (!IsFiniteFloat(m11) || !IsFiniteFloat(m21) || !IsFiniteFloat(dx) ||
+      !IsFiniteFloat(m12) || !IsFiniteFloat(m22) || !IsFiniteFloat(dy))
     return;
 
   resetTransform();
   transform(m11, m12, m21, m22, dx, dy);
 }
 
 void BaseRenderingContext2D::beginPath() {
   m_path.clear();
 }
 
 static bool validateRectForCanvas(double& x,
                                   double& y,
                                   double& width,
                                   double& height) {
-  if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(width) ||
-      !std::isfinite(height))
+  if (!IsFiniteFloat(x) || !IsFiniteFloat(y) || !IsFiniteFloat(width) ||
+      !IsFiniteFloat(height))
     return false;
 
   if (!width && !height)
     return false;
 
   if (width < 0) {
     width = -width;
     x -= width;
   }
 
@@ skipping 194 matching lines @@
     const double x,
     const double y,
     const String& windingRuleString) {
   SkCanvas* c = drawingCanvas();
   if (!c)
     return false;
   if (!state().isTransformInvertible())
     return false;
 
   FloatPoint point(x, y);
-  if (!std::isfinite(point.x()) || !std::isfinite(point.y()))
+  if (!IsFiniteFloat(point.x()) || !IsFiniteFloat(point.y()))
     return false;
   AffineTransform ctm = state().transform();
   FloatPoint transformedPoint = ctm.inverse().mapPoint(point);
 
   return path.contains(transformedPoint,
                        SkFillTypeToWindRule(parseWinding(windingRuleString)));
 }
 
 bool BaseRenderingContext2D::isPointInStroke(const double x, const double y) {
   return isPointInStrokeInternal(m_path, x, y);
 }
 
 bool BaseRenderingContext2D::isPointInStroke(Path2D* domPath,
                                              const double x,
                                              const double y) {
   return isPointInStrokeInternal(domPath->path(), x, y);
 }
 
 bool BaseRenderingContext2D::isPointInStrokeInternal(const Path& path,
                                                      const double x,
                                                      const double y) {
   SkCanvas* c = drawingCanvas();
   if (!c)
     return false;
   if (!state().isTransformInvertible())
     return false;
 
   FloatPoint point(x, y);
-  if (!std::isfinite(point.x()) || !std::isfinite(point.y()))
+  if (!IsFiniteFloat(point.x()) || !IsFiniteFloat(point.y()))
     return false;
   AffineTransform ctm = state().transform();
   FloatPoint transformedPoint = ctm.inverse().mapPoint(point);
 
   StrokeData strokeData;
   strokeData.setThickness(state().lineWidth());
   strokeData.setLineCap(state().getLineCap());
   strokeData.setLineJoin(state().getLineJoin());
   strokeData.setMiterLimit(state().miterLimit());
   Vector<float> lineDash(state().lineDash().size());
@@ skipping 320 matching lines @@
       exceptionState.throwDOMException(
           InvalidStateError,
           "The HTMLImageElement provided is in the 'broken' state.");
     if (!image || !image->width() || !image->height())
       return;
   } else {
     if (!static_cast<HTMLVideoElement*>(imageSource)->hasAvailableVideoFrame())
       return;
   }
 
-  if (!std::isfinite(dx) || !std::isfinite(dy) || !std::isfinite(dw) ||
-      !std::isfinite(dh) || !std::isfinite(sx) || !std::isfinite(sy) ||
-      !std::isfinite(sw) || !std::isfinite(sh) || !dw || !dh || !sw || !sh)
+  if (!IsFiniteFloat(dx) || !IsFiniteFloat(dy) || !IsFiniteFloat(dw) ||
+      !IsFiniteFloat(dh) || !IsFiniteFloat(sx) || !IsFiniteFloat(sy) ||
+      !IsFiniteFloat(sw) || !IsFiniteFloat(sh) || !dw || !dh || !sw || !sh)
     return;
 
   FloatRect srcRect = normalizeRect(FloatRect(sx, sy, sw, sh));
   FloatRect dstRect = normalizeRect(FloatRect(dx, dy, dw, dh));
   FloatSize imageSize = imageSource->elementSize(defaultObjectSize);
 
   clipRectsToImageRect(FloatRect(FloatPoint(), imageSize), &srcRect, &dstRect);
 
   imageSource->adjustDrawRects(&srcRect, &dstRect);
 
@@ skipping 847 matching lines @@
       ExpensiveCanvasHeuristicParameters::ShadowFixedCost[index] *
           m_usageCounters.numBlurredShadows +
       ExpensiveCanvasHeuristicParameters::
               ShadowVariableCostPerAreaTimesShadowBlurSquared[index] *
           m_usageCounters.boundingBoxAreaTimesShadowBlurSquared;
 
   return basicCostOfDrawCalls + fillTypeAdjustment + shadowAdjustment;
 }
 
 }  // namespace blink