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

cc/trees/layer_tree_host_common.h

 // 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.
 
 #ifndef CC_TREES_LAYER_TREE_HOST_COMMON_H_
 #define CC_TREES_LAYER_TREE_HOST_COMMON_H_
 
 #include <limits>
 #include <vector>
 
@@ skipping 23 matching lines @@
     CalcDrawPropsInputs(LayerType* root_layer,
                         const gfx::Size& device_viewport_size,
                         const gfx::Transform& device_transform,
                         float device_scale_factor,
                         float page_scale_factor,
                         const LayerType* page_scale_application_layer,
                         int max_texture_size,
                         bool can_use_lcd_text,
                         bool can_render_to_separate_surface,
                         bool can_adjust_raster_scales,
-                        RenderSurfaceLayerListType* render_surface_layer_list)
+                        RenderSurfaceLayerListType* render_surface_layer_list,
+                        size_t current_calculate_draw_properties_count)
         : root_layer(root_layer),
           device_viewport_size(device_viewport_size),
           device_transform(device_transform),
           device_scale_factor(device_scale_factor),
           page_scale_factor(page_scale_factor),
           page_scale_application_layer(page_scale_application_layer),
           max_texture_size(max_texture_size),
           can_use_lcd_text(can_use_lcd_text),
           can_render_to_separate_surface(can_render_to_separate_surface),
           can_adjust_raster_scales(can_adjust_raster_scales),
-          render_surface_layer_list(render_surface_layer_list) {}
+          render_surface_layer_list(render_surface_layer_list),
+          current_calculate_draw_properties_count(
+              current_calculate_draw_properties_count) {}
 
     LayerType* root_layer;
     gfx::Size device_viewport_size;
     const gfx::Transform& device_transform;
     float device_scale_factor;
     float page_scale_factor;
     const LayerType* page_scale_application_layer;
     int max_texture_size;
     bool can_use_lcd_text;
     bool can_render_to_separate_surface;
     bool can_adjust_raster_scales;
     RenderSurfaceLayerListType* render_surface_layer_list;
+    size_t current_calculate_draw_properties_count;

[enne (OOO), 2014/05/02 23:47:53]

I think I would prefer using SourceFrameNumber here.

(Also, size_t => int)

[vmpstr, 2014/05/05 18:46:43]

I would still prefer to have an independent count here... The reason is that I
want to ensure that this doesn't change anywhere except when
CalculateDrawProperties is called (or right before that), and remains unchanged
otherwise (so that ManageTiles has correct information). Using the
Source{,Animation}FrameNumber seem like a risk to me. That is, it changes when
we draw, and it only changes sometimes (if we don't early out from drawing).
It's very much dependent on the order of operations.. So, if we ever calc draw
props, then update the frame number, and then call manage tiles, then wrong
things will happen.

I _think_ this is OK now, but it really feels like a source of future bugs (or
maybe current bugs). Anyway, if you still insist that we use the frame number,
I'll dig in to see if there are any cases where it's not appropriate (which is
hopefully none). Otherwise, please consider the current implementation.

   };
 
   template <typename LayerType, typename RenderSurfaceLayerListType>
   struct CalcDrawPropsInputsForTesting
       : public CalcDrawPropsInputs<LayerType, RenderSurfaceLayerListType> {
     CalcDrawPropsInputsForTesting(
         LayerType* root_layer,
         const gfx::Size& device_viewport_size,
         const gfx::Transform& device_transform,
         RenderSurfaceLayerListType* render_surface_layer_list);
@@ skipping 179 matching lines @@
           true,
           false,
           render_surface_layer_list) {
   DCHECK(root_layer);
   DCHECK(render_surface_layer_list);
 }
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_COMMON_H_