Added LayerSorter::Sort perftests

Added two JSON tree dumps to be loaded by the perftests

Same as issue 305063002 (https://codereview.chromium.org/305063002)

Review URL: https://codereview.chromium.org/312233002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@275331 0039d316-1c4b-4281-b951-d872f2087c98

cc/layers/layer_impl.cc

@@ -635,6 +635,7 @@ base::DictionaryValue* LayerImpl::LayerTreeAsJson() const {
   result->Set("DrawTransform", list);
 
   result->SetBoolean("DrawsContent", draws_content_);
+  result->SetBoolean("Is3DSorted", is_3d_sorted_);
   result->SetDouble("Opacity", opacity());
   result->SetBoolean("ContentsOpaque", contents_opaque_);
 

cc/test/layer_tree_json_parser.cc

@@ -129,6 +129,10 @@ scoped_refptr<Layer> ParseTreeFromValue(base::Value* val,
   if (dict->GetBoolean("ScrollHandler", &scroll_handler))
     new_layer->SetHaveScrollEventHandlers(scroll_handler);
 
+  bool is_3d_sorted;
+  if (dict->GetBoolean("Is3DSorted", &is_3d_sorted))
+    new_layer->SetIs3dSorted(is_3d_sorted);
+
   if (dict->HasKey("TouchRegion")) {
     success &= dict->GetList("TouchRegion", &list);
     Region touch_region;

cc/trees/layer_tree_host_common_perftest.cc

@@ -19,6 +19,7 @@
 #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"
 
@@ -125,27 +126,85 @@ class CalcDrawPropsImplTest : public LayerTreeHostCommonPerfTest {
     do {
       bool can_render_to_separate_surface = true;
       int max_texture_size = 8096;
-      LayerImplList update_list;
-      LayerTreeHostCommon::CalcDrawPropsImplInputs inputs(
-          active_tree->root_layer(),
-          active_tree->DrawViewportSize(),
-          host_impl->DrawTransform(),
-          active_tree->device_scale_factor(),
-          active_tree->total_page_scale_factor(),
-          active_tree->InnerViewportContainerLayer(),
-          max_texture_size,
-          host_impl->settings().can_use_lcd_text,
-          can_render_to_separate_surface,
-          host_impl->settings().layer_transforms_should_scale_layer_contents,
-          &update_list,
-          0);
-      LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+      DoCalcDrawPropertiesImpl(can_render_to_separate_surface,
+                               max_texture_size,
+                               active_tree,
+                               host_impl);
+
+      timer_.NextLap();
+    } while (!timer_.HasTimeLimitExpired());
+
+    EndTest();
+  }
+
+  void DoCalcDrawPropertiesImpl(bool can_render_to_separate_surface,
+                                int max_texture_size,
+                                LayerTreeImpl* active_tree,
+                                LayerTreeHostImpl* host_impl) {
+    LayerImplList update_list;
+    LayerTreeHostCommon::CalcDrawPropsImplInputs inputs(
+        active_tree->root_layer(),
+        active_tree->DrawViewportSize(),
+        host_impl->DrawTransform(),
+        active_tree->device_scale_factor(),
+        active_tree->total_page_scale_factor(),
+        active_tree->InnerViewportContainerLayer(),
+        max_texture_size,
+        host_impl->settings().can_use_lcd_text,
+        can_render_to_separate_surface,
+        host_impl->settings().layer_transforms_should_scale_layer_contents,
+        &update_list,
+        0);
+    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+  }
+};
+
+class LayerSorterMainTest : public CalcDrawPropsImplTest {
+ public:
+  void RunSortLayers() { RunTest(false, false, false); }
+
+  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);
 
+    // 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->is_3d_sorted()) {
+      list->push_back(layer);
+    }
+
+    for (unsigned int i = 0; i < layer->children().size(); i++) {
+      BuildLayerImplList(layer->children()[i], list);
+    }
+  }
+
+ private:
+  LayerImplList base_list_;
+  LayerSorter layer_sorter_;
 };
 
 TEST_F(CalcDrawPropsMainTest, TenTen) {
@@ -196,5 +255,17 @@ TEST_F(CalcDrawPropsImplTest, TouchRegionHeavy) {
   RunCalcDrawProps();
 }
 
+TEST_F(LayerSorterMainTest, LayerSorterCubes) {
+  SetTestName("layer_sort_cubes");
+  ReadTestFile("layer_sort_cubes");
+  RunSortLayers();
+}
+
+TEST_F(LayerSorterMainTest, LayerSorterRubik) {
+  SetTestName("layer_sort_rubik");
+  ReadTestFile("layer_sort_rubik");
+  RunSortLayers();
+}
+
 }  // namespace
 }  // namespace cc