Revert of Splitting of layers for correct intersections

cc/trees/layer_tree_host_common_perftest.cc

 // Copyright 2013 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/trees/layer_tree_host_common.h"
 
 #include <sstream>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.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"
 #include "cc/test/layer_tree_test.h"
 #include "cc/test/paths.h"
+#include "cc/trees/layer_sorter.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "testing/perf/perf_test.h"
 
 namespace cc {
 namespace {
 
 static const int kTimeLimitMillis = 2000;
 static const int kWarmupRuns = 5;
 static const int kTimeCheckInterval = 10;
 
@@ skipping 116 matching lines @@
         host_impl->settings().can_use_lcd_text,
         host_impl->settings().layers_always_allowed_lcd_text,
         can_render_to_separate_surface,
         host_impl->settings().layer_transforms_should_scale_layer_contents,
         host_impl->settings().verify_property_trees,
         &update_list, 0);
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
   }
 };
 
-class BspTreePerfTest : public CalcDrawPropsImplTest {
+class LayerSorterMainTest : public CalcDrawPropsImplTest {
  public:
   void RunSortLayers() { RunTest(false, false, false); }
 
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+
+  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);
+
+    // Behaviour of this test is different from that of sorting in practice.
+    // In this case, all layers that exist in any 3D context are put into a list
+    // and are sorted as one big 3D context instead of several smaller ones.
+    BuildLayerImplList(active_tree->root_layer(), &base_list_);
+    timer_.Reset();
+    do {
+      // Here we'll move the layers into a LayerImpl list of their own to be
+      // sorted so we don't have a sorted list for every run after the first
+      LayerImplList test_list = base_list_;
+      layer_sorter_.Sort(test_list.begin(), test_list.end());
+      timer_.NextLap();
+    } while (!timer_.HasTimeLimitExpired());
+
+    EndTest();
+  }
+
+  void BuildLayerImplList(LayerImpl* layer, LayerImplList* list) {
+    if (layer->Is3dSorted()) {
+      list->push_back(layer);
+    }
+
+    for (size_t i = 0; i < layer->children().size(); i++) {
+      BuildLayerImplList(layer->children()[i], list);
+    }
+  }
+
+ private:
+  LayerImplList base_list_;
+  LayerSorter layer_sorter_;
+};
+
+class BspTreePerfTest : public LayerSorterMainTest {
+ public:
+  void RunSortLayers() { RunTest(false, false, false); }
+
   void SetNumberOfDuplicates(int num_duplicates) {
     num_duplicates_ = num_duplicates;
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   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
@@ skipping 27 matching lines @@
           test_list.push_back(polygon_list[i]->CreateCopy());
         }
       }
       BspTree bsp_tree(&test_list);
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
     EndTest();
   }
 
-  void BuildLayerImplList(LayerImpl* layer, LayerImplList* list) {
-    if (layer->Is3dSorted()) {
-      list->push_back(layer);
-    }
-
-    for (size_t i = 0; i < layer->children().size(); i++) {
-      BuildLayerImplList(layer->children()[i], list);
-    }
-  }
-
  private:
-  LayerImplList base_list_;
   int num_duplicates_;
 };
 
 TEST_F(CalcDrawPropsMainTest, TenTen) {
   SetTestName("10_10_main_thread");
   ReadTestFile("10_10_layer_tree");
   RunCalcDrawProps();
 }
 
 TEST_F(CalcDrawPropsMainTest, HeavyPage) {
@@ skipping 31 matching lines @@
   ReadTestFile("touch_region_light");
   RunCalcDrawProps();
 }
 
 TEST_F(CalcDrawPropsImplTest, TouchRegionHeavy) {
   SetTestName("touch_region_heavy");
   ReadTestFile("touch_region_heavy");
   RunCalcDrawProps();
 }
 
-TEST_F(BspTreePerfTest, LayerSorterCubes) {
+TEST_F(LayerSorterMainTest, LayerSorterCubes) {
   SetTestName("layer_sort_cubes");
   ReadTestFile("layer_sort_cubes");
   RunSortLayers();
 }
 
-TEST_F(BspTreePerfTest, LayerSorterRubik) {
+TEST_F(LayerSorterMainTest, LayerSorterRubik) {
   SetTestName("layer_sort_rubik");
   ReadTestFile("layer_sort_rubik");
   // TODO(vollick): Remove verify_property_trees setting after
   // crbug.com/444219 is fixed.
   bool old_verify_property_trees = verify_property_trees();
   set_verify_property_trees(false);
   RunSortLayers();
   set_verify_property_trees(old_verify_property_trees);
 }
 
@@ skipping 25 matching lines @@
 
 TEST_F(BspTreePerfTest, BspTreeCubes_4) {
   SetTestName("bsp_tree_cubes_4");
   SetNumberOfDuplicates(4);
   ReadTestFile("layer_sort_cubes");
   RunSortLayers();
 }
 
 }  // namespace
 }  // namespace cc