cc: Replace WebCore::FloatQuad with gfx::QuadF.

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>
@@ skipping 74 matching lines @@
         return None;
 
     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<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]))
+        if (a->projectedQuad.Contains(bPoints[i]))
             overlapPoints.push_back(bPoints[i]);
-        if (b->projectedQuad.containsPoint(aPoints[i]))
+        if (b->projectedQuad.Contains(aPoints[i]))
             overlapPoints.push_back(aPoints[i]);
     }
 
     // Check all the edges of one layer for intersection with the other layer's edges.
     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))
@@ skipping 34 matching lines @@
 
     return BBeforeA;
 }
 
 LayerShape::LayerShape()
 {
 }
 
 LayerShape::LayerShape(float width, float height, const WebTransformationMatrix& drawTransform)
 {
-    FloatQuad layerQuad(gfx::RectF(0, 0, width, height));
+    gfx::QuadF layerQuad(gfx::RectF(0, 0, width, height));
 
     // Compute the projection of the layer quad onto the z = 0 plane.
 
     gfx::PointF clippedQuad[8];
     int numVerticesInClippedQuad;
     MathUtil::mapClippedQuad(drawTransform, layerQuad, clippedQuad, numVerticesInClippedQuad);
 
     if (numVerticesInClippedQuad < 3) {
         projectedBounds = gfx::RectF();
         return;
     }
 
     projectedBounds = MathUtil::computeEnclosingRectOfVertices(clippedQuad, numVerticesInClippedQuad);
 
     // NOTE: it will require very significant refactoring and overhead to deal with
     // generalized polygons or multiple quads per layer here. For the sake of layer
     // sorting it is equally correct to take a subsection of the polygon that can be made
     // into a quad. This will only be incorrect in the case of intersecting layers, which
     // are not supported yet anyway.
-    projectedQuad.setP1(clippedQuad[0]);
-    projectedQuad.setP2(clippedQuad[1]);
-    projectedQuad.setP3(clippedQuad[2]);
+    projectedQuad.set_p1(clippedQuad[0]);
+    projectedQuad.set_p2(clippedQuad[1]);
+    projectedQuad.set_p3(clippedQuad[2]);
     if (numVerticesInClippedQuad >= 4)
-        projectedQuad.setP4(clippedQuad[3]);
+        projectedQuad.set_p4(clippedQuad[3]);
     else
-        projectedQuad.setP4(clippedQuad[2]); // this will be a degenerate quad that is actually a triangle.
+        projectedQuad.set_p4(clippedQuad[2]); // this will be a degenerate quad that is actually a triangle.
 
     // Compute the normal of the layer's plane.
     bool clipped = false;
     gfx::Point3F c1 = MathUtil::mapPoint(drawTransform, gfx::Point3F(0, 0, 0), clipped);
     gfx::Point3F c2 = MathUtil::mapPoint(drawTransform, gfx::Point3F(0, 1, 0), clipped);
     gfx::Point3F c3 = MathUtil::mapPoint(drawTransform, gfx::Point3F(1, 0, 0), clipped);
     // FIXME: Deal with clipping.
     gfx::Vector3dF c12 = c2 - c1;
     gfx::Vector3dF c13 = c3 - c1;
     layerNormal = gfx::CrossProduct(c13, c12);
@@ skipping 218 matching lines @@
         *it = sortedList[count++]->layer;
 
     DVLOG(2) << "Sorting end ----";
 
     m_nodes.clear();
     m_edges.clear();
     m_activeEdges.clear();
 }
 
 }