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..e9f7ce2e2d1027d89d7023aca82d2dfcf53b5961 100644
--- a/cc/trees/layer_tree_host_common_perftest.cc
+++ b/cc/trees/layer_tree_host_common_perftest.cc
@@ -8,12 +8,17 @@
 
 #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_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"
@@ -21,6 +26,7 @@
 #include "cc/test/paths.h"
 #include "cc/trees/layer_sorter.h"
 #include "cc/trees/layer_tree_impl.h"
+#include "cc/trees/single_thread_proxy.h"
 #include "testing/perf/perf_test.h"
 
 namespace cc {
@@ -207,6 +213,61 @@ 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,
+                                                  (*it)->visible_content_rect(),

[enne (OOO), 2014/07/30 18:43:56]

Are the visible content rects valid in this test? Could you change it to
gfx::Rect((*it)->bounds()) so that it's much more obvious that we're testing the
entire layer as a quad (since that's what the layer sorter is sorting against,
so it's slightly more fair)?

[troyhildebrandt, 2014/07/30 23:36:57]

Using bounds() now.

+                                                  (*it)->draw_transform(),
+                                                  polygon_counter++);
+      polygon_list.push_back(scoped_ptr<DrawPolygon>(draw_polygon));
+    }
+
+    timer_.Reset();
+    do {
+      ScopedPtrDeque<DrawPolygon> test_list;
+      int dupe_counter = num_duplicates_;
+      while (dupe_counter-- > 0) {

[enne (OOO), 2014/07/30 18:43:56]

Use a for loop here.

[troyhildebrandt, 2014/07/30 23:36:57]

Done.

+        for (unsigned int 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 +328,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