cc: Stop converting Rect to QuadF to map to an enclosed rect.

cc/base/math_util.cc

 // Copyright 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 "cc/base/math_util.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
@@ skipping 103 matching lines @@
 static inline void AddVertexToClippedQuad3d(const gfx::Point3F& new_vertex,
                                             gfx::Point3F clipped_quad[8],
                                             int* num_vertices_in_clipped_quad) {
   clipped_quad[*num_vertices_in_clipped_quad] = new_vertex;
   (*num_vertices_in_clipped_quad)++;
 }
 
 gfx::Rect MathUtil::MapEnclosingClippedRect(const gfx::Transform& transform,
                                             const gfx::Rect& src_rect) {
   if (transform.IsIdentityOrIntegerTranslation()) {
-    return src_rect +
-           gfx::Vector2d(
-               static_cast<int>(SkMScalarToFloat(transform.matrix().get(0, 3))),
-               static_cast<int>(
-                   SkMScalarToFloat(transform.matrix().get(1, 3))));
+    gfx::Vector2d offset(static_cast<int>(transform.matrix().getFloat(0, 3)),
+                         static_cast<int>(transform.matrix().getFloat(1, 3)));
+    return src_rect + offset;
   }
   return gfx::ToEnclosingRect(MapClippedRect(transform, gfx::RectF(src_rect)));
 }
 
 gfx::RectF MathUtil::MapClippedRect(const gfx::Transform& transform,
                                     const gfx::RectF& src_rect) {
   if (transform.IsIdentityOrTranslation()) {
-    return src_rect +
-           gfx::Vector2dF(SkMScalarToFloat(transform.matrix().get(0, 3)),
-                          SkMScalarToFloat(transform.matrix().get(1, 3)));
+    gfx::Vector2dF offset(transform.matrix().getFloat(0, 3),
+                          transform.matrix().getFloat(1, 3));
+    return src_rect + offset;
   }
 
   // Apply the transform, but retain the result in homogeneous coordinates.
 
   SkMScalar quad[4 * 2];  // input: 4 x 2D points
   quad[0] = src_rect.x();
   quad[1] = src_rect.y();
   quad[2] = src_rect.right();
   quad[3] = src_rect.y();
   quad[4] = src_rect.right();
   quad[5] = src_rect.bottom();
   quad[6] = src_rect.x();
   quad[7] = src_rect.bottom();
 
   SkMScalar result[4 * 4];  // output: 4 x 4D homogeneous points
   transform.matrix().map2(quad, 4, result);
 
   HomogeneousCoordinate hc0(result[0], result[1], result[2], result[3]);
   HomogeneousCoordinate hc1(result[4], result[5], result[6], result[7]);
   HomogeneousCoordinate hc2(result[8], result[9], result[10], result[11]);
   HomogeneousCoordinate hc3(result[12], result[13], result[14], result[15]);
   return ComputeEnclosingClippedRect(hc0, hc1, hc2, hc3);
 }
 
 gfx::Rect MathUtil::ProjectEnclosingClippedRect(const gfx::Transform& transform,
                                                 const gfx::Rect& src_rect) {
   if (transform.IsIdentityOrIntegerTranslation()) {
-    return src_rect +
-           gfx::Vector2d(
-               static_cast<int>(SkMScalarToFloat(transform.matrix().get(0, 3))),
-               static_cast<int>(
-                   SkMScalarToFloat(transform.matrix().get(1, 3))));
+    gfx::Vector2d offset(static_cast<int>(transform.matrix().getFloat(0, 3)),
+                         static_cast<int>(transform.matrix().getFloat(1, 3)));
+    return src_rect + offset;
   }
   return gfx::ToEnclosingRect(
       ProjectClippedRect(transform, gfx::RectF(src_rect)));
 }
 
 gfx::RectF MathUtil::ProjectClippedRect(const gfx::Transform& transform,
                                         const gfx::RectF& src_rect) {
   if (transform.IsIdentityOrTranslation()) {
-    return src_rect +
-           gfx::Vector2dF(SkMScalarToFloat(transform.matrix().get(0, 3)),
-                          SkMScalarToFloat(transform.matrix().get(1, 3)));
+    gfx::Vector2dF offset(transform.matrix().getFloat(0, 3),
+                          transform.matrix().getFloat(1, 3));
+    return src_rect + offset;
   }
 
   // Perform the projection, but retain the result in homogeneous coordinates.
   gfx::QuadF q = gfx::QuadF(src_rect);
   HomogeneousCoordinate h1 = ProjectHomogeneousPoint(transform, q.p1());
   HomogeneousCoordinate h2 = ProjectHomogeneousPoint(transform, q.p2());
   HomogeneousCoordinate h3 = ProjectHomogeneousPoint(transform, q.p3());
   HomogeneousCoordinate h4 = ProjectHomogeneousPoint(transform, q.p4());
 
   return ComputeEnclosingClippedRect(h1, h2, h3, h4);
 }
 
+gfx::Rect MathUtil::MapEnclosedNonClippedRect(const gfx::Transform& transform,

[enne (OOO), 2014/08/25 19:58:56]

Do you think this function name have the 2d axis alignment assertion embedded in
it too?

+                                              const gfx::Rect& rect) {
+  DCHECK(transform.Preserves2dAxisAlignment());
+
+  if (transform.IsIdentityOrIntegerTranslation()) {
+    gfx::Vector2d offset(static_cast<int>(transform.matrix().getFloat(0, 3)),
+                         static_cast<int>(transform.matrix().getFloat(1, 3)));
+    return rect + offset;
+  }
+  if (transform.IsIdentityOrTranslation()) {
+    gfx::Vector2dF offset(transform.matrix().getFloat(0, 3),
+                          transform.matrix().getFloat(1, 3));
+    return gfx::ToEnclosedRect(rect + offset);
+  }
+
+  SkMScalar quad[2 * 2];  // input: 2 x 2D points
+  quad[0] = rect.x();
+  quad[1] = rect.y();
+  quad[2] = rect.right();
+  quad[3] = rect.bottom();
+
+  SkMScalar result[4 * 2];  // output: 2 x 4D homogeneous points
+  transform.matrix().map2(quad, 2, result);
+
+  HomogeneousCoordinate hc0(result[0], result[1], result[2], result[3]);
+  HomogeneousCoordinate hc1(result[4], result[5], result[6], result[7]);
+  DCHECK(!hc0.ShouldBeClipped());
+  DCHECK(!hc1.ShouldBeClipped());
+
+  gfx::PointF top_left(hc0.CartesianPoint2d());
+  gfx::PointF bottom_right(hc1.CartesianPoint2d());
+  return gfx::ToEnclosedRect(gfx::BoundingRect(top_left, bottom_right));
+}
+
 void MathUtil::MapClippedQuad(const gfx::Transform& transform,
                               const gfx::QuadF& src_quad,
                               gfx::PointF clipped_quad[8],
                               int* num_vertices_in_clipped_quad) {
   HomogeneousCoordinate h1 =
       MapHomogeneousPoint(transform, gfx::Point3F(src_quad.p1()));
   HomogeneousCoordinate h2 =
       MapHomogeneousPoint(transform, gfx::Point3F(src_quad.p2()));
   HomogeneousCoordinate h3 =
       MapHomogeneousPoint(transform, gfx::Point3F(src_quad.p3()));
@@ skipping 225 matching lines @@
 
   return gfx::RectF(gfx::PointF(xmin, ymin),
                     gfx::SizeF(xmax - xmin, ymax - ymin));
 }
 
 gfx::QuadF MathUtil::MapQuad(const gfx::Transform& transform,
                              const gfx::QuadF& q,
                              bool* clipped) {
   if (transform.IsIdentityOrTranslation()) {
     gfx::QuadF mapped_quad(q);
-    mapped_quad +=
-        gfx::Vector2dF(SkMScalarToFloat(transform.matrix().get(0, 3)),
-                       SkMScalarToFloat(transform.matrix().get(1, 3)));
+    mapped_quad += gfx::Vector2dF(transform.matrix().getFloat(0, 3),
+                                  transform.matrix().getFloat(1, 3));
     *clipped = false;
     return mapped_quad;
   }
 
   HomogeneousCoordinate h1 =
       MapHomogeneousPoint(transform, gfx::Point3F(q.p1()));
   HomogeneousCoordinate h2 =
       MapHomogeneousPoint(transform, gfx::Point3F(q.p2()));
   HomogeneousCoordinate h3 =
       MapHomogeneousPoint(transform, gfx::Point3F(q.p3()));
@@ skipping 10 matching lines @@
                     h3.CartesianPoint2d(),
                     h4.CartesianPoint2d());
 }
 
 gfx::QuadF MathUtil::MapQuad3d(const gfx::Transform& transform,
                                const gfx::QuadF& q,
                                gfx::Point3F* p,
                                bool* clipped) {
   if (transform.IsIdentityOrTranslation()) {
     gfx::QuadF mapped_quad(q);
-    mapped_quad +=
-        gfx::Vector2dF(SkMScalarToFloat(transform.matrix().get(0, 3)),
-                       SkMScalarToFloat(transform.matrix().get(1, 3)));
+    mapped_quad += gfx::Vector2dF(transform.matrix().getFloat(0, 3),
+                                  transform.matrix().getFloat(1, 3));
     *clipped = false;
     p[0] = gfx::Point3F(mapped_quad.p1().x(), mapped_quad.p1().y(), 0.0f);
     p[1] = gfx::Point3F(mapped_quad.p2().x(), mapped_quad.p2().y(), 0.0f);
     p[2] = gfx::Point3F(mapped_quad.p3().x(), mapped_quad.p3().y(), 0.0f);
     p[3] = gfx::Point3F(mapped_quad.p4().x(), mapped_quad.p4().y(), 0.0f);
     return mapped_quad;
   }
 
   HomogeneousCoordinate h1 =
       MapHomogeneousPoint(transform, gfx::Point3F(q.p1()));
@@ skipping 305 matching lines @@
 
 double MathUtil::AsDoubleSafely(double value) {
   return std::min(value, std::numeric_limits<double>::max());
 }
 
 float MathUtil::AsFloatSafely(float value) {
   return std::min(value, std::numeric_limits<float>::max());
 }
 
 }  // namespace cc