Replace gfx::ClampToInt with base::saturated_cast.

ui/gfx/transform_unittest.cc

 // Copyright (c) 2011 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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "ui/gfx/transform.h"
 
 #include <cmath>
@@ skipping 430 matching lines @@
     int x1;
     int y1;
     float tx;
     float ty;
     int x2;
     int y2;
   } test_cases[] = {
     { 0, 0, 10.0f, 20.0f, 10, 20},
     { 0, 0, -10.0f, -20.0f, 0, 0},
     { 0, 0, -10.0f, -20.0f, -10, -20},
-    { 0, 0,
-      std::numeric_limits<float>::quiet_NaN(),
-      std::numeric_limits<float>::quiet_NaN(),
-      10, 20},
   };
 
   Transform xform;
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     const TestCase& value = test_cases[i];
     Transform translation;
     translation.Translate(value.tx, value.ty);
     xform = translation * xform;
     Point p1(value.x1, value.y1);
     Point p2(value.x2, value.y2);
     xform.TransformPoint(&p1);
     if (value.tx == value.tx &&
         value.ty == value.ty) {
       EXPECT_EQ(p1.x(), p2.x());
       EXPECT_EQ(p1.y(), p2.y());
     }
   }
 }
 
 TEST(XFormTest, ConcatScale2D) {
   static const struct TestCase {
     int before;
     float scale;
     int after;
   } test_cases[] = {
     { 1, 10.0f, 10},
     { 1, .1f, 1},
     { 1, 100.0f, 100},
     { 1, -1.0f, -100},
-    { 1, std::numeric_limits<float>::quiet_NaN(), 1}
   };
 
   Transform xform;
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     const TestCase& value = test_cases[i];
     Transform scale;
     scale.Scale(value.scale, value.scale);
     xform = scale * xform;
     Point p1(value.before, value.before);
     Point p2(value.after, value.after);
@@ skipping 11 matching lines @@
     int y1;
     float degrees;
     int x2;
     int y2;
   } test_cases[] = {
     { 1, 0, 90.0f, 0, 1},
     { 1, 0, -90.0f, 1, 0},
     { 1, 0, 90.0f, 0, 1},
     { 1, 0, 360.0f, 0, 1},
     { 1, 0, 0.0f, 0, 1},
-    { 1, 0, std::numeric_limits<float>::quiet_NaN(), 1, 0}
   };
 
   Transform xform;
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     const TestCase& value = test_cases[i];
     Transform rotation;
     rotation.Rotate(value.degrees);
     xform = rotation * xform;
     Point p1(value.x1, value.y1);
     Point p2(value.x2, value.y2);
     xform.TransformPoint(&p1);
     if (value.degrees == value.degrees) {
       EXPECT_EQ(p1.x(), p2.x());
       EXPECT_EQ(p1.y(), p2.y());
     }
   }
 }
 
 TEST(XFormTest, SetTranslate2D) {
   static const struct TestCase {
     int x1; int y1;
     float tx; float ty;
     int x2; int y2;
   } test_cases[] = {
     { 0, 0, 10.0f, 20.0f, 10, 20},
     { 10, 20, 10.0f, 20.0f, 20, 40},
     { 10, 20, 0.0f, 0.0f, 10, 20},
-    { 0, 0,
-      std::numeric_limits<float>::quiet_NaN(),
-      std::numeric_limits<float>::quiet_NaN(),
-      0, 0}
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     const TestCase& value = test_cases[i];
     for (int j = -1; j < 2; ++j) {
       for (int k = 0; k < 3; ++k) {
         float epsilon = 0.0001f;
         Point p0, p1, p2;
         Transform xform;
         switch (k) {
@@ skipping 32 matching lines @@
 TEST(XFormTest, SetScale2D) {
   static const struct TestCase {
     int before;
     float s;
     int after;
   } test_cases[] = {
     { 1, 10.0f, 10},
     { 1, 1.0f, 1},
     { 1, 0.0f, 0},
     { 0, 10.0f, 0},
-    { 1, std::numeric_limits<float>::quiet_NaN(), 0},
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     const TestCase& value = test_cases[i];
     for (int j = -1; j < 2; ++j) {
       for (int k = 0; k < 3; ++k) {
         float epsilon = 0.0001f;
         Point p0, p1, p2;
         Transform xform;
         switch (k) {
@@ skipping 2093 matching lines @@
   // Rounding should only affect 2d translation components.
   translation.Translate3d(0.f, 0.f, 0.5f);
   expected.Translate3d(0.f, 0.f, 0.5f);
   translation.RoundTranslationComponents();
   EXPECT_EQ(expected.ToString(), translation.ToString());
 }
 
 }  // namespace
 
 }  // namespace gfx