Move SaturatedArithmetic from Blink to base

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/saturated_arithmetic.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 <stdlib.h>
 
 namespace blink {
 
 #if DCHECK_IS_ON()
 #define REPORT_OVERFLOW(doesOverflow)                                          \
@@ skipping 103 matching lines @@
   }
   int ceil() const {
     if (UNLIKELY(m_value >= INT_MAX - kFixedPointDenominator + 1))
       return intMaxForLayoutUnit;
 
     if (m_value >= 0)
       return (m_value + kFixedPointDenominator - 1) / kFixedPointDenominator;
     return toInt();
   }
   ALWAYS_INLINE int round() const {
-    return saturatedAddition(rawValue(), kFixedPointDenominator / 2) >>
+    return base::SaturatedAddition(rawValue(), kFixedPointDenominator / 2) >>
            kLayoutUnitFractionalBits;
   }
 
   int floor() const {
     if (UNLIKELY(m_value <= INT_MIN + kFixedPointDenominator - 1))
       return intMinForLayoutUnit;
 
     return m_value >> kLayoutUnitFractionalBits;
   }
 
@@ skipping 59 matching lines @@
   static bool isInBounds(unsigned value) {
     return value <= static_cast<unsigned>(std::numeric_limits<int>::max()) /
                         kFixedPointDenominator;
   }
   static bool isInBounds(double value) {
     return ::fabs(value) <=
            std::numeric_limits<int>::max() / kFixedPointDenominator;
   }
 
   ALWAYS_INLINE void setValue(int value) {
-    m_value = saturatedSet<kLayoutUnitFractionalBits>(value);
+    m_value = base::SaturatedSet<kLayoutUnitFractionalBits>(value);
   }
 
   inline void setValue(unsigned value) {
-    m_value = saturatedSet<kLayoutUnitFractionalBits>(value);
+    m_value = base::SaturatedSet<kLayoutUnitFractionalBits>(value);
   }
 
   int m_value;
 };
 
 inline bool operator<=(const LayoutUnit& a, const LayoutUnit& b) {
   return a.rawValue() <= b.rawValue();
 }
 
 inline bool operator<=(const LayoutUnit& a, float b) {
@@ skipping 259 matching lines @@
 inline LayoutUnit operator/(unsigned long a, const LayoutUnit& b) {
   return LayoutUnit(a) / b;
 }
 
 inline LayoutUnit operator/(unsigned long long a, const LayoutUnit& b) {
   return LayoutUnit(a) / b;
 }
 
 ALWAYS_INLINE LayoutUnit operator+(const LayoutUnit& a, const LayoutUnit& b) {
   LayoutUnit returnVal;
-  returnVal.setRawValue(saturatedAddition(a.rawValue(), b.rawValue()));
+  returnVal.setRawValue(base::SaturatedAddition(a.rawValue(), b.rawValue()));
   return returnVal;
 }
 
 inline LayoutUnit operator+(const LayoutUnit& a, int b) {
   return a + LayoutUnit(b);
 }
 
 inline float operator+(const LayoutUnit& a, float b) {
   return a.toFloat() + b;
 }
 
 inline double operator+(const LayoutUnit& a, double b) {
   return a.toDouble() + b;
 }
 
 inline LayoutUnit operator+(const int a, const LayoutUnit& b) {
   return LayoutUnit(a) + b;
 }
 
 inline float operator+(const float a, const LayoutUnit& b) {
   return a + b.toFloat();
 }
 
 inline double operator+(const double a, const LayoutUnit& b) {
   return a + b.toDouble();
 }
 
 ALWAYS_INLINE LayoutUnit operator-(const LayoutUnit& a, const LayoutUnit& b) {
   LayoutUnit returnVal;
-  returnVal.setRawValue(saturatedSubtraction(a.rawValue(), b.rawValue()));
+  returnVal.setRawValue(base::SaturatedSubtraction(a.rawValue(), b.rawValue()));
   return returnVal;
 }
 
 inline LayoutUnit operator-(const LayoutUnit& a, int b) {
   return a - LayoutUnit(b);
 }
 
 inline LayoutUnit operator-(const LayoutUnit& a, unsigned b) {
   return a - LayoutUnit(b);
 }
 
 inline float operator-(const LayoutUnit& a, float b) {
   return a.toFloat() - b;
 }
 
 inline double operator-(const LayoutUnit& a, double b) {
   return a.toDouble() - b;
 }
 
 inline LayoutUnit operator-(const int a, const LayoutUnit& b) {
   return LayoutUnit(a) - b;
 }
 
 inline float operator-(const float a, const LayoutUnit& b) {
   return a - b.toFloat();
 }
 
 inline LayoutUnit operator-(const LayoutUnit& a) {
   LayoutUnit returnVal;
-  returnVal.setRawValue(saturatedNegative(a.rawValue()));
+  returnVal.setRawValue(base::SaturatedNegative(a.rawValue()));
   return returnVal;
 }
 
 // For returning the remainder after a division with integer results.
 inline LayoutUnit intMod(const LayoutUnit& a, const LayoutUnit& b) {
   // This calculates the modulo so that: a = static_cast<int>(a / b) * b +
   // intMod(a, b).
   LayoutUnit returnVal;
   returnVal.setRawValue(a.rawValue() % b.rawValue());
   return returnVal;
@@ skipping 11 matching lines @@
 
 inline LayoutUnit operator%(const LayoutUnit& a, int b) {
   return a % LayoutUnit(b);
 }
 
 inline LayoutUnit operator%(int a, const LayoutUnit& b) {
   return LayoutUnit(a) % b;
 }
 
 inline LayoutUnit& operator+=(LayoutUnit& a, const LayoutUnit& b) {
-  a.setRawValue(saturatedAddition(a.rawValue(), b.rawValue()));
+  a.setRawValue(base::SaturatedAddition(a.rawValue(), b.rawValue()));
   return a;
 }
 
 inline LayoutUnit& operator+=(LayoutUnit& a, int b) {
   a = a + LayoutUnit(b);
   return a;
 }
 
 inline LayoutUnit& operator+=(LayoutUnit& a, float b) {
   a = LayoutUnit(a + b);
   return a;
 }
 
 inline float& operator+=(float& a, const LayoutUnit& b) {
   a = a + b;
   return a;
 }
 
 inline LayoutUnit& operator-=(LayoutUnit& a, int b) {
   a = a - LayoutUnit(b);
   return a;
 }
 
 inline LayoutUnit& operator-=(LayoutUnit& a, const LayoutUnit& b) {
-  a.setRawValue(saturatedSubtraction(a.rawValue(), b.rawValue()));
+  a.setRawValue(base::SaturatedSubtraction(a.rawValue(), b.rawValue()));
   return a;
 }
 
 inline LayoutUnit& operator-=(LayoutUnit& a, float b) {
   a = LayoutUnit(a - b);
   return a;
 }
 
 inline float& operator-=(float& a, const LayoutUnit& b) {
   a = a - b;
@@ skipping 70 matching lines @@
   return value;
 }
 
 inline std::ostream& operator<<(std::ostream& stream, const LayoutUnit& value) {
   return stream << value.toString();
 }
 
 }  // namespace blink
 
 #endif  // LayoutUnit_h