BSP Tree perf tests to match LayerSorter perf tests

cc/quads/draw_polygon.cc

 // Copyright 2014 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/quads/draw_polygon.h"
 
 #include <vector>
 
 #include "cc/output/bsp_compare_result.h"
+#include "cc/quads/draw_quad.h"
 
 namespace {
 // This allows for some imperfection in the normal comparison when checking if
 // two pieces of geometry are coplanar.
 static const float coplanar_dot_epsilon = 0.01f;
 // This threshold controls how "thick" a plane is. If a point's distance is
 // <= |compare_threshold|, then it is considered on the plane. Only when this
 // boundary is crossed do we consider doing splitting.
 static const float compare_threshold = 1.0f;
 // |split_threshold| is lower in this case because we want the points created
@@ skipping 18 matching lines @@
                          const std::vector<gfx::Point3F>& in_points,
                          const gfx::Vector3dF& normal,
                          int draw_order_index)
     : order_index_(draw_order_index), original_ref_(original) {
   for (size_t i = 0; i < in_points.size(); i++) {
     points_.push_back(in_points[i]);
   }
   normal_ = normal;
 }
 
+// This takes the original DrawQuad that this polygon should be based on,
+// a visible content rect to make the 4 corner points from, and a transformation
+// to move it and its normal into screen space.
+DrawPolygon::DrawPolygon(DrawQuad* original_ref,
+                         const gfx::RectF& visible_content_rect,
+                         const gfx::Transform& transform,
+                         int draw_order_index)
+    : order_index_(draw_order_index), original_ref_(original_ref) {
+  normal_ = default_normal;
+  gfx::Point3F points[8];
+  int num_vertices_in_clipped_quad;
+  gfx::QuadF send_quad(visible_content_rect);
+
+  // Doing this mapping here is very important, since we can't just transform
+  // the points without clipping and not run into strange geometry issues when
+  // crossing w = 0. At this point, in the constructor, we know that we're
+  // working with a quad, so we can reuse the MathUtil::MapClippedQuad3d
+  // function instead of writing a generic polygon version of it.
+  MathUtil::MapClippedQuad3d(
+      transform, send_quad, points, &num_vertices_in_clipped_quad);
+  for (int i = 0; i < num_vertices_in_clipped_quad; i++) {
+    points_.push_back(points[i]);
+  }
+  ApplyTransformToNormal(transform);
+}
+
 DrawPolygon::~DrawPolygon() {
 }
 
 scoped_ptr<DrawPolygon> DrawPolygon::CreateCopy() {
   DrawPolygon* new_polygon = new DrawPolygon();
   new_polygon->order_index_ = order_index_;
   new_polygon->original_ref_ = original_ref_;
   new_polygon->points_.reserve(points_.size());
   new_polygon->points_ = points_;
   new_polygon->normal_.set_x(normal_.x());
@@ skipping 258 matching lines @@
     quads->push_back(
         gfx::QuadF(first,
                    gfx::PointF(points_[offset].x(), points_[offset].y()),
                    gfx::PointF(points_[op1].x(), points_[op1].y()),
                    gfx::PointF(points_[op2].x(), points_[op2].y())));
     offset = op2;
   }
 }
 
 }  // namespace cc