Revert of Splitting of layers for correct intersections

cc/trees/layer_tree_host_common.cc

 // Copyright 2011 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 <algorithm>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/render_surface.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/trees/draw_property_utils.h"
+#include "cc/trees/layer_sorter.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/transform_util.h"
 
 namespace cc {
 
 ScrollAndScaleSet::ScrollAndScaleSet()
     : page_scale_delta(1.f), top_controls_delta(0.f) {
 }
 
 ScrollAndScaleSet::~ScrollAndScaleSet() {}
 
+static void SortLayers(LayerList::iterator first,
+                       LayerList::iterator end,
+                       void* layer_sorter) {
+  NOTREACHED();
+}
+
+static void SortLayers(LayerImplList::iterator first,
+                       LayerImplList::iterator end,
+                       LayerSorter* layer_sorter) {
+  DCHECK(layer_sorter);
+  TRACE_EVENT0("cc", "LayerTreeHostCommon::SortLayers");
+  layer_sorter->Sort(first, end);
+}
+
 template <typename LayerType>
 static gfx::Vector2dF GetEffectiveScrollDelta(LayerType* layer) {
   // Layer's scroll offset can have an integer part and fractional part.
   // Due to Blink's limitation, it only counter-scrolls the position-fixed
   // layer using the integer part of Layer's scroll offset.
   // CC scrolls the layer using the full scroll offset, so we have to
   // add the ScrollCompensationAdjustment (fractional part of the scroll
   // offset) to the effective scroll delta which is used to counter-scroll
   // the position-fixed layer.
   gfx::Vector2dF scroll_delta =
@@ skipping 1214 matching lines @@
   layer->draw_properties().num_unclipped_descendants =
       recursive_data->num_unclipped_descendants;
   layer->draw_properties().layer_or_descendant_has_copy_request =
       recursive_data->layer_or_descendant_has_copy_request;
   layer->draw_properties().layer_or_descendant_has_input_handler =
       recursive_data->layer_or_descendant_has_input_handler;
 }
 
 template <typename LayerType>
 struct SubtreeGlobals {
+  LayerSorter* layer_sorter;
   int max_texture_size;
   float device_scale_factor;
   float page_scale_factor;
   const LayerType* page_scale_application_layer;
   gfx::Vector2dF elastic_overscroll;
   const LayerType* elastic_overscroll_application_layer;
   bool can_adjust_raster_scales;
   bool can_render_to_separate_surface;
   bool layers_always_allowed_lcd_text;
 };
@@ skipping 1065 matching lines @@
   }
 
   SavePaintPropertiesLayer(layer);
 
   // If neither this layer nor any of its children were added, early out.
   if (sorting_start_index == descendants.size()) {
     DCHECK(!render_to_separate_surface || IsRootLayer(layer));
     return;
   }
 
+  // If preserves-3d then sort all the descendants in 3D so that they can be
+  // drawn from back to front. If the preserves-3d property is also set on the
+  // parent then skip the sorting as the parent will sort all the descendants
+  // anyway.
+  if (globals.layer_sorter && descendants.size() && layer->Is3dSorted() &&
+      !LayerIsInExisting3DRenderingContext(layer)) {
+    SortLayers(descendants.begin() + sorting_start_index,
+               descendants.end(),
+               globals.layer_sorter);
+  }
+
   UpdateAccumulatedSurfaceState<LayerType>(
       layer, local_drawable_content_rect_of_subtree, accumulated_surface_state);
 
   if (layer->HasContributingDelegatedRenderPasses()) {
     layer->render_target()->render_surface()->
         AddContributingDelegatedRenderPassLayer(layer);
   }
 }  // NOLINT(readability/fn_size)
 
 template <typename LayerType, typename RenderSurfaceLayerListType>
@@ skipping 17 matching lines @@
       MathUtil::ComputeTransform2dScaleComponents(inputs.device_transform, 1.f);
   // Not handling the rare case of different x and y device scale.
   float device_transform_scale =
       std::max(device_transform_scale_components.x(),
                device_transform_scale_components.y());
 
   gfx::Transform scaled_device_transform = inputs.device_transform;
   scaled_device_transform.Scale(inputs.device_scale_factor,
                                 inputs.device_scale_factor);
 
+  globals->layer_sorter = NULL;
   globals->max_texture_size = inputs.max_texture_size;
   globals->device_scale_factor =
       inputs.device_scale_factor * device_transform_scale;
   globals->page_scale_factor = inputs.page_scale_factor;
   globals->page_scale_application_layer = inputs.page_scale_application_layer;
   globals->elastic_overscroll = inputs.elastic_overscroll;
   globals->elastic_overscroll_application_layer =
       inputs.elastic_overscroll_application_layer;
   globals->can_render_to_separate_surface =
       inputs.can_render_to_separate_surface;
@@ skipping 136 matching lines @@
   }
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     CalcDrawPropsImplInputs* inputs) {
   LayerImplList dummy_layer_list;
   SubtreeGlobals<LayerImpl> globals;
   DataForRecursion<LayerImpl> data_for_recursion;
   ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion);
 
+  LayerSorter layer_sorter;
+  globals.layer_sorter = &layer_sorter;
+
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
   std::vector<AccumulatedSurfaceState<LayerImpl>> accumulated_surface_state;
   CalculateDrawPropertiesInternal<LayerImpl>(
       inputs->root_layer,
       globals,
       data_for_recursion,
       inputs->render_surface_layer_list,
       &dummy_layer_list,
       &accumulated_surface_state,
       inputs->current_render_surface_layer_list_id);
 
   // The dummy layer list should not have been used.
   DCHECK_EQ(0u, dummy_layer_list.size());
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
   DCHECK(inputs->root_layer->render_surface());
 }
 
 }  // namespace cc