BSP Tree perf tests to match LayerSorter perf tests

cc/trees/layer_tree_host_common_perftest.cc

Index: cc/trees/layer_tree_host_common_perftest.cc
diff --git a/cc/trees/layer_tree_host_common_perftest.cc b/cc/trees/layer_tree_host_common_perftest.cc
index 02b0770495b4c42c789c13ad427200318a2aae86..de15903c52d7ba93a90e1518769d76cddffa46d9 100644
--- a/cc/trees/layer_tree_host_common_perftest.cc
+++ b/cc/trees/layer_tree_host_common_perftest.cc
@@ -8,12 +8,18 @@
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/strings/string_piece.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
+#include "cc/base/scoped_ptr_deque.h"
+#include "cc/base/scoped_ptr_vector.h"
 #include "cc/debug/lap_timer.h"
 #include "cc/layers/layer.h"
+#include "cc/output/bsp_tree.h"
+#include "cc/quads/draw_polygon.h"
+#include "cc/quads/draw_quad.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/layer_tree_json_parser.h"
@@ -197,7 +203,7 @@ class LayerSorterMainTest : public CalcDrawPropsImplTest {
       list->push_back(layer);
     }
 
-    for (unsigned int i = 0; i < layer->children().size(); i++) {
+    for (size_t i = 0; i < layer->children().size(); i++) {
       BuildLayerImplList(layer->children()[i], list);
     }
   }
@@ -207,6 +213,60 @@ class LayerSorterMainTest : public CalcDrawPropsImplTest {
   LayerSorter layer_sorter_;
 };
 
+class BspTreePerfTest : public LayerSorterMainTest {
+ public:
+  void RunSortLayers() { RunTest(false, false, false); }
+
+  void SetNumberOfDuplicates(int num_duplicates) {
+    num_duplicates_ = num_duplicates;
+  }
+
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+    LayerTreeImpl* active_tree = host_impl->active_tree();
+    // First build the tree and then we'll start running tests on layersorter
+    // itself
+    bool can_render_to_separate_surface = true;
+    int max_texture_size = 8096;
+    DoCalcDrawPropertiesImpl(can_render_to_separate_surface,
+                             max_texture_size,
+                             active_tree,
+                             host_impl);
+
+    LayerImplList base_list;
+    BuildLayerImplList(active_tree->root_layer(), &base_list);
+
+    int polygon_counter = 0;
+    ScopedPtrVector<DrawPolygon> polygon_list;
+    for (LayerImplList::iterator it = base_list.begin(); it != base_list.end();
+         ++it) {
+      DrawPolygon* draw_polygon = new DrawPolygon(NULL,
+                                                  gfx::RectF((*it)->bounds()),

[enne (OOO), 2014/07/31 00:18:04]

I lied.  This should be content bounds and not normal bounds, since the draw
transform operates in that space.

[troyhildebrandt, 2014/07/31 18:32:38]

Done.

+                                                  (*it)->draw_transform(),
+                                                  polygon_counter++);
+      polygon_list.push_back(scoped_ptr<DrawPolygon>(draw_polygon));
+    }
+
+    timer_.Reset();
+    do {
+      ScopedPtrDeque<DrawPolygon> test_list;
+      for (int i = 0; i < num_duplicates_; i++) {
+        for (size_t i = 0; i < polygon_list.size(); i++) {
+          test_list.push_back(polygon_list[i]->CreateCopy());
+        }
+      }
+      BspTree bsp_tree(&test_list);
+      timer_.NextLap();
+    } while (!timer_.HasTimeLimitExpired());
+
+    EndTest();
+  }
+
+ private:
+  int num_duplicates_;
+};
+
 TEST_F(CalcDrawPropsMainTest, TenTen) {
   SetTestName("10_10_main_thread");
   ReadTestFile("10_10_layer_tree");
@@ -267,5 +327,33 @@ TEST_F(LayerSorterMainTest, LayerSorterRubik) {
   RunSortLayers();
 }
 
+TEST_F(BspTreePerfTest, BspTreeCubes) {
+  SetTestName("bsp_tree_cubes");
+  SetNumberOfDuplicates(1);
+  ReadTestFile("layer_sort_cubes");
+  RunSortLayers();
+}
+
+TEST_F(BspTreePerfTest, BspTreeRubik) {
+  SetTestName("bsp_tree_rubik");
+  SetNumberOfDuplicates(1);
+  ReadTestFile("layer_sort_rubik");
+  RunSortLayers();
+}
+
+TEST_F(BspTreePerfTest, BspTreeCubes_2) {
+  SetTestName("bsp_tree_cubes_2");
+  SetNumberOfDuplicates(2);
+  ReadTestFile("layer_sort_cubes");
+  RunSortLayers();
+}
+
+TEST_F(BspTreePerfTest, BspTreeCubes_4) {
+  SetTestName("bsp_tree_cubes_4");
+  SetNumberOfDuplicates(4);
+  ReadTestFile("layer_sort_cubes");
+  RunSortLayers();
+}
+
 }  // namespace
 }  // namespace cc