cc: Add a flag to layers that returns true if the layer is in RSLL.

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 1111 matching lines @@
     LayerType* layer) {
   if (!layer->render_surface()) {
     layer->CreateRenderSurface();
     return layer->render_surface();
   }
 
   layer->render_surface()->ClearLayerLists();
   return layer->render_surface();
 }
 
+template <typename LayerTypePtr>
+static inline void MarkLayerWithRenderSurfaceLayerListId(
+    LayerTypePtr layer,
+    int current_render_surface_layer_list_id) {
+  layer->draw_properties().last_valid_render_surface_layer_list_id =
+      current_render_surface_layer_list_id;
+  if (layer->mask_layer()) {
+    layer->mask_layer()
+        ->draw_properties()
+        .last_valid_render_surface_layer_list_id =
+        current_render_surface_layer_list_id;
+  }
+  if (layer->replica_layer()) {
+    layer->replica_layer()
+        ->draw_properties()
+        .last_valid_render_surface_layer_list_id =
+        current_render_surface_layer_list_id;
+    if (layer->replica_layer()->mask_layer()) {
+      layer->replica_layer()
+          ->mask_layer()
+          ->draw_properties()
+          .last_valid_render_surface_layer_list_id =
+          current_render_surface_layer_list_id;
+    }
+  }
+}
+
+template <typename LayerListType>
+static inline void MarkLayerListWithRenderSurfaceLayerListId(
+    LayerListType* layer_list,
+    int current_render_surface_layer_list_id) {
+  for (typename LayerListType::iterator it = layer_list->begin();
+       it != layer_list->end();
+       ++it) {
+    MarkLayerWithRenderSurfaceLayerListId(*it,
+                                          current_render_surface_layer_list_id);
+  }
+}
+
 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()->ClearRenderSurfaceLayerList();
+    MarkLayerListWithRenderSurfaceLayerListId(

[enne (OOO), 2014/05/06 21:10:27]

This doesn't do anything.  You're calling this after
ClearRenderSurfaceLayerList.

[vmpstr, 2014/05/06 22:38:53]

Fixed.

+        &render_surface_layer_list->back()->render_surface()->layer_list(), 0);
+    MarkLayerWithRenderSurfaceLayerListId(render_surface_layer_list->back(), 0);

[enne (OOO), 2014/05/06 21:10:27]

Likewise, this.

[vmpstr, 2014/05/06 22:38:53]

This marks the layer itself?

[enne (OOO), 2014/05/07 00:12:11]

Ok, I guess it's getting the mask and replica from the layer.  The layer itself
got cleared in the list above.

     render_surface_layer_list->pop_back();
   }
   DCHECK_EQ(render_surface_layer_list->back(), layer_to_remove);
+  MarkLayerListWithRenderSurfaceLayerListId(

[enne (OOO), 2014/05/06 21:10:27]

We will only get into this function if
layer_to_remove->render_surface()->layer_list() is empty.  Can you just assert
instead of calling this function?

[vmpstr, 2014/05/06 22:38:53]

It doesn't have to be empty here, we also call this function when the whole
thing is clipped away. At least, I think that's the reason we have to clear the
render surface layer list?

[enne (OOO), 2014/05/07 00:12:11]

Oh right, I forgot the clip case.

+      &layer_to_remove->render_surface()->layer_list(), 0);
+  MarkLayerWithRenderSurfaceLayerListId(layer_to_remove, 0);

[enne (OOO), 2014/05/06 21:10:27]

This should already be marked properly.  The layer was not added to its own RSLL
by definition because of the check before calling this function.  Therefore, its
id is already correctly stale.  Can you just assert instead of calling this
function?

   render_surface_layer_list->pop_back();
   layer_to_remove->ClearRenderSurfaceLayerList();
 }
 
 struct PreCalculateMetaInformationRecursiveData {
   bool layer_or_descendant_has_copy_request;
   int num_unclipped_descendants;
 
   PreCalculateMetaInformationRecursiveData()
       : layer_or_descendant_has_copy_request(false),
@@ skipping 258 matching lines @@
 
 // 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::LayerListType* layer_list,
-    std::vector<AccumulatedSurfaceState<LayerType> >*
-        accumulated_surface_state) {
+    std::vector<AccumulatedSurfaceState<LayerType> >* accumulated_surface_state,
+    int current_render_surface_layer_list_id) {
   // 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.
   //
   // 1. In our terminology, the "layer origin" refers to the top-left corner of
   // a layer, and the positive Y-axis points downwards. This interpretation is
@@ skipping 490 matching lines @@
       render_surface->SetClipRect(gfx::Rect());
       clip_rect_of_target_surface_in_target_space =
           data_from_ancestor.clip_rect_of_target_surface_in_target_space;
     }
 
     // If the new render surface is drawn translucent or with a non-integral
     // translation then the subtree that gets drawn on this render surface
     // cannot use LCD text.
     data_for_children.subtree_can_use_lcd_text = layer_can_use_lcd_text;
 
+    MarkLayerWithRenderSurfaceLayerListId(layer,

[danakj, 2014/05/06 21:02:36]

We were discussing this and enne@ pointed out that you only want to mark layers
that contribute their content to their render target (ie the layer itself draws
something), as opposed to all layers that are in the RSLL at all?

Meaning, you don't want to include a picture layer that doesn't draw anything
but owns a RenderSurface?

If that's corrent then apologies, this should go away, along with the DCHECK
below that you added, and your test expectations would have to be adjusted to
match.

+                                          current_render_surface_layer_list_id);
     render_surface_layer_list->push_back(layer);
   } else {
     DCHECK(layer->parent());
 
     // Note: layer_draw_properties.target_space_transform is computed above,
     // before this if-else statement.
     layer_draw_properties.target_space_transform_is_animating =
         animating_transform_to_target;
     layer_draw_properties.screen_space_transform_is_animating =
         animating_transform_to_screen;
@@ skipping 56 matching lines @@
   }
 
   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))
+  if (!LayerShouldBeSkipped(layer, layer_is_drawn)) {
+    MarkLayerWithRenderSurfaceLayerListId(layer,
+                                          current_render_surface_layer_list_id);
     descendants.push_back(layer);
+  }
 
   // Any layers that are appended after this point may need to be sorted if we
   // visit the children out of order.
   size_t render_surface_layer_list_child_sorting_start_index =
       render_surface_layer_list->size();
   size_t layer_list_child_sorting_start_index = descendants.size();
 
   if (!layer->children().empty()) {
     if (layer == globals.page_scale_application_layer) {
       data_for_children.parent_matrix.Scale(
@@ skipping 39 matching lines @@
     LayerType* child =
         layer_draw_properties.has_child_with_a_scroll_parent
             ? sorted_children[i]
             : LayerTreeHostCommon::get_layer_as_raw_ptr(layer->children(), i);
 
     child->draw_properties().index_of_first_descendants_addition =
         descendants.size();
     child->draw_properties().index_of_first_render_surface_layer_list_addition =
         render_surface_layer_list->size();
 
-    CalculateDrawPropertiesInternal<LayerType>(child,
-                                               globals,
-                                               data_for_children,
-                                               render_surface_layer_list,
-                                               &descendants,
-                                               accumulated_surface_state);
+    CalculateDrawPropertiesInternal<LayerType>(
+        child,
+        globals,
+        data_for_children,
+        render_surface_layer_list,
+        &descendants,
+        accumulated_surface_state,
+        current_render_surface_layer_list_id);
     if (child->render_surface() &&
         !child->render_surface()->layer_list().empty() &&
         !child->render_surface()->content_rect().IsEmpty()) {
+      // We don't need to mark this child with the draw properties id, since it
+      // should've already been marked when it was pushed into the top level
+      // render surface list.
+      DCHECK(std::find(render_surface_layer_list->begin(),
+                       render_surface_layer_list->end(),
+                       child) != render_surface_layer_list->end());
       descendants.push_back(child);
     }
 
     child->draw_properties().num_descendants_added =
         descendants.size() -
         child->draw_properties().index_of_first_descendants_addition;
     child->draw_properties().num_render_surfaces_added =
         render_surface_layer_list->size() -
         child->draw_properties()
             .index_of_first_render_surface_layer_list_addition;
@@ skipping 227 matching lines @@
 void LayerTreeHostCommon::CalculateDrawProperties(
     CalcDrawPropsMainInputs* inputs) {
   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,
-                                         inputs->render_surface_layer_list,
-                                         &dummy_layer_list,
-                                         &accumulated_surface_state);
+  CalculateDrawPropertiesInternal<Layer>(
+      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());
 }
 
 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);
+  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());
 }
 
 static bool PointHitsRect(
     const gfx::PointF& screen_space_point,
@@ skipping 205 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