Switch to standard integer types in ui/gfx/.

ui/gfx/animation/tween.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/animation/tween.h"
 
 #include <math.h>
+#include <stdint.h>
+
+#include <algorithm>
+
+#include "base/logging.h"
+#include "base/numerics/safe_conversions.h"
+#include "build/build_config.h"
+#include "ui/gfx/geometry/cubic_bezier.h"
+#include "ui/gfx/geometry/safe_integer_conversions.h"
 
 #if defined(OS_WIN)
 #include <float.h>
 #endif
 
-#include <algorithm>
-
-#include "base/basictypes.h"
-#include "base/logging.h"
-#include "base/numerics/safe_conversions.h"
-#include "ui/gfx/geometry/cubic_bezier.h"
-#include "ui/gfx/geometry/safe_integer_conversions.h"
-
 namespace gfx {
 
 // static
 double Tween::CalculateValue(Tween::Type type, double state) {
   DCHECK_GE(state, 0);
   DCHECK_LE(state, 1);
 
   switch (type) {
     case EASE_IN:
       return pow(state, 2);
@@ skipping 33 matching lines @@
 
     case ZERO:
       return 0;
   }
 
   NOTREACHED();
   return state;
 }
 
 namespace {
-uint8 FloatToColorByte(float f) {
-  return base::saturated_cast<uint8>(ToRoundedInt(f * 255.f));
+uint8_t FloatToColorByte(float f) {
+  return base::saturated_cast<uint8_t>(ToRoundedInt(f * 255.f));
 }
 
-uint8 BlendColorComponents(uint8 start,
-                           uint8 target,
-                           float start_alpha,
-                           float target_alpha,
-                           float blended_alpha,
-                           double progress) {
+uint8_t BlendColorComponents(uint8_t start,
+                             uint8_t target,
+                             float start_alpha,
+                             float target_alpha,
+                             float blended_alpha,
+                             double progress) {
   // Since progress can be outside [0, 1], blending can produce a value outside
   // [0, 255].
   float blended_premultiplied = Tween::FloatValueBetween(
       progress, start / 255.f * start_alpha, target / 255.f * target_alpha);
   return FloatToColorByte(blended_premultiplied / blended_alpha);
 }
 
 }  // namespace
 
 // static
 SkColor Tween::ColorValueBetween(double value, SkColor start, SkColor target) {
   float start_a = SkColorGetA(start) / 255.f;
   float target_a = SkColorGetA(target) / 255.f;
   float blended_a = FloatValueBetween(value, start_a, target_a);
   if (blended_a <= 0.f)
     return SkColorSetARGB(0, 0, 0, 0);
   blended_a = std::min(blended_a, 1.f);
 
-  uint8 blended_r = BlendColorComponents(SkColorGetR(start),
-                                         SkColorGetR(target),
-                                         start_a,
-                                         target_a,
-                                         blended_a,
-                                         value);
-  uint8 blended_g = BlendColorComponents(SkColorGetG(start),
-                                         SkColorGetG(target),
-                                         start_a,
-                                         target_a,
-                                         blended_a,
-                                         value);
-  uint8 blended_b = BlendColorComponents(SkColorGetB(start),
-                                         SkColorGetB(target),
-                                         start_a,
-                                         target_a,
-                                         blended_a,
-                                         value);
+  uint8_t blended_r =
+      BlendColorComponents(SkColorGetR(start), SkColorGetR(target), start_a,
+                           target_a, blended_a, value);
+  uint8_t blended_g =
+      BlendColorComponents(SkColorGetG(start), SkColorGetG(target), start_a,
+                           target_a, blended_a, value);
+  uint8_t blended_b =
+      BlendColorComponents(SkColorGetB(start), SkColorGetB(target), start_a,
+                           target_a, blended_a, value);
 
   return SkColorSetARGB(
       FloatToColorByte(blended_a), blended_r, blended_g, blended_b);
 }
 
 // static
 double Tween::DoubleValueBetween(double value, double start, double target) {
   return start + (target - start) * value;
 }
 
@@ skipping 46 matching lines @@
   if (value <= 0.0)
     return start_transform;
 
   gfx::Transform to_return = end_transform;
   to_return.Blend(start_transform, value);
 
   return to_return;
 }
 
 }  // namespace gfx