Move SaturatedArithmetic from Blink to base

ui/gfx/geometry/rect.h

 // Copyright (c) 2012 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.
 
 // Defines a simple integer rectangle class.  The containment semantics
 // are array-like; that is, the coordinate (x, y) is considered to be
 // contained by the rectangle, but the coordinate (x + width, y) is not.
 // The class will happily let you create malformed rectangles (that is,
 // rectangles with negative width and/or height), but there will be assertions
 // in the operations (such as Contains()) to complain in this case.
@@ skipping 188 matching lines @@
   int ManhattanInternalDistance(const Rect& rect) const;
 
   std::string ToString() const;
 
   bool ApproximatelyEqual(const Rect& rect, int tolerance) const;
 
  private:
   gfx::Point origin_;
   gfx::Size size_;
 
+  // Returns true iff a+b would overflow max int.
+  static constexpr bool AddWouldOverflow(int a, int b) {
+    // In this function, GCC tries to make optimizations that would only work if
+    // max - a wouldn't overflow but it isn't smart enough to notice that a > 0.
+    // So cast everything to unsigned to avoid this.  As it is guaranteed that
+    // max - a and b are both already positive, the cast is a noop.
+    //
+    // This is intended to be: a > 0 && max - a < b
+    return a > 0 && b > 0 &&
+           static_cast<unsigned>(std::numeric_limits<int>::max() - a) <
+               static_cast<unsigned>(b);
+  }
+
   // Clamp the size to avoid integer overflow in bottom() and right().
   // This returns the width given an origin and a width.
+  // TODO(enne): this should probably use base::SaturatedAddition, but that
+  // function is not a constexpr.
   static constexpr int GetClampedValue(int origin, int size) {
     return AddWouldOverflow(origin, size)
                ? std::numeric_limits<int>::max() - origin
                : size;
   }
-
-  // Returns a clamped width given a right and a left, assuming right > left.
-  static constexpr int GetClampedWidthFromExtents(int left, int right) {
-    return SubtractWouldOverflow(right, left) ? std::numeric_limits<int>::max()
-                                              : right - left;
-  }
 };
 
 inline bool operator==(const Rect& lhs, const Rect& rhs) {
   return lhs.origin() == rhs.origin() && lhs.size() == rhs.size();
 }
 
 inline bool operator!=(const Rect& lhs, const Rect& rhs) {
   return !(lhs == rhs);
 }
 
@@ skipping 94 matching lines @@
 }
 
 // This is declared here for use in gtest-based unit tests but is defined in
 // the //ui/gfx:test_support target. Depend on that to use this in your unit
 // test. This should not be used in production code - call ToString() instead.
 void PrintTo(const Rect& rect, ::std::ostream* os);
 
 }  // namespace gfx
 
 #endif  // UI_GFX_GEOMETRY_RECT_H_