Type conversion fixes, ui/gfx/ edition.

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>
 
 #if defined(OS_WIN)
 #include <float.h>
@@ skipping 53 matching lines @@
     case ZERO:
       return 0;
   }
 
   NOTREACHED();
   return state;
 }
 
 namespace {
 uint8 FloatToColorByte(float f) {
-  return std::min(std::max(ToRoundedInt(f * 255.f), 0), 255);
+  return static_cast<uint8>(
+      std::min(std::max(ToRoundedInt(f * 255.f), 0), 255));
 }
 
 uint8 BlendColorComponents(uint8 start,
                            uint8 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].
@@ skipping 57 matching lines @@
     delta++;
 #if defined(OS_WIN)
   return start + static_cast<int>(value * _nextafter(delta, 0));
 #else
   return start + static_cast<int>(value * nextafter(delta, 0));
 #endif
 }
 
 //static
 int Tween::LinearIntValueBetween(double value, int start, int target) {
-  return std::floor(0.5 + DoubleValueBetween(value, start, target));
+  return static_cast<int>(

[danakj, 2014/10/18 18:40:06]

Can you ToFlooredInt here instead of cast+std::floor?

[Peter Kasting, 2014/10/20 23:38:56]

I can do even better and use ToRoundedInt() to eliminate the 0.5+ as well.

+      std::floor(0.5 + DoubleValueBetween(value, start, target)));
 }
 
 // static
 gfx::Rect Tween::RectValueBetween(double value,
                                   const gfx::Rect& start_bounds,
                                   const gfx::Rect& target_bounds) {
   return gfx::Rect(
       LinearIntValueBetween(value, start_bounds.x(), target_bounds.x()),
       LinearIntValueBetween(value, start_bounds.y(), target_bounds.y()),
       LinearIntValueBetween(value, start_bounds.width(), target_bounds.width()),
@@ skipping 11 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