Don't clear render surfaces unnecessarily.

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/debug/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 1094 matching lines @@
     *combined_maximum_animation_contents_scale = 0.f;
     return;
   }
   gfx::Vector2dF ancestor_transform_scales =
       MathUtil::ComputeTransform2dScaleComponents(ancestor_transform, 0.f);
   *combined_maximum_animation_contents_scale =
       layer_maximum_animated_scale *
       std::max(ancestor_transform_scales.x(), ancestor_transform_scales.y());
 }
 
-static inline RenderSurface* CreateOrReuseRenderSurface(Layer* layer) {
-  // The render surface should always be new on the main thread, as the
-  // RenderSurfaceLayerList should be a new empty list when given to
-  // CalculateDrawProperties.
-  DCHECK(!layer->render_surface());
-  layer->CreateRenderSurface();
-  return layer->render_surface();
-}
-
-static inline RenderSurfaceImpl* CreateOrReuseRenderSurface(LayerImpl* layer) {
+template <typename LayerType>
+static inline typename LayerType::RenderSurfaceType* CreateOrReuseRenderSurface(
+    LayerType* layer) {
   if (!layer->render_surface()) {
     layer->CreateRenderSurface();
     return layer->render_surface();
   }
 
   layer->render_surface()->ClearLayerLists();
   return layer->render_surface();
 }
 
 template <typename LayerType>
 static inline void RemoveSurfaceForEarlyExit(
     LayerType* layer_to_remove,
     typename LayerType::RenderSurfaceListType* render_surface_layer_list) {
   DCHECK(layer_to_remove->render_surface());
   // Technically, we know that the layer we want to remove should be
   // at the back of the render_surface_layer_list. However, we have had
   // bugs before that added unnecessary layers here
   // (https://bugs.webkit.org/show_bug.cgi?id=74147), but that causes
   // things to crash. So here we proactively remove any additional
   // layers from the end of the list.
-  while (render_surface_layer_list->back() != layer_to_remove) {
-    render_surface_layer_list->back()->ClearRenderSurface();
+  while (render_surface_layer_list->back() != layer_to_remove)
     render_surface_layer_list->pop_back();
-  }
   DCHECK_EQ(render_surface_layer_list->back(), layer_to_remove);
   render_surface_layer_list->pop_back();
-  layer_to_remove->ClearRenderSurface();
 }
 
 struct PreCalculateMetaInformationRecursiveData {
   bool layer_or_descendant_has_copy_request;
   int num_unclipped_descendants;
 
   PreCalculateMetaInformationRecursiveData()
       : layer_or_descendant_has_copy_request(false),
         num_unclipped_descendants(0) {}
 
@@ skipping 212 matching lines @@
 
 template <typename LayerType>
 static void GetNewRenderSurfacesStartIndexAndCount(LayerType* layer,
                                                    size_t* start_index,
                                                    size_t* count) {
   *start_index = layer->draw_properties()
                      .index_of_first_render_surface_layer_list_addition;
   *count = layer->draw_properties().num_render_surfaces_added;
 }
 
-template <typename LayerType,
-          typename GetIndexAndCountType>
+// We need to extract a list from the the two flavors of RenderSurfaceListType
+// for use in the sorting function below.
+static LayerList* GetLayerListForSorting(RenderSurfaceLayerList* rsll) {
+  return rsll->layer_list();
+}
+
+static LayerImplList* GetLayerListForSorting(LayerImplList* layer_list) {
+  return layer_list;
+}
+
+template <typename LayerType, typename GetIndexAndCountType>
 static void SortLayerListContributions(
     const LayerType& parent,
-    typename LayerType::RenderSurfaceListType* unsorted,
+    typename LayerType::LayerListType* unsorted,
     size_t start_index_for_all_contributions,
     GetIndexAndCountType get_index_and_count) {
-
   typename LayerType::LayerListType buffer;
   for (size_t i = 0; i < parent.children().size(); ++i) {
     LayerType* child =
         LayerTreeHostCommon::get_child_as_raw_ptr(parent.children(), i);
 
     size_t start_index = 0;
     size_t count = 0;
     get_index_and_count(child, &start_index, &count);
     for (size_t j = start_index; j < start_index + count; ++j)
       buffer.push_back(unsorted->at(j));
   }
 
   DCHECK_EQ(buffer.size(),
             unsorted->size() - start_index_for_all_contributions);
 
   for (size_t i = 0; i < buffer.size(); ++i)
     (*unsorted)[i + start_index_for_all_contributions] = buffer[i];
 }
 
 // Recursively walks the layer tree starting at the given node and computes all
 // the necessary transformations, clip rects, render surfaces, etc.
 template <typename LayerType>
 static void CalculateDrawPropertiesInternal(
     LayerType* layer,
     const SubtreeGlobals<LayerType>& globals,
     const DataForRecursion<LayerType>& data_from_ancestor,
     typename LayerType::RenderSurfaceListType* render_surface_layer_list,
-    typename LayerType::RenderSurfaceListType* layer_list,
+    typename LayerType::LayerListType* layer_list,
     std::vector<AccumulatedSurfaceState<LayerType> >*
         accumulated_surface_state) {
   // This function computes the new matrix transformations recursively for this
   // layer and all its descendants. It also computes the appropriate render
   // surfaces.
   // Some important points to remember:
   //
   // 0. Here, transforms are notated in Matrix x Vector order, and in words we
   // describe what the transform does from left to right.
   //
@@ skipping 121 matching lines @@
   // Layers that are marked as hidden will hide themselves and their subtree.
   // Exception: Layers with copy requests, whether hidden or not, must be drawn
   // anyway.  In this case, we will inform their subtree they are visible to get
   // the right results.
   const bool layer_is_visible =
       data_from_ancestor.subtree_is_visible_from_ancestor &&
       !layer->hide_layer_and_subtree();
   const bool layer_is_drawn = layer_is_visible || layer->HasCopyRequest();
 
   // The root layer cannot skip CalcDrawProperties.
-  if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer, layer_is_drawn)) {
-    if (layer->render_surface())
-      layer->ClearRenderSurface();
+  if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer, layer_is_drawn))
     return;
-  }
 
   // We need to circumvent the normal recursive flow of information for clip
   // children (they don't inherit their direct ancestor's clip information).
   // This is unfortunate, and would be unnecessary if we were to formally
   // separate the clipping hierarchy from the layer hierarchy.
   bool ancestor_clips_subtree = data_from_ancestor.ancestor_clips_subtree;
   gfx::Rect ancestor_clip_rect_in_target_space =
       data_from_ancestor.clip_rect_in_target_space;
 
   // Update our clipping state. If we have a clip parent we will need to pull
@@ skipping 180 matching lines @@
   if (globals.can_render_to_separate_surface) {
     render_to_separate_surface = SubtreeShouldRenderToSeparateSurface(
           layer, combined_transform.Preserves2dAxisAlignment());
   } else {
     render_to_separate_surface = IsRootLayer(layer);
   }
   if (render_to_separate_surface) {
     // Check back-face visibility before continuing with this surface and its
     // subtree
     if (!layer->double_sided() && TransformToParentIsKnown(layer) &&
-        IsSurfaceBackFaceVisible(layer, combined_transform)) {
-      layer->ClearRenderSurface();
+        IsSurfaceBackFaceVisible(layer, combined_transform))
       return;
-    }
 
     typename LayerType::RenderSurfaceType* render_surface =
         CreateOrReuseRenderSurface(layer);
 
     if (IsRootLayer(layer)) {
       // The root layer's render surface size is predetermined and so the root
       // layer can't directly support non-identity transforms.  It should just
       // forward top-level transforms to the rest of the tree.
       data_for_children.parent_matrix = combined_transform;
 
@@ skipping 210 matching lines @@
   // is used in the recursion below, so we must set it beforehand.
   layer_draw_properties.is_clipped = layer_or_ancestor_clips_descendants;
   if (layer_or_ancestor_clips_descendants) {
     layer_draw_properties.clip_rect = clip_rect_in_target_space;
   } else {
     // Initialize the clip rect to a safe value that will not clip the
     // layer, just in case clipping is still accidentally used.
     layer_draw_properties.clip_rect = rect_in_target_space;
   }
 
-  typename LayerType::RenderSurfaceListType& descendants =
+  typename LayerType::LayerListType& descendants =
       (layer->render_surface() ? layer->render_surface()->layer_list()
                                : *layer_list);
 
   // Any layers that are appended after this point are in the layer's subtree
   // and should be included in the sorting process.
   size_t sorting_start_index = descendants.size();
 
   if (!LayerShouldBeSkipped(layer, layer_is_drawn))
     descendants.push_back(layer);
 
@@ skipping 72 matching lines @@
     child->draw_properties().num_render_surfaces_added =
         render_surface_layer_list->size() -
         child->draw_properties()
             .index_of_first_render_surface_layer_list_addition;
   }
 
   // Add the unsorted layer list contributions, if necessary.
   if (child_order_changed) {
     SortLayerListContributions(
         *layer,
-        render_surface_layer_list,
+        GetLayerListForSorting(render_surface_layer_list),
         render_surface_layer_list_child_sorting_start_index,
         &GetNewRenderSurfacesStartIndexAndCount<LayerType>);
 
     SortLayerListContributions(
         *layer,
         &descendants,
         layer_list_child_sorting_start_index,
         &GetNewDescendantsStartIndexAndCount<LayerType>);
   }
 
@@ skipping 202 matching lines @@
   data_for_recursion->ancestor_is_animating_scale = false;
   data_for_recursion->ancestor_clips_subtree = true;
   data_for_recursion->nearest_occlusion_immune_ancestor_surface = NULL;
   data_for_recursion->in_subtree_of_page_scale_application_layer = false;
   data_for_recursion->subtree_can_use_lcd_text = inputs.can_use_lcd_text;
   data_for_recursion->subtree_is_visible_from_ancestor = true;
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     CalcDrawPropsMainInputs* inputs) {
-  RenderSurfaceLayerList dummy_layer_list;
+  LayerList dummy_layer_list;
   SubtreeGlobals<Layer> globals;
   DataForRecursion<Layer> data_for_recursion;
   ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion);
 
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
   std::vector<AccumulatedSurfaceState<Layer> > accumulated_surface_state;
   CalculateDrawPropertiesInternal<Layer>(inputs->root_layer,
                                          globals,
                                          data_for_recursion,
@@ skipping 248 matching lines @@
   // At this point, we think the point does hit the touch event handler region
   // on the layer, but we need to walk up the parents to ensure that the layer
   // was not clipped in such a way that the hit point actually should not hit
   // the layer.
   if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer_impl))
     return false;
 
   return true;
 }
 }  // namespace cc