SkRect to gfx::Rect type conversions.

ui/gfx/transform.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/transform.h"
 
 #include "ui/gfx/point3_f.h"
 #include "ui/gfx/rect.h"
+#include "ui/gfx/rect_f.h"
+#include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/safe_integer_conversions.h"
 #include "ui/gfx/skia_util.h"
 
 namespace gfx {
 
 Transform::Transform() {
   matrix_.reset();
 }
 
 Transform::~Transform() {}
@@ skipping 125 matching lines @@
 bool Transform::TransformPointReverse(Point3F& point) const {
   // TODO(sad): Try to avoid trying to invert the matrix.
   SkMatrix44 inverse;
   if (!matrix_.invert(&inverse))
     return false;
 
   TransformPointInternal(inverse, point);
   return true;
 }
 
-void Transform::TransformRect(Rect* rect) const {
-  SkRect src = RectToSkRect(*rect);
+void Transform::TransformRect(RectF* rect) const {
+  SkRect src = RectFToSkRect(*rect);
   const SkMatrix& matrix = matrix_;
   matrix.mapRect(&src);
-  *rect = SkRectToRect(src);
+  *rect = SkRectToRectF(src);
 }
 
-bool Transform::TransformRectReverse(Rect* rect) const {
+void Transform::TransformRect(Rect* rect) const {
+  RectF rect_f = *rect;
+  TransformRect(&rect_f);
+  *rect = gfx::ToEnclosingRect(rect_f);
+}
+
+bool Transform::TransformRectReverse(RectF* rect) const {
   SkMatrix44 inverse;
   if (!matrix_.invert(&inverse))
     return false;
   const SkMatrix& matrix = inverse;
-  SkRect src = RectToSkRect(*rect);
+  SkRect src = RectFToSkRect(*rect);
   matrix.mapRect(&src);
-  *rect = SkRectToRect(src);
+  *rect = SkRectToRectF(src);
   return true;
 }
 
+void Transform::TransformRectReverse(Rect* rect) const {
+  RectF rect_f = *rect;
+  TransformRectReverse(&rect_f);
+  *rect = gfx::ToEnclosingRect(rect_f);
+}
+
 void Transform::TransformPointInternal(const SkMatrix44& xform,
                                        Point3F& point) const {
   SkScalar p[4] = {
     SkFloatToScalar(point.x()),
     SkFloatToScalar(point.y()),
     SkFloatToScalar(point.z()),
     1 };
 
   xform.map(p);
 
   if (p[3] != 1 && abs(p[3]) > 0) {
     point.SetPoint(p[0] / p[3], p[1] / p[3], p[2]/ p[3]);
   } else {
     point.SetPoint(p[0], p[1], p[2]);
   }
 }
 
 void Transform::TransformPointInternal(const SkMatrix44& xform,
                                        Point& point) const {
   SkScalar p[4] = { SkIntToScalar(point.x()),  SkIntToScalar(point.y()),
                     0, 1 };
 
   xform.map(p);
 
   point.SetPoint(ToRoundedInt(p[0]), ToRoundedInt(p[1]));
 }
 
 }  // namespace gfx