cc: Move copy requests from layers to the effect tree

cc/trees/draw_property_utils.cc

 // Copyright 2014 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/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 35 matching lines @@
   if (layer->has_render_surface())
     return;
 
   DCHECK(layer->filters().IsEmpty()) << "layer: " << layer->id();
   DCHECK(layer->background_filters().IsEmpty()) << "layer: " << layer->id();
   DCHECK(!IsRootLayer(layer)) << "layer: " << layer->id();
   if (EffectNodeOwner(layer)->replica_layer() == layer)
     return;
   DCHECK(!layer->mask_layer()) << "layer: " << layer->id();
   DCHECK(!layer->replica_layer()) << "layer: " << layer->id();
-  DCHECK(!layer->HasCopyRequest()) << "layer: " << layer->id();
 }
 
 #endif
 
 template <typename LayerType>
 void CalculateVisibleRects(
     const typename LayerType::LayerListType& visible_layer_list,
     const ClipTree& clip_tree,
     const TransformTree& transform_tree,
+    const EffectTree& effect_tree,
     bool non_root_surfaces_enabled) {
   for (auto& layer : visible_layer_list) {
     gfx::Size layer_bounds = layer->bounds();
     const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index());
     const bool is_unclipped = clip_node->data.resets_clip &&
                               !clip_node->data.applies_local_clip &&
                               non_root_surfaces_enabled;
     // When both the layer and the target are unclipped, the entire layer
     // content rect is visible.
     const bool fully_visible = !clip_node->data.layers_are_clipped &&
                                !clip_node->data.target_is_clipped &&
                                non_root_surfaces_enabled;
     const TransformNode* transform_node =
         transform_tree.Node(layer->transform_tree_index());
     if (!is_unclipped && !fully_visible) {
       // The entire layer is visible if it has copy requests.
-      if (layer->HasCopyRequest()) {
+      const EffectNode* effect_node =
+          effect_tree.Node(layer->effect_tree_index());
+      if (effect_node->data.has_copy_request &&
+          effect_node->owner_id == layer->id()) {
         layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
         continue;
       }
 
       const TransformNode* target_node =
           non_root_surfaces_enabled
               ? transform_tree.Node(transform_node->data.content_target_id)
               : transform_tree.Node(0);
 
       // The clip node stores clip rect in its target space. If required,
@@ skipping 680 matching lines @@
   ComputeTransforms(&property_trees->transform_tree);
   ComputeClips(&property_trees->clip_tree, property_trees->transform_tree,
                can_render_to_separate_surface);
   ComputeEffects(&property_trees->effect_tree);
 
   FindLayersThatNeedUpdates(
       root_layer->layer_tree_impl(), property_trees->transform_tree,
       property_trees->effect_tree, update_layer_list, visible_layer_list);
   CalculateVisibleRects<LayerImpl>(
       *visible_layer_list, property_trees->clip_tree,
-      property_trees->transform_tree, can_render_to_separate_surface);
+      property_trees->transform_tree, property_trees->effect_tree,
+      can_render_to_separate_surface);
 }
 
 void UpdatePropertyTrees(PropertyTrees* property_trees,
                          bool can_render_to_separate_surface) {
   if (property_trees->non_root_surfaces_enabled !=
       can_render_to_separate_surface) {
     property_trees->non_root_surfaces_enabled = can_render_to_separate_surface;
     property_trees->transform_tree.set_needs_update(true);
   }
   if (property_trees->transform_tree.needs_update()) {
     property_trees->clip_tree.set_needs_update(true);
     property_trees->effect_tree.set_needs_update(true);
   }
   ComputeTransforms(&property_trees->transform_tree);
   ComputeClips(&property_trees->clip_tree, property_trees->transform_tree,
                can_render_to_separate_surface);
   ComputeEffects(&property_trees->effect_tree);
 }
 
 void ComputeVisibleRectsForTesting(PropertyTrees* property_trees,
                                    bool can_render_to_separate_surface,
                                    LayerList* update_layer_list) {
   CalculateVisibleRects<Layer>(*update_layer_list, property_trees->clip_tree,
                                property_trees->transform_tree,
+                               property_trees->effect_tree,
                                can_render_to_separate_surface);
 }
 
 void BuildPropertyTreesAndComputeVisibleRects(
     LayerImpl* root_layer,
     const LayerImpl* page_scale_layer,
     const LayerImpl* inner_viewport_scroll_layer,
     const LayerImpl* outer_viewport_scroll_layer,
     const LayerImpl* overscroll_elasticity_layer,
     const gfx::Vector2dF& elastic_overscroll,
@@ skipping 435 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc