Fixes rounding bug in transform. This is needed to avoid rounding

ui/gfx/transform.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.
 
 #include "ui/gfx/transform.h"
 
+#include <cmath>
+
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/skia_util.h"
 
 namespace ui {
 
 Transform::Transform() {
   matrix_.reset();
 }
 
@@ skipping 47 matching lines @@
   return matrix_.setConcat(transform.matrix_, matrix_);
 }
 
 bool Transform::HasChange() const {
   return !matrix_.isIdentity();
 }
 
 bool Transform::TransformPoint(gfx::Point* point) {
   SkPoint skp;
   matrix_.mapXY(SkIntToScalar(point->x()), SkIntToScalar(point->y()), &skp);
-  point->SetPoint(static_cast<int>(skp.fX), static_cast<int>(skp.fY));
+  point->SetPoint(static_cast<int>(std::floor(skp.fX)),
+                  static_cast<int>(std::floor(skp.fY)));

[wjmaclean, 2011/05/24 12:11:40]

Just curious ... for positive values, wouldn't this run the danger of converting
0.998 to 0 instead of 1? Do we want rounding or floor/ceil here?

The comment in the unit test mentions only negative numbers, so perhaps I'm
missing how this is used.

[sky, 2011/05/24 15:51:49]

I'm sure we'll have rounding problems until we use doubles every where.

The current code uses static cast, which rounds .998 to 0 too, so that behavior
isn't any different. What is different is that negative numbers are now rounded
down, not up (as static_cast does). Here's an example to show the problems with
the current code. Lets say the root view has one child view at 50,50 with a
scale 5. Because the current code rounds down, anything in the range 46-49 of
the parent gets mapped to 0x0 in the child. This means that any mouse movements
from 46-49 get forwarded to the child even though it doesn't contain the point.
By rounding down instead of up for negative numbers we ensure 46-49 are treated
as -1 and don't get forwarded to the child. Does that makes sense?

   return true;
 }
 
 bool Transform::TransformPointReverse(gfx::Point* point) {
   SkMatrix inverse;
   // TODO(sad): Try to avoid trying to invert the matrix.
   if (matrix_.invert(&inverse)) {
     SkPoint skp;
     inverse.mapXY(SkIntToScalar(point->x()), SkIntToScalar(point->y()), &skp);
-    point->SetPoint(static_cast<int>(skp.fX), static_cast<int>(skp.fY));
+    point->SetPoint(static_cast<int>(std::floor(skp.fX)),
+                    static_cast<int>(std::floor(skp.fY)));
     return true;
   }
   return false;
 }
 
 bool Transform::TransformRect(gfx::Rect* rect) {
   SkRect src = gfx::RectToSkRect(*rect);
   if (!matrix_.mapRect(&src))
     return false;
   gfx::Rect xrect = gfx::SkRectToRect(src);
   rect->SetRect(xrect.x(), xrect.y(), xrect.width(), xrect.height());
   return true;
 }
 
 }  // namespace ui