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>
 #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/safe_integer_conversions.h"
 
 namespace gfx {
 
 // static
 double Tween::CalculateValue(Tween::Type type, double state) {
   DCHECK_GE(state, 0);
   DCHECK_LE(state, 1);
 
@@ skipping 37 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 base::saturated_cast<uint8>(ToRoundedInt(f * 255.f));
 }
 
 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 ToRoundedInt(DoubleValueBetween(value, start, target));

[Peter Kasting, 2014/10/21 00:53:56]

Note: This causes test failures in TweenTest.LinearIntValueBetweenNegative
because the rounding behavior is changed in my patch from "round toward positive
infinity" to "round away from 0".  "Round away from 0" matches e.g. std::round()
and seems more intuitive to me, so I'm inclined to change the test expectations,
but let me know what you think should be done.

[danakj, 2014/10/23 15:20:42]

We should have ajuma decide the right thing here, it may be speced.

[ajuma, 2014/10/23 15:44:39]

Rounding towards positive infinity is indeed part of the CSS transitions spec.
See http://www.w3.org/TR/css3-transitions/#animatable-types

[Peter Kasting, 2014/10/23 17:29:45]

This isn't used for CSS transitions, though.  This is only used in Chrome UI
animations.  How does the CSS spec relate?

(Also, if we have a ToRoundedInt() in ui/gfx/ at all, and it rounds away from
zero, aren't we already risking other people rounding in this way?  Are you guys
proposing changing how that method is implemented?)

[ajuma, 2014/10/23 17:37:11]

It's used by cc::FilterOperation when animating CSS filters.

[Peter Kasting, 2014/10/23 17:39:52]

I see...

I'll change this; in the future it would be awesome if we could add comments
documenting subtle things like how this piece of ui/ is actually used for web
content, and that there's a spec that controls its behavior.  (I'll add such a
comment here.)

[ajuma, 2014/10/23 17:42:14]

FWIW, the .h file has such a comment :)  But it's true that having a comment
beside the implementation would help to avoid future confusion.

[danakj, 2014/10/23 17:43:23]

I'm not proposing that. ToRoundedInt should work like round(). But in this case
round() is not the right behaviour due to spec.

 }
 
 // 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