cc: Move copy requests from layers to the effect tree

cc/trees/property_tree_builder.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/property_tree_builder.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
+#include "cc/output/copy_output_request.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
 
 class LayerTreeHost;
 
@@ skipping 649 matching lines @@
 }
 
 static inline bool AlwaysUseActiveTreeOpacity(Layer* layer) {
   return layer->AlwaysUseActiveTreeOpacity();
 }
 
 static inline bool AlwaysUseActiveTreeOpacity(LayerImpl* layer) {
   return false;
 }
 
+static inline bool HasCopyRequest(Layer* layer) {
+  return layer->HasCopyRequest();
+}
+
+static inline bool HasCopyRequest(LayerImpl* layer) {
+  return !layer->test_properties()->copy_requests.empty();
+}
+
 template <typename LayerType>
 bool ShouldCreateRenderSurface(LayerType* layer,
                                gfx::Transform current_transform,
                                bool axis_aligned) {
   const bool preserves_2d_axis_alignment =
       (current_transform * layer->transform()).Preserves2dAxisAlignment() &&
       axis_aligned && layer->AnimationsPreserveAxisAlignment();
   const bool is_root = !layer->parent();
   if (is_root)
     return true;
@@ skipping 80 matching lines @@
         "cc", "PropertyTreeBuilder::ShouldCreateRenderSurface isolation",
         TRACE_EVENT_SCOPE_THREAD);
     return true;
   }
 
   // If we force it.
   if (ForceRenderSurface(layer))
     return true;
 
   // If we'll make a copy of the layer's contents.
-  if (layer->HasCopyRequest())
+  if (HasCopyRequest(layer))
     return true;
 
   return false;
 }
 
+static void TakeCopyRequests(
+    Layer* layer,
+    std::vector<std::unique_ptr<CopyOutputRequest>>* copy_requests) {
+  layer->TakeCopyRequests(copy_requests);
+}
+
+static void TakeCopyRequests(
+    LayerImpl* layer,
+    std::vector<std::unique_ptr<CopyOutputRequest>>* copy_requests) {
+  for (auto& request : layer->test_properties()->copy_requests)
+    copy_requests->push_back(std::move(request));
+  layer->test_properties()->copy_requests.clear();
+}
+
 template <typename LayerType>
 bool AddEffectNodeIfNeeded(
     const DataForRecursion<LayerType>& data_from_ancestor,
     LayerType* layer,
     DataForRecursion<LayerType>* data_for_children) {
   const bool is_root = !layer->parent();
   const bool has_transparency = EffectiveOpacity(layer) != 1.f;
   const bool has_potential_opacity_animation =
       HasPotentialOpacityAnimation(layer);
   const bool should_create_render_surface = ShouldCreateRenderSurface(
@@ skipping 18 matching lines @@
 
   EffectNode node;
   node.owner_id = layer->id();
   if (AlwaysUseActiveTreeOpacity(layer)) {
     data_for_children->property_trees->always_use_active_tree_opacity_effect_ids
         .push_back(node.owner_id);
   }
 
   node.data.opacity = layer->opacity();
   node.data.has_render_surface = should_create_render_surface;
-  node.data.has_copy_request = layer->HasCopyRequest();
+  node.data.has_copy_request = HasCopyRequest(layer);
   node.data.has_background_filters = !layer->background_filters().IsEmpty();
   node.data.has_potential_opacity_animation = has_potential_opacity_animation;
   node.data.double_sided = DoubleSided(layer);
   node.data.subtree_hidden = HideLayerAndSubtree(layer);
   node.data.is_currently_animating_opacity = layer->OpacityIsAnimating();
 
   if (!is_root) {
     // The effect node's transform id is used only when we create a render
     // surface. So, we can leave the default value when we don't create a render
     // surface.
@@ skipping 10 matching lines @@
   } else {
     // Root render surface acts the unbounded and untransformed to draw content
     // into. Transform node created from root layer (includes device scale
     // factor) and clip node created from root layer (include viewports) applies
     // to root render surface's content, but not root render surface itself.
     node.data.transform_id = kRootPropertyTreeNodeId;
     node.data.clip_id = kViewportClipTreeNodeId;
   }
   data_for_children->effect_tree_parent =
       data_for_children->property_trees->effect_tree.Insert(node, parent_id);
-  layer->SetEffectTreeIndex(data_for_children->effect_tree_parent);
+  int node_id = data_for_children->effect_tree_parent;
+  layer->SetEffectTreeIndex(node_id);
   data_for_children->property_trees->effect_id_to_index_map[layer->id()] =
       data_for_children->effect_tree_parent;
+
+  std::vector<std::unique_ptr<CopyOutputRequest>> layer_copy_requests;
+  TakeCopyRequests(layer, &layer_copy_requests);
+  for (auto& it : layer_copy_requests) {
+    data_for_children->property_trees->effect_tree.AddCopyRequest(
+        node_id, std::move(it));
+  }
+  layer_copy_requests.clear();
+
   if (should_create_render_surface) {
     data_for_children->compound_transform_since_render_target =
         gfx::Transform();
     data_for_children->axis_align_since_render_target = true;
   }
   return should_create_render_surface;
 }
 
 template <typename LayerType>
 void AddScrollNodeIfNeeded(
@@ skipping 199 matching lines @@
     }
   }
 
   if (layer->has_replica()) {
     DataForRecursionFromChild<LayerType> data_from_child;
     BuildPropertyTreesInternal(layer->replica_layer(), data_for_children,
                                &data_from_child);
     data_to_parent->Merge(data_from_child);
   }
 
-  if (layer->HasCopyRequest())
-    data_to_parent->num_copy_requests_in_subtree++;
+  EffectNode* effect_node = data_for_children.property_trees->effect_tree.Node(
+      data_for_children.effect_tree_parent);
 
-  if (data_for_children.property_trees->effect_tree
-          .Node(data_for_children.effect_tree_parent)
-          ->owner_id == layer->id())
-    data_for_children.property_trees->effect_tree
-        .Node(data_for_children.effect_tree_parent)
-        ->data.num_copy_requests_in_subtree =
+  if (effect_node->owner_id == layer->id()) {
+    if (effect_node->data.has_copy_request)
+      data_to_parent->num_copy_requests_in_subtree++;
+    effect_node->data.num_copy_requests_in_subtree =
         data_to_parent->num_copy_requests_in_subtree;
+  }
 }
 
 }  // namespace
 
 void CC_EXPORT
 PropertyTreeBuilder::PreCalculateMetaInformation(Layer* root_layer) {
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformationInternal(root_layer, &recursive_data);
 }
 
@@ skipping 176 matching lines @@
   if (SkColorGetA(color) != 255)
     color = SkColorSetA(color, 255);
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees, color);
 }
 
 }  // namespace cc