Remove 2d MapClippedQuad.

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>
 #ifdef __SSE__
@@ skipping 159 matching lines @@
                                    const gfx::PointF& rhs) {
   return IsNearlyTheSame(lhs.x(), rhs.x()) && IsNearlyTheSame(lhs.y(), rhs.y());
 }
 
 static inline bool IsNearlyTheSame(const gfx::Point3F& lhs,
                                    const gfx::Point3F& rhs) {
   return IsNearlyTheSame(lhs.x(), rhs.x()) &&
          IsNearlyTheSame(lhs.y(), rhs.y()) && IsNearlyTheSame(lhs.z(), rhs.z());
 }
 
-static inline void AddVertexToClippedQuad(const gfx::PointF& new_vertex,
-                                          gfx::PointF clipped_quad[8],
-                                          int* num_vertices_in_clipped_quad) {
-  if (*num_vertices_in_clipped_quad > 0 &&
-      IsNearlyTheSame(clipped_quad[*num_vertices_in_clipped_quad - 1],
-                      new_vertex))
-    return;
-
-  clipped_quad[*num_vertices_in_clipped_quad] = new_vertex;
-  (*num_vertices_in_clipped_quad)++;
-}
-
 static inline void AddVertexToClippedQuad3d(const gfx::Point3F& new_vertex,
                                             gfx::Point3F clipped_quad[8],
                                             int* num_vertices_in_clipped_quad) {
   if (*num_vertices_in_clipped_quad > 0 &&
       IsNearlyTheSame(clipped_quad[*num_vertices_in_clipped_quad - 1],
                       new_vertex))
     return;
 
   clipped_quad[*num_vertices_in_clipped_quad] = new_vertex;
   (*num_vertices_in_clipped_quad)++;
@@ skipping 110 matching lines @@
   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()));
-  HomogeneousCoordinate h4 =
-      MapHomogeneousPoint(transform, gfx::Point3F(src_quad.p4()));
-
-  // The order of adding the vertices to the array is chosen so that
-  // clockwise / counter-clockwise orientation is retained.
-
-  *num_vertices_in_clipped_quad = 0;
-
-  if (!h1.ShouldBeClipped()) {
-    AddVertexToClippedQuad(
-        h1.CartesianPoint2d(), clipped_quad, num_vertices_in_clipped_quad);
-  }
-
-  if (h1.ShouldBeClipped() ^ h2.ShouldBeClipped()) {
-    AddVertexToClippedQuad(ComputeClippedCartesianPoint2dForEdge(h1, h2),
-                           clipped_quad, num_vertices_in_clipped_quad);
-  }
-
-  if (!h2.ShouldBeClipped()) {
-    AddVertexToClippedQuad(
-        h2.CartesianPoint2d(), clipped_quad, num_vertices_in_clipped_quad);
-  }
-
-  if (h2.ShouldBeClipped() ^ h3.ShouldBeClipped()) {
-    AddVertexToClippedQuad(ComputeClippedCartesianPoint2dForEdge(h2, h3),
-                           clipped_quad, num_vertices_in_clipped_quad);
-  }
-
-  if (!h3.ShouldBeClipped()) {
-    AddVertexToClippedQuad(
-        h3.CartesianPoint2d(), clipped_quad, num_vertices_in_clipped_quad);
-  }
-
-  if (h3.ShouldBeClipped() ^ h4.ShouldBeClipped()) {
-    AddVertexToClippedQuad(ComputeClippedCartesianPoint2dForEdge(h3, h4),
-                           clipped_quad, num_vertices_in_clipped_quad);
-  }
-
-  if (!h4.ShouldBeClipped()) {
-    AddVertexToClippedQuad(
-        h4.CartesianPoint2d(), clipped_quad, num_vertices_in_clipped_quad);
-  }
-
-  if (h4.ShouldBeClipped() ^ h1.ShouldBeClipped()) {
-    AddVertexToClippedQuad(ComputeClippedCartesianPoint2dForEdge(h4, h1),
-                           clipped_quad, num_vertices_in_clipped_quad);
-  }
-
-  if (*num_vertices_in_clipped_quad > 2 &&
-      IsNearlyTheSame(clipped_quad[0],
-                      clipped_quad[*num_vertices_in_clipped_quad - 1]))
-    *num_vertices_in_clipped_quad -= 1;
-
-  DCHECK_LE(*num_vertices_in_clipped_quad, 8);
-}
-
 bool MathUtil::MapClippedQuad3d(const gfx::Transform& transform,
                                 const gfx::QuadF& src_quad,
                                 gfx::Point3F 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 587 matching lines @@
                                          const gfx::PointF& right) {
   return IsNearlyTheSame(left, right);
 }
 
 bool MathUtil::IsNearlyTheSameForTesting(const gfx::Point3F& left,
                                          const gfx::Point3F& right) {
   return IsNearlyTheSame(left, right);
 }
 
 }  // namespace cc