cc: layer_or_descendant_has_copy_request is inherited by siblings.

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 751 matching lines @@
   while (render_surface_layer_list->back() != layer_to_remove) {
     render_surface_layer_list->back()->ClearRenderSurface();
     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_descendent_has_copy_request;
+  bool layer_or_descendant_has_copy_request;
 
   PreCalculateMetaInformationRecursiveData()
-      : layer_or_descendent_has_copy_request(false) {}
+      : layer_or_descendant_has_copy_request(false) {}
+
+  void Merge(const PreCalculateMetaInformationRecursiveData& data) {
+    layer_or_descendant_has_copy_request |=
+        data.layer_or_descendant_has_copy_request;
+  }
 };
 
 // Recursively walks the layer tree to compute any information that is needed
 // before doing the main recursion.
 template <typename LayerType>
 static void PreCalculateMetaInformation(
     LayerType* layer,
     PreCalculateMetaInformationRecursiveData* recursive_data) {
   bool has_delegated_content = layer->HasDelegatedContent();
   int num_descendants_that_draw_content = 0;
   bool descendants_can_clip_selves = true;
 
   if (has_delegated_content) {
     // Layers with delegated content need to be treated as if they have as
     // many children as the number of layers they own delegated quads for.
     // Since we don't know this number right now, we choose one that acts like
     // infinity for our purposes.
     num_descendants_that_draw_content = 1000;
     descendants_can_clip_selves = false;
   }
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     LayerType* child_layer =
         LayerTreeHostCommon::get_child_as_raw_ptr(layer->children(), i);
-    PreCalculateMetaInformation<LayerType>(child_layer, recursive_data);
+
+    PreCalculateMetaInformationRecursiveData data_for_child;
+    PreCalculateMetaInformation(child_layer, &data_for_child);
 
     if (!has_delegated_content) {
       bool sublayer_transform_prevents_clip =
           !layer->sublayer_transform().IsPositiveScaleOrTranslation();
 
       num_descendants_that_draw_content += child_layer->DrawsContent() ? 1 : 0;
       num_descendants_that_draw_content +=
           child_layer->draw_properties().num_descendants_that_draw_content;
 
       if ((child_layer->DrawsContent() && !child_layer->CanClipSelf()) ||
           !child_layer->draw_properties().descendants_can_clip_selves ||
           sublayer_transform_prevents_clip ||
           !child_layer->transform().IsPositiveScaleOrTranslation())
         descendants_can_clip_selves = false;
     }
+
+    recursive_data->Merge(data_for_child);
   }
 
   if (layer->HasCopyRequest())
-    recursive_data->layer_or_descendent_has_copy_request = true;
+    recursive_data->layer_or_descendant_has_copy_request = true;
 
   layer->draw_properties().num_descendants_that_draw_content =
       num_descendants_that_draw_content;
   layer->draw_properties().descendants_can_clip_selves =
       descendants_can_clip_selves;
   layer->draw_properties().layer_or_descendant_has_copy_request =
-      recursive_data->layer_or_descendent_has_copy_request;
+      recursive_data->layer_or_descendant_has_copy_request;
 }
 
 static void RoundTranslationComponents(gfx::Transform* transform) {
   transform->matrix().
       setDouble(0, 3, MathUtil::Round(transform->matrix().getDouble(0, 3)));
   transform->matrix().
       setDouble(1, 3, MathUtil::Round(transform->matrix().getDouble(1, 3)));
 }
 
 // Recursively walks the layer tree starting at the given node and computes all
@@ skipping 765 matching lines @@
   // initial clip rect.
   bool subtree_should_be_clipped = true;
   gfx::Rect device_viewport_rect(device_viewport_size);
   bool in_subtree_of_page_scale_application_layer = false;
   bool subtree_is_visible = true;
 
   // This function should have received a root layer.
   DCHECK(IsRootLayer(root_layer));
 
   PreCalculateMetaInformationRecursiveData recursive_data;
-  PreCalculateMetaInformation<Layer>(root_layer, &recursive_data);
+  PreCalculateMetaInformation(root_layer, &recursive_data);
 
   CalculateDrawPropertiesInternal<Layer, LayerList, RenderSurface>(
       root_layer,
       scaled_device_transform,
       identity_matrix,
       identity_matrix,
       root_layer,
       device_viewport_rect,
       device_viewport_rect,
       subtree_should_be_clipped,
@@ skipping 40 matching lines @@
   // initial clip rect.
   bool subtree_should_be_clipped = true;
   gfx::Rect device_viewport_rect(device_viewport_size);
   bool in_subtree_of_page_scale_application_layer = false;
   bool subtree_is_visible = true;
 
   // This function should have received a root layer.
   DCHECK(IsRootLayer(root_layer));
 
   PreCalculateMetaInformationRecursiveData recursive_data;
-  PreCalculateMetaInformation<LayerImpl>(root_layer, &recursive_data);
+  PreCalculateMetaInformation(root_layer, &recursive_data);
 
   CalculateDrawPropertiesInternal<LayerImpl,
                                   LayerImplList,
                                   RenderSurfaceImpl>(
       root_layer,
       scaled_device_transform,
       identity_matrix,
       identity_matrix,
       root_layer,
       device_viewport_rect,
@@ 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