Change LayoutUnit to use saturated_cast

third_party/WebKit/Source/platform/LayoutUnit.h

 /*
  * Copyright (c) 2012, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef LayoutUnit_h
 #define LayoutUnit_h
 
+#include "base/numerics/safe_conversions.h"
 #include "platform/PlatformExport.h"
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
-#include "wtf/MathExtras.h"
 #include "wtf/SaturatedArithmetic.h"
 #include "wtf/text/WTFString.h"
 #include <algorithm>
 #include <limits.h>
 #include <limits>
+#include <math.h>
 #include <stdlib.h>
 
 namespace blink {
 
 #if DCHECK_IS_ON()
 #define REPORT_OVERFLOW(doesOverflow)                                          \
   DLOG_IF(ERROR, !(doesOverflow)) << "LayoutUnit overflow !(" << #doesOverflow \
                                   << ") in " << WTF_PRETTY_FUNCTION
 #else
 #define REPORT_OVERFLOW(doesOverflow) ((void)0)
@@ skipping 11 matching lines @@
 
 class LayoutUnit {
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 
  public:
   LayoutUnit() : m_value(0) {}
   explicit LayoutUnit(int value) { setValue(value); }
   explicit LayoutUnit(unsigned short value) { setValue(value); }
   explicit LayoutUnit(unsigned value) { setValue(value); }
   explicit LayoutUnit(unsigned long value) {
-    m_value = clampTo<int>(value * kFixedPointDenominator);
+    m_value = base::saturated_cast<int>(value * kFixedPointDenominator);
   }
   explicit LayoutUnit(unsigned long long value) {
-    m_value = clampTo<int>(value * kFixedPointDenominator);
+    m_value = base::saturated_cast<int>(value * kFixedPointDenominator);
   }
   explicit LayoutUnit(float value) {
-    m_value = clampTo<int>(value * kFixedPointDenominator);
+    m_value = base::saturated_cast<int>(value * kFixedPointDenominator);
   }
   explicit LayoutUnit(double value) {
-    m_value = clampTo<int>(value * kFixedPointDenominator);
+    m_value = base::saturated_cast<int>(value * kFixedPointDenominator);
   }
 
   static LayoutUnit fromFloatCeil(float value) {
     LayoutUnit v;
-    v.m_value = clampTo<int>(ceilf(value * kFixedPointDenominator));
+    v.m_value =
+        base::saturated_cast<int>(ceilf(value * kFixedPointDenominator));
     return v;
   }
 
   static LayoutUnit fromFloatFloor(float value) {
     LayoutUnit v;
-    v.m_value = clampTo<int>(floorf(value * kFixedPointDenominator));
+    v.m_value =
+        base::saturated_cast<int>(floorf(value * kFixedPointDenominator));
     return v;
   }
 
   static LayoutUnit fromFloatRound(float value) {
-    if (value >= 0)
-      return clamp(value + epsilon() / 2.0f);
-    return clamp(value - epsilon() / 2.0f);
+    LayoutUnit v;
+    v.m_value =
+        base::saturated_cast<int>(roundf(value * kFixedPointDenominator));
+    return v;
   }
 
   int toInt() const { return m_value / kFixedPointDenominator; }
   float toFloat() const {
     return static_cast<float>(m_value) / kFixedPointDenominator;
   }
   double toDouble() const {
     return static_cast<double>(m_value) / kFixedPointDenominator;
   }
   unsigned toUnsigned() const {
@@ skipping 91 matching lines @@
     LayoutUnit m;
     m.m_value = std::numeric_limits<int>::max() - kFixedPointDenominator / 2;
     return m;
   }
   static const LayoutUnit nearlyMin() {
     LayoutUnit m;
     m.m_value = std::numeric_limits<int>::min() + kFixedPointDenominator / 2;
     return m;
   }
 
-  static LayoutUnit clamp(double value) {
-    return clampTo<LayoutUnit>(value, LayoutUnit::min(), LayoutUnit::max());
-  }
+  static LayoutUnit clamp(double value) { return fromFloatFloor(value); }
 
   String toString() const;
 
  private:
   static bool isInBounds(int value) {
     return ::abs(value) <=
            std::numeric_limits<int>::max() / kFixedPointDenominator;
   }
   static bool isInBounds(unsigned value) {
     return value <= static_cast<unsigned>(std::numeric_limits<int>::max()) /
@@ skipping 220 matching lines @@
 }
 
 inline double operator*(const double a, const LayoutUnit& b) {
   return a * b.toDouble();
 }
 
 inline LayoutUnit operator/(const LayoutUnit& a, const LayoutUnit& b) {
   LayoutUnit returnVal;
   long long rawVal = static_cast<long long>(kFixedPointDenominator) *
                      a.rawValue() / b.rawValue();
-  returnVal.setRawValue(clampTo<int>(rawVal));
+  returnVal.setRawValue(base::saturated_cast<int>(rawVal));
   return returnVal;
 }
 
 inline float operator/(const LayoutUnit& a, float b) {
   return a.toFloat() / b;
 }
 
 inline double operator/(const LayoutUnit& a, double b) {
   return a.toDouble() / b;
 }
@@ skipping 232 matching lines @@
 }
 
 inline LayoutUnit layoutMod(const LayoutUnit& numerator, int denominator) {
   return numerator % LayoutUnit(denominator);
 }
 
 inline bool isIntegerValue(const LayoutUnit value) {
   return value.toInt() == value;
 }
 
-inline LayoutUnit clampToLayoutUnit(LayoutUnit value,
-                                    LayoutUnit min,
-                                    LayoutUnit max) {
-  if (value >= max)
-    return max;
-  if (value <= min)
-    return min;
-  return value;
-}
-
 inline std::ostream& operator<<(std::ostream& stream, const LayoutUnit& value) {
   return stream << value.toString();
 }
 
 }  // namespace blink
 
 #endif  // LayoutUnit_h