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 1112 matching lines @@
   if (!layer->render_surface()) {
     layer->CreateRenderSurface();
     return layer->render_surface();
   }
 
   layer->render_surface()->ClearLayerLists();
   return layer->render_surface();
 }
 
 template <typename LayerType>
+static inline void MarkLayerWithFrameNumber(

[danakj, 2014/05/05 19:25:41]

"FrameNumber" seems like a misnomer here

[vmpstr, 2014/05/05 20:50:34]

Done.

+    LayerType* layer,
+    int current_calculate_draw_properties_count) {
+  layer->draw_properties().last_valid_render_surface_list_count =
+      current_calculate_draw_properties_count;
+  if (layer->mask_layer()) {
+    layer->mask_layer()
+        ->draw_properties()
+        .last_valid_render_surface_list_count =
+        current_calculate_draw_properties_count;
+  }
+  if (layer->replica_layer() && layer->replica_layer()->mask_layer()) {

[danakj, 2014/05/05 19:25:41]

can you mark the replica layer too (it doesn't have tiles but to be complete)?

[vmpstr, 2014/05/05 20:50:34]

Done.

+    layer->replica_layer()
+        ->mask_layer()
+        ->draw_properties()
+        .last_valid_render_surface_list_count =
+        current_calculate_draw_properties_count;
+  }
+}
+
+template <typename LayerType>
+static inline void MarkLayerWithFrameNumber(
+    scoped_refptr<LayerType> layer,

[danakj, 2014/05/05 19:25:41]

Does the templated method above not handle this case too where
LayerType=scoped_refptr<Layer> ?

[vmpstr, 2014/05/05 20:50:34]

No, the signature is LayerType*, and scoped_refptr<A> doesn't bind to A*. I
think it would be fine if I accept a LayerType&, but that seems less in line
with "pass things by pointer if it's meant to be modified"

+    int current_calculate_draw_properties_count) {
+  MarkLayerWithFrameNumber(layer.get(),
+                           current_calculate_draw_properties_count);
+}
+
+template <typename LayerListType>
+static inline void MarkLayerListWithFrameNumber(
+    LayerListType* layer_list,
+    int current_calculate_draw_properties_count) {
+  for (typename LayerListType::iterator it = layer_list->begin();
+       it != layer_list->end();
+       ++it) {
+    MarkLayerWithFrameNumber(*it, current_calculate_draw_properties_count);
+  }
+}
+
+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();
+    MarkLayerListWithFrameNumber(
+        &render_surface_layer_list->back()->render_surface()->layer_list(), 0);
     render_surface_layer_list->pop_back();
   }
   DCHECK_EQ(render_surface_layer_list->back(), layer_to_remove);
+

[danakj, 2014/05/05 19:25:41]

nit: drop extra whitespace?

[vmpstr, 2014/05/05 20:50:34]

Done.

+  MarkLayerListWithFrameNumber(&layer_to_remove->render_surface()->layer_list(),
+                               0);
+
   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_calculate_draw_properties_count) {
   // 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;
 
     render_surface_layer_list->push_back(layer);

[danakj, 2014/05/05 19:25:41]

Mark the layer with the number here also, if you want to include layers in the
RSLL top list, that aren't in some RS's layer_list

Currently I think this would miss the root layer if it doesn't draw

[vmpstr, 2014/05/05 20:50:34]

In this case, would the layer still be visited by the iterator? If not, then I'm
not sure it should be marked... If so, then it definitely should be :)

[danakj, 2014/05/05 21:25:22]

It would be visited by the iterator with the state
represents_target_render_surface()

   } 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;
     layer_draw_properties.opacity = accumulated_draw_opacity;
@@ skipping 55 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)) {
+    MarkLayerWithFrameNumber(layer, current_calculate_draw_properties_count);
     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_calculate_draw_properties_count);
     if (child->render_surface() &&
         !child->render_surface()->layer_list().empty() &&
         !child->render_surface()->content_rect().IsEmpty()) {
+      MarkLayerWithFrameNumber(child, current_calculate_draw_properties_count);

[danakj, 2014/05/05 19:25:41]

then this one won't be needed any more

[vmpstr, 2014/05/05 20:50:34]

I don't follow... The above would only mark the parent layer, this pushes a
child: shouldn't this be marked independently?

[danakj, 2014/05/05 21:25:22]

This pushes a child that has a render surface. But if it has a render surface,
it was pushed onto the RSLL top level list already by the above one.

IOW you could DCHECK that the rsll.back() is this child here and it should pass
(maybe do that with a comment saying you don't need to mark it?)

       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_calculate_draw_properties_count);
 
   // 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_calculate_draw_properties_count);
 
   // 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