Move SaturatedArithmetic from Blink to base

ui/gfx/geometry/point.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.
 
 #ifndef UI_GFX_GEOMETRY_POINT_H_
 #define UI_GFX_GEOMETRY_POINT_H_
 
 #include <iosfwd>
 #include <string>
 #include <tuple>
 
+#include "base/numerics/saturated_arithmetic.h"
 #include "build/build_config.h"
-#include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/gfx_export.h"
 
 #if defined(OS_WIN)
 typedef unsigned long DWORD;
 typedef struct tagPOINT POINT;
 #elif defined(OS_MACOSX)
 typedef struct CGPoint CGPoint;
 #endif
 
@@ skipping 25 matching lines @@
   constexpr int y() const { return y_; }
   void set_x(int x) { x_ = x; }
   void set_y(int y) { y_ = y; }
 
   void SetPoint(int x, int y) {
     x_ = x;
     y_ = y;
   }
 
   void Offset(int delta_x, int delta_y) {
-    x_ = SafeAdd(x_, delta_x);
-    y_ = SafeAdd(y_, delta_y);
+    x_ = base::SaturatedAddition(x_, delta_x);
+    y_ = base::SaturatedAddition(y_, delta_y);
   }
 
   void operator+=(const Vector2d& vector) {
-    x_ = SafeAdd(x_, vector.x());
-    y_ = SafeAdd(y_, vector.y());
+    x_ = base::SaturatedAddition(x_, vector.x());
+    y_ = base::SaturatedAddition(y_, vector.y());
   }
 
   void operator-=(const Vector2d& vector) {
-    x_ = SafeSubtract(x_, vector.x());
-    y_ = SafeSubtract(y_, vector.y());
+    x_ = base::SaturatedSubtraction(x_, vector.x());
+    y_ = base::SaturatedSubtraction(y_, vector.y());
   }
 
   void SetToMin(const Point& other);
   void SetToMax(const Point& other);
 
   bool IsOrigin() const { return x_ == 0 && y_ == 0; }
 
   Vector2d OffsetFromOrigin() const { return Vector2d(x_, y_); }
 
   // A point is less than another point if its y-value is closer
@@ skipping 28 matching lines @@
   return result;
 }
 
 inline Point operator-(const Point& lhs, const Vector2d& rhs) {
   Point result(lhs);
   result -= rhs;
   return result;
 }
 
 inline Vector2d operator-(const Point& lhs, const Point& rhs) {
-  return Vector2d(SafeSubtract(lhs.x(), rhs.x()),
-                  SafeSubtract(lhs.y(), rhs.y()));
+  return Vector2d(base::SaturatedSubtraction(lhs.x(), rhs.x()),
+                  base::SaturatedSubtraction(lhs.y(), rhs.y()));
 }
 
 inline Point PointAtOffsetFromOrigin(const Vector2d& offset_from_origin) {
   return Point(offset_from_origin.x(), offset_from_origin.y());
 }
 
 // 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 Point& point, ::std::ostream* os);
 
 // Helper methods to scale a gfx::Point to a new gfx::Point.
 GFX_EXPORT Point ScaleToCeiledPoint(const Point& point,
                                     float x_scale,
                                     float y_scale);
 GFX_EXPORT Point ScaleToCeiledPoint(const Point& point, float x_scale);
 GFX_EXPORT Point ScaleToFlooredPoint(const Point& point,
                                      float x_scale,
                                      float y_scale);
 GFX_EXPORT Point ScaleToFlooredPoint(const Point& point, float x_scale);
 GFX_EXPORT Point ScaleToRoundedPoint(const Point& point,
                                      float x_scale,
                                      float y_scale);
 GFX_EXPORT Point ScaleToRoundedPoint(const Point& point, float x_scale);
 
 }  // namespace gfx
 
 #endif  // UI_GFX_GEOMETRY_POINT_H_