Move SaturatedArithmetic from Blink to base

ui/gfx/geometry/rect.cc

 // 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.
 
 #include "ui/gfx/geometry/rect.h"
 
 #include <algorithm>
 
 #if defined(OS_WIN)
 #include <windows.h>
 #elif defined(OS_IOS)
 #include <CoreGraphics/CoreGraphics.h>
 #elif defined(OS_MACOSX)
 #include <ApplicationServices/ApplicationServices.h>
 #endif
 
 #include "base/logging.h"
+#include "base/numerics/saturated_arithmetic.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "ui/gfx/geometry/insets.h"
 
 namespace gfx {
 
 #if defined(OS_WIN)
 Rect::Rect(const RECT& r)
     : origin_(r.left, r.top),
       size_(std::abs(r.right - r.left), std::abs(r.bottom - r.top)) {
@@ skipping 32 matching lines @@
 namespace gfx {
 
 void Rect::Inset(const Insets& insets) {
   Inset(insets.left(), insets.top(), insets.right(), insets.bottom());
 }
 
 void Rect::Inset(int left, int top, int right, int bottom) {
   origin_ += Vector2d(left, top);
   // left+right might overflow/underflow, but width() - (left+right) might
   // overflow as well.
-  set_width(SafeSubtract(width(), SafeAdd(left, right)));
-  set_height(SafeSubtract(height(), SafeAdd(top, bottom)));
+  set_width(base::SaturatedSubtraction(width(),
+                                       base::SaturatedAddition(left, right)));
+  set_height(base::SaturatedSubtraction(height(),
+                                        base::SaturatedAddition(top, bottom)));
 }
 
 void Rect::Offset(int horizontal, int vertical) {
   origin_ += Vector2d(horizontal, vertical);
   // Ensure that width and height remain valid.
   set_width(width());
   set_height(height());
 }
 
 void Rect::operator+=(const Vector2d& offset) {
@@ skipping 65 matching lines @@
   }
   if (rect.IsEmpty())
     return;
 
   int rx = std::min(x(), rect.x());
   int ry = std::min(y(), rect.y());
   int rr = std::max(right(), rect.right());
   int rb = std::max(bottom(), rect.bottom());
 
   // Subtracting to get width/height might overflow integers, so clamp them.
-  SetRect(rx, ry, GetClampedWidthFromExtents(rx, rr),
-          GetClampedWidthFromExtents(ry, rb));
+  SetRect(rx, ry, base::SaturatedSubtraction(rr, rx),
+          base::SaturatedSubtraction(rb, ry));
 }
 
 void Rect::Subtract(const Rect& rect) {
   if (!Intersects(rect))
     return;
   if (rect.Contains(*this)) {
     SetRect(0, 0, 0, 0);
     return;
   }
 
@@ skipping 121 matching lines @@
 
 Rect BoundingRect(const Point& p1, const Point& p2) {
   int rx = std::min(p1.x(), p2.x());
   int ry = std::min(p1.y(), p2.y());
   int rr = std::max(p1.x(), p2.x());
   int rb = std::max(p1.y(), p2.y());
   return Rect(rx, ry, rr - rx, rb - ry);
 }
 
 }  // namespace gfx