Tighten bounds on 3d 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 160 matching lines @@
   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 AddVertexToClippedQuad3d(const gfx::Point3F& new_vertex,
-                                            gfx::Point3F clipped_quad[8],
+                                            gfx::Point3F clipped_quad[6],
                                             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 @@
   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));
 }
 
 bool MathUtil::MapClippedQuad3d(const gfx::Transform& transform,
                                 const gfx::QuadF& src_quad,
-                                gfx::Point3F clipped_quad[8],
+                                gfx::Point3F clipped_quad[6],
                                 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()));
 
@@ skipping 40 matching lines @@
   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);
+  DCHECK_LE(*num_vertices_in_clipped_quad, 6);

[flackr, 2017/01/12 16:59:11]

I'm concerned with the DCHECK that if we got this maximum amount wrong for some
reason we might not find out if it's a rare case (i.e. only hit on release where
it may crash later). Can we make this a release check?

[danakj, 2017/01/12 17:01:19]

Can we not just find a provably correct number?

   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();
 
   float xmin = std::numeric_limits<float>::max();
@@ skipping 523 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