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

cc/layer_sorter.cc

 // Copyright 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 "config.h"
 
 #include "cc/layer_sorter.h"
 
 #include <deque>
 #include <limits>
 #include <vector>
 
 #include "base/logging.h"
 #include "cc/math_util.h"
 #include "cc/render_surface_impl.h"
 #include <public/WebTransformationMatrix.h>
 
 using namespace std;
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
-inline static float perpProduct(const FloatSize& u, const FloatSize& v)
+inline static float perpProduct(const gfx::Vector2dF& u, const gfx::Vector2dF& v)
 {
-    return u.width() * v.height() - u.height() * v.width();
+    return u.x() * v.y() - u.y() * v.x();
 }
 
 // Tests if two edges defined by their endpoints (a,b) and (c,d) intersect. Returns true and the
 // point of intersection if they do and false otherwise.
-static bool edgeEdgeTest(const FloatPoint& a, const FloatPoint& b, const FloatPoint& c, const FloatPoint& d, FloatPoint& r)
+static bool edgeEdgeTest(const gfx::PointF& a, const gfx::PointF& b, const gfx::PointF& c, const gfx::PointF& d, gfx::PointF& r)
 {
-    FloatSize u = b - a;
-    FloatSize v = d - c;
-    FloatSize w = a - c;
+    gfx::Vector2dF u = b - a;
+    gfx::Vector2dF v = d - c;
+    gfx::Vector2dF w = a - c;
 
     float denom = perpProduct(u, v);
 
     // If denom == 0 then the edges are parallel. While they could be overlapping
     // we don't bother to check here as the we'll find their intersections from the
     // corner to quad tests.
     if (!denom)
         return false;
 
     float s = perpProduct(v, w) / denom;
     if (s < 0 || s > 1)
         return false;
 
     float t = perpProduct(u, w) / denom;
     if (t < 0 || t > 1)
         return false;
 
-    u.scale(s);
+    u.Scale(s);
     r = a + u;
     return true;
 }
 
 GraphNode::GraphNode(LayerImpl* layerImpl)
     : layer(layerImpl)
     , incomingEdgeWeight(0)
 {
 }
 
@@ skipping 11 matching lines @@
 }
 
 // Checks whether layer "a" draws on top of layer "b". The weight value returned is an indication of
 // the maximum z-depth difference between the layers or zero if the layers are found to be intesecting
 // (some features are in front and some are behind).
 LayerSorter::ABCompareResult LayerSorter::checkOverlap(LayerShape* a, LayerShape* b, float zThreshold, float& weight)
 {
     weight = 0;
 
     // Early out if the projected bounds don't overlap.
-    if (!a->projectedBounds.intersects(b->projectedBounds))
+    if (!a->projectedBounds.Intersects(b->projectedBounds))
         return None;
 
-    FloatPoint aPoints[4] = {a->projectedQuad.p1(), a->projectedQuad.p2(), a->projectedQuad.p3(), a->projectedQuad.p4() };
-    FloatPoint bPoints[4] = {b->projectedQuad.p1(), b->projectedQuad.p2(), b->projectedQuad.p3(), b->projectedQuad.p4() };
+    gfx::PointF aPoints[4] = {a->projectedQuad.p1(), a->projectedQuad.p2(), a->projectedQuad.p3(), a->projectedQuad.p4() };
+    gfx::PointF bPoints[4] = {b->projectedQuad.p1(), b->projectedQuad.p2(), b->projectedQuad.p3(), b->projectedQuad.p4() };
 
     // Make a list of points that inside both layer quad projections.
-    std::vector<FloatPoint> overlapPoints;
+    std::vector<gfx::PointF> overlapPoints;
 
     // Check all four corners of one layer against the other layer's quad.
     for (int i = 0; i < 4; ++i) {
         if (a->projectedQuad.containsPoint(bPoints[i]))
             overlapPoints.push_back(bPoints[i]);
         if (b->projectedQuad.containsPoint(aPoints[i]))
             overlapPoints.push_back(aPoints[i]);
     }
 
     // Check all the edges of one layer for intersection with the other layer's edges.
-    FloatPoint r;
+    gfx::PointF r;
     for (int ea = 0; ea < 4; ++ea)
         for (int eb = 0; eb < 4; ++eb)
             if (edgeEdgeTest(aPoints[ea], aPoints[(ea + 1) % 4],
                              bPoints[eb], bPoints[(eb + 1) % 4],
                              r))
                 overlapPoints.push_back(r);
 
     if (overlapPoints.empty())
         return None;
 
@@ skipping 33 matching lines @@
 LayerShape::LayerShape()
 {
 }
 
 LayerShape::LayerShape(float width, float height, const WebTransformationMatrix& drawTransform)
 {
     FloatQuad layerQuad(FloatRect(0, 0, width, height));
 
     // Compute the projection of the layer quad onto the z = 0 plane.
 
-    FloatPoint clippedQuad[8];
+    gfx::PointF clippedQuad[8];
     int numVerticesInClippedQuad;
     MathUtil::mapClippedQuad(drawTransform, layerQuad, clippedQuad, numVerticesInClippedQuad);
 
     if (numVerticesInClippedQuad < 3) {
         projectedBounds = FloatRect();
         return;
     }
 
     projectedBounds = MathUtil::computeEnclosingRectOfVertices(clippedQuad, numVerticesInClippedQuad);
 
@@ skipping 16 matching lines @@
     FloatPoint3D c2 = MathUtil::mapPoint(drawTransform, FloatPoint3D(0, 1, 0), clipped);
     FloatPoint3D c3 = MathUtil::mapPoint(drawTransform, FloatPoint3D(1, 0, 0), clipped);
     // FIXME: Deal with clipping.
     FloatPoint3D c12 = c2 - c1;
     FloatPoint3D c13 = c3 - c1;
     layerNormal = c13.cross(c12);
 
     transformOrigin = c1;
 }
 
+LayerShape::~LayerShape()
+{
+}
+
 // Returns the Z coordinate of a point on the layer that projects
 // to point p which lies on the z = 0 plane. It does it by computing the
 // intersection of a line starting from p along the Z axis and the plane
 // of the layer.
-float LayerShape::layerZFromProjectedPoint(const FloatPoint& p) const
+float LayerShape::layerZFromProjectedPoint(const gfx::PointF& p) const
 {
     const FloatPoint3D zAxis(0, 0, 1);
-    FloatPoint3D w = FloatPoint3D(p) - transformOrigin;
+    FloatPoint3D w = FloatPoint3D(cc::FloatPoint(p)) - transformOrigin;
 
     float d = layerNormal.dot(zAxis);
     float n = -layerNormal.dot(w);
 
     // Check if layer is parallel to the z = 0 axis which will make it
     // invisible and hence returning zero is fine.
     if (!d)
         return 0;
 
     // The intersection point would be given by:
@@ skipping 192 matching lines @@
         *it = sortedList[count++]->layer;
 
     DVLOG(2) << "Sorting end ----";
 
     m_nodes.clear();
     m_edges.clear();
     m_activeEdges.clear();
 }
 
 }