cc: Use gfx:: Geometry types for positions, bounds, and related things.

cc/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 "config.h"
 
 #include "cc/math_util.h"
 
-#include "FloatPoint.h"
 #include "FloatQuad.h"
-#include "IntRect.h"
+#include "FloatSize.h"
+#include "ui/gfx/rect.h"
+#include "ui/gfx/rect_conversions.h"
+#include "ui/gfx/rect_f.h"
 #include <cmath>
 #include <public/WebTransformationMatrix.h>
 
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
-static HomogeneousCoordinate projectHomogeneousPoint(const WebTransformationMatrix& transform, const FloatPoint& p)
+static HomogeneousCoordinate projectHomogeneousPoint(const WebTransformationMatrix& transform, const gfx::PointF& p)
 {
     // In this case, the layer we are trying to project onto is perpendicular to ray
     // (point p and z-axis direction) that we are trying to project. This happens when the
     // layer is rotated so that it is infinitesimally thin, or when it is co-planar with
     // the camera origin -- i.e. when the layer is invisible anyway.
     if (!transform.m33())
         return HomogeneousCoordinate(0, 0, 0, 1);
 
     double x = p.x();
     double y = p.y();
@@ skipping 45 matching lines @@
 
     double t = (w - h1.w) / (h2.w - h1.w);
 
     double x = (1-t) * h1.x + t * h2.x;
     double y = (1-t) * h1.y + t * h2.y;
     double z = (1-t) * h1.z + t * h2.z;
 
     return HomogeneousCoordinate(x, y, z, w);
 }
 
-static inline void expandBoundsToIncludePoint(float& xmin, float& xmax, float& ymin, float& ymax, const FloatPoint& p)
+static inline void expandBoundsToIncludePoint(float& xmin, float& xmax, float& ymin, float& ymax, const gfx::PointF& p)
 {
     xmin = std::min(p.x(), xmin);
     xmax = std::max(p.x(), xmax);
     ymin = std::min(p.y(), ymin);
     ymax = std::max(p.y(), ymax);
 }
 
-static inline void addVertexToClippedQuad(const FloatPoint& newVertex, FloatPoint clippedQuad[8], int& numVerticesInClippedQuad)
+static inline void addVertexToClippedQuad(const gfx::PointF& newVertex, gfx::PointF clippedQuad[8], int& numVerticesInClippedQuad)
 {
     clippedQuad[numVerticesInClippedQuad] = newVertex;
     numVerticesInClippedQuad++;
 }
 
-IntRect MathUtil::mapClippedRect(const WebTransformationMatrix& transform, const IntRect& srcRect)
+gfx::Rect MathUtil::mapClippedRect(const WebTransformationMatrix& transform, const gfx::Rect& srcRect)
 {
-    return enclosingIntRect(mapClippedRect(transform, FloatRect(srcRect)));
+    return gfx::ToEnclosingRect(mapClippedRect(transform, gfx::RectF(srcRect)));
 }
 
-FloatRect MathUtil::mapClippedRect(const WebTransformationMatrix& transform, const FloatRect& srcRect)
+gfx::RectF MathUtil::mapClippedRect(const WebTransformationMatrix& transform, const gfx::RectF& srcRect)
 {
     if (transform.isIdentityOrTranslation()) {
-        FloatRect mappedRect(srcRect);
-        mappedRect.move(static_cast<float>(transform.m41()), static_cast<float>(transform.m42()));
+        gfx::RectF mappedRect(srcRect);
+        mappedRect.Offset(static_cast<float>(transform.m41()), static_cast<float>(transform.m42()));
         return mappedRect;
     }
 
     // Apply the transform, but retain the result in homogeneous coordinates.
-    FloatQuad q = FloatQuad(FloatRect(srcRect));
+    FloatQuad q = FloatQuad(gfx::RectF(srcRect));
     HomogeneousCoordinate h1 = mapHomogeneousPoint(transform, q.p1());
     HomogeneousCoordinate h2 = mapHomogeneousPoint(transform, q.p2());
     HomogeneousCoordinate h3 = mapHomogeneousPoint(transform, q.p3());
     HomogeneousCoordinate h4 = mapHomogeneousPoint(transform, q.p4());
 
     return computeEnclosingClippedRect(h1, h2, h3, h4);
 }
 
-FloatRect MathUtil::projectClippedRect(const WebTransformationMatrix& transform, const FloatRect& srcRect)
+gfx::RectF MathUtil::projectClippedRect(const WebTransformationMatrix& transform, const gfx::RectF& srcRect)
 {
     // Perform the projection, but retain the result in homogeneous coordinates.
-    FloatQuad q = FloatQuad(FloatRect(srcRect));
+    FloatQuad q = FloatQuad(gfx::RectF(srcRect));
     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);
 }
 
-void MathUtil::mapClippedQuad(const WebTransformationMatrix& transform, const FloatQuad& srcQuad, FloatPoint clippedQuad[8], int& numVerticesInClippedQuad)
+void MathUtil::mapClippedQuad(const WebTransformationMatrix& transform, const FloatQuad& srcQuad, gfx::PointF clippedQuad[8], int& numVerticesInClippedQuad)
 {
     HomogeneousCoordinate h1 = mapHomogeneousPoint(transform, srcQuad.p1());
     HomogeneousCoordinate h2 = mapHomogeneousPoint(transform, srcQuad.p2());
     HomogeneousCoordinate h3 = mapHomogeneousPoint(transform, srcQuad.p3());
     HomogeneousCoordinate h4 = mapHomogeneousPoint(transform, srcQuad.p4());
 
     // The order of adding the vertices to the array is chosen so that clockwise / counter-clockwise orientation is retained.
 
     numVerticesInClippedQuad = 0;
 
@@ skipping 17 matching lines @@
 
     if (!h4.shouldBeClipped())
         addVertexToClippedQuad(h4.cartesianPoint2d(), clippedQuad, numVerticesInClippedQuad);
 
     if (h4.shouldBeClipped() ^ h1.shouldBeClipped())
         addVertexToClippedQuad(computeClippedPointForEdge(h4, h1).cartesianPoint2d(), clippedQuad, numVerticesInClippedQuad);
 
     DCHECK(numVerticesInClippedQuad <= 8);
 }
 
-FloatRect MathUtil::computeEnclosingRectOfVertices(FloatPoint vertices[], int numVertices)
+gfx::RectF MathUtil::computeEnclosingRectOfVertices(gfx::PointF vertices[], int numVertices)
 {
     if (numVertices < 2)
-        return FloatRect();
+        return gfx::RectF();
 
     float xmin = std::numeric_limits<float>::max();
     float xmax = -std::numeric_limits<float>::max();
     float ymin = std::numeric_limits<float>::max();
     float ymax = -std::numeric_limits<float>::max();
 
     for (int i = 0; i < numVertices; ++i)
         expandBoundsToIncludePoint(xmin, xmax, ymin, ymax, vertices[i]);
 
-    return FloatRect(FloatPoint(xmin, ymin), FloatSize(xmax - xmin, ymax - ymin));
+    return gfx::RectF(gfx::PointF(xmin, ymin), gfx::SizeF(xmax - xmin, ymax - ymin));
 }
 
-FloatRect MathUtil::computeEnclosingClippedRect(const HomogeneousCoordinate& h1, const HomogeneousCoordinate& h2, const HomogeneousCoordinate& h3, const HomogeneousCoordinate& h4)
+gfx::RectF MathUtil::computeEnclosingClippedRect(const HomogeneousCoordinate& h1, const HomogeneousCoordinate& h2, const HomogeneousCoordinate& h3, const HomogeneousCoordinate& h4)
 {
     // This function performs clipping as necessary and computes the enclosing 2d
-    // FloatRect of the vertices. Doing these two steps simultaneously allows us to avoid
+    // gfx::RectF of the vertices. Doing these two steps simultaneously allows us to avoid
     // the overhead of storing an unknown number of clipped vertices.
 
     // If no vertices on the quad are clipped, then we can simply return the enclosing rect directly.
     bool somethingClipped = h1.shouldBeClipped() || h2.shouldBeClipped() || h3.shouldBeClipped() || h4.shouldBeClipped();
     if (!somethingClipped) {
         FloatQuad mappedQuad = FloatQuad(h1.cartesianPoint2d(), h2.cartesianPoint2d(), h3.cartesianPoint2d(), h4.cartesianPoint2d());
         return cc::FloatRect(mappedQuad.boundingBox());
     }
 
     bool everythingClipped = h1.shouldBeClipped() && h2.shouldBeClipped() && h3.shouldBeClipped() && h4.shouldBeClipped();
     if (everythingClipped)
-        return FloatRect();
+        return gfx::RectF();
 
 
     float xmin = std::numeric_limits<float>::max();
     float xmax = -std::numeric_limits<float>::max();
     float ymin = std::numeric_limits<float>::max();
     float ymax = -std::numeric_limits<float>::max();
 
     if (!h1.shouldBeClipped())
         expandBoundsToIncludePoint(xmin, xmax, ymin, ymax, h1.cartesianPoint2d());
 
@@ skipping 11 matching lines @@
 
     if (h3.shouldBeClipped() ^ h4.shouldBeClipped())
         expandBoundsToIncludePoint(xmin, xmax, ymin, ymax, computeClippedPointForEdge(h3, h4).cartesianPoint2d());
 
     if (!h4.shouldBeClipped())
         expandBoundsToIncludePoint(xmin, xmax, ymin, ymax, h4.cartesianPoint2d());
 
     if (h4.shouldBeClipped() ^ h1.shouldBeClipped())
         expandBoundsToIncludePoint(xmin, xmax, ymin, ymax, computeClippedPointForEdge(h4, h1).cartesianPoint2d());
 
-    return FloatRect(FloatPoint(xmin, ymin), FloatSize(xmax - xmin, ymax - ymin));
+    return gfx::RectF(gfx::PointF(xmin, ymin), gfx::SizeF(xmax - xmin, ymax - ymin));
 }
 
 FloatQuad MathUtil::mapQuad(const WebTransformationMatrix& transform, const FloatQuad& q, bool& clipped)
 {
     if (transform.isIdentityOrTranslation()) {
         FloatQuad mappedQuad(q);
         mappedQuad.move(static_cast<float>(transform.m41()), static_cast<float>(transform.m42()));
         clipped = false;
         return mappedQuad;
     }
 
     HomogeneousCoordinate h1 = mapHomogeneousPoint(transform, q.p1());
     HomogeneousCoordinate h2 = mapHomogeneousPoint(transform, q.p2());
     HomogeneousCoordinate h3 = mapHomogeneousPoint(transform, q.p3());
     HomogeneousCoordinate h4 = mapHomogeneousPoint(transform, q.p4());
 
     clipped = h1.shouldBeClipped() || h2.shouldBeClipped() || h3.shouldBeClipped() || h4.shouldBeClipped();
 
     // Result will be invalid if clipped == true. But, compute it anyway just in case, to emulate existing behavior.
     return FloatQuad(h1.cartesianPoint2d(), h2.cartesianPoint2d(), h3.cartesianPoint2d(), h4.cartesianPoint2d());
 }
 
-FloatPoint MathUtil::mapPoint(const WebTransformationMatrix& transform, const FloatPoint& p, bool& clipped)
+gfx::PointF MathUtil::mapPoint(const WebTransformationMatrix& transform, const gfx::PointF& p, bool& clipped)
 {
-    HomogeneousCoordinate h = mapHomogeneousPoint(transform, p);
+    HomogeneousCoordinate h = mapHomogeneousPoint(transform, cc::FloatPoint(p));
 
     if (h.w > 0) {
         clipped = false;
         return h.cartesianPoint2d();
     }
 
     // The cartesian coordinates will be invalid after dividing by w.
     clipped = true;
 
     // Avoid dividing by w if w == 0.
     if (!h.w)
-        return FloatPoint();
+        return gfx::PointF();
 
     // This return value will be invalid because clipped == true, but (1) users of this
     // code should be ignoring the return value when clipped == true anyway, and (2) this
     // behavior is more consistent with existing behavior of WebKit transforms if the user
     // really does not ignore the return value.
     return h.cartesianPoint2d();
 }
 
 FloatPoint3D MathUtil::mapPoint(const WebTransformationMatrix& transform, const FloatPoint3D& p, bool& clipped)
 {
@@ skipping 27 matching lines @@
     projectedQuad.setP2(projectPoint(transform, q.p2(), clippedPoint));
     clipped |= clippedPoint;
     projectedQuad.setP3(projectPoint(transform, q.p3(), clippedPoint));
     clipped |= clippedPoint;
     projectedQuad.setP4(projectPoint(transform, q.p4(), clippedPoint));
     clipped |= clippedPoint;
 
     return projectedQuad;
 }
 
-FloatPoint MathUtil::projectPoint(const WebTransformationMatrix& transform, const FloatPoint& p, bool& clipped)
+gfx::PointF MathUtil::projectPoint(const WebTransformationMatrix& transform, const gfx::PointF& p, bool& clipped)
 {
     HomogeneousCoordinate h = projectHomogeneousPoint(transform, p);
 
     if (h.w > 0) {
         // The cartesian coordinates will be valid in this case.
         clipped = false;
         return h.cartesianPoint2d();
     }
 
     // The cartesian coordinates will be invalid after dividing by w.
     clipped = true;
 
     // Avoid dividing by w if w == 0.
     if (!h.w)
-        return FloatPoint();
+        return gfx::PointF();
 
     // This return value will be invalid because clipped == true, but (1) users of this
     // code should be ignoring the return value when clipped == true anyway, and (2) this
     // behavior is more consistent with existing behavior of WebKit transforms if the user
     // really does not ignore the return value.
     return h.cartesianPoint2d();
 }
 
 void MathUtil::flattenTransformTo2d(WebTransformationMatrix& transform)
 {
@@ skipping 14 matching lines @@
     transform.setM33(1);
     transform.setM34(0);
     transform.setM43(0);
 }
 
 static inline float scaleOnAxis(double a, double b, double c)
 {
     return std::sqrt(a * a + b * b + c * c);
 }
 
-FloatPoint MathUtil::computeTransform2dScaleComponents(const WebTransformationMatrix& transform)
+gfx::Vector2dF MathUtil::computeTransform2dScaleComponents(const WebTransformationMatrix& transform)
 {
     if (transform.hasPerspective())
-        return FloatPoint(1, 1);
+        return gfx::Vector2dF(1, 1);
     float xScale = scaleOnAxis(transform.m11(), transform.m12(), transform.m13());
     float yScale = scaleOnAxis(transform.m21(), transform.m22(), transform.m23());
-    return FloatPoint(xScale, yScale);
+    return gfx::Vector2dF(xScale, yScale);
 }
 
 float MathUtil::smallestAngleBetweenVectors(const FloatSize& v1, const FloatSize& v2)
 {
     float dotProduct = (v1.width() * v2.width() + v1.height() * v2.height()) / (v1.diagonalLength() * v2.diagonalLength());
     // Clamp to compensate for rounding errors.
     dotProduct = std::max(-1.f, std::min(1.f, dotProduct));
     return rad2deg(acosf(dotProduct));
 }
 
 FloatSize MathUtil::projectVector(const FloatSize& source, const FloatSize& destination)
 {
     float sourceDotDestination = source.width() * destination.width() + source.height() * destination.height();
     float projectedLength = sourceDotDestination / destination.diagonalLengthSquared();
     return FloatSize(projectedLength * destination.width(), projectedLength * destination.height());
 }
 
 } // namespace cc