Don't add duplicate points when clipping

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 137 matching lines @@
                                               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 bool IsNearlyTheSame(const float f, const float g) {
+  // The idea behind this is to use this fraction of the larger of the
+  // two numbers as the limit of the difference.  This breaks down near
+  // zero, so we reuse this as the minimum absolute size we will use
+  // for the base of the scale too.
+  static const float epsilon_scale = 0.00001f;
+  return std::abs(f - g) <
+         epsilon_scale *
+             std::max(std::max(std::abs(f), std::abs(g)), epsilon_scale);
+}
+
+static inline bool IsNearlyTheSame(const gfx::PointF& lhs,
+                                   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)++;
 }
 
 gfx::Rect MathUtil::MapEnclosingClippedRect(const gfx::Transform& transform,
                                             const gfx::Rect& src_rect) {
   if (transform.IsIdentityOrIntegerTranslation()) {
     gfx::Vector2d offset(static_cast<int>(transform.matrix().getFloat(0, 3)),
                          static_cast<int>(transform.matrix().getFloat(1, 3)));
     return src_rect + offset;
@@ skipping 160 matching lines @@
   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 =
@@ skipping 41 matching lines @@
   if (!h4.ShouldBeClipped()) {
     AddVertexToClippedQuad3d(
         h4.CartesianPoint3d(), clipped_quad, num_vertices_in_clipped_quad);
   }
 
   if (h4.ShouldBeClipped() ^ h1.ShouldBeClipped()) {
     AddVertexToClippedQuad3d(ComputeClippedCartesianPoint3dForEdge(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);
   return (*num_vertices_in_clipped_quad >= 4);
 }
 
 gfx::RectF MathUtil::ComputeEnclosingRectOfVertices(
     const gfx::PointF vertices[],
     int num_vertices) {
   if (num_vertices < 2)
     return gfx::RectF();
 
@@ skipping 509 matching lines @@
   _mm_setcsr(orig_state_ | 0x8040);
 #endif
 }
 
 ScopedSubnormalFloatDisabler::~ScopedSubnormalFloatDisabler() {
 #ifdef __SSE__
   _mm_setcsr(orig_state_);
 #endif
 }
 
+bool IsNearlyTheSameForTesting(float left, float right) {
+  return IsNearlyTheSame(left, right);
+}
+
+bool IsNearlyTheSameForTesting(const gfx::PointF& left,
+                               const gfx::PointF& right) {
+  return IsNearlyTheSame(left, right);
+}
+
+bool IsNearlyTheSameForTesting(const gfx::Point3F& left,
+                               const gfx::Point3F& right) {
+  return IsNearlyTheSame(left, right);
+}
+
 }  // namespace cc