cc: Move copy requests from layers to the effect tree

cc/trees/layer_tree_impl.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_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 75 matching lines @@
   property_trees()->is_main_thread = false;
 }
 
 LayerTreeImpl::~LayerTreeImpl() {
   BreakSwapPromises(IsActiveTree() ? SwapPromise::SWAP_FAILS
                                    : SwapPromise::ACTIVATION_FAILS);
 
   // Need to explicitly clear the tree prior to destroying this so that
   // the LayerTreeImpl pointer is still valid in the LayerImpl dtor.
   DCHECK(!root_layer_);
-  DCHECK(layers_with_copy_output_request_.empty());
 }
 
 void LayerTreeImpl::Shutdown() {
   if (root_layer_)
     RemoveLayer(root_layer_->id());
   root_layer_ = nullptr;
 }
 
 void LayerTreeImpl::ReleaseResources() {
   if (root_layer_) {
@@ skipping 216 matching lines @@
       DCHECK_EQ(layer->id(), clip_node->owner_id);
       gfx::SizeF bounds = gfx::SizeF(layer->bounds());
       if (clip_node->data.clip.size() != bounds) {
         clip_node->data.clip.set_size(bounds);
         clip_tree->set_needs_update(true);
       }
     }
   }
 }
 
+void LayerTreeImpl::SetPropertyTrees(PropertyTrees* property_trees) {
+  property_trees_ = *property_trees;
+  property_trees->effect_tree.PushCopyRequestsTo(&property_trees_.effect_tree);
+  property_trees_.is_main_thread = false;
+  property_trees_.is_active = IsActiveTree();
+  property_trees_.transform_tree.set_source_to_parent_updates_allowed(false);
+  // The value of some effect node properties (like is_drawn) depends on
+  // whether we are on the active tree or not. So, we need to update the
+  // effect tree.
+  if (IsActiveTree())
+    property_trees_.effect_tree.set_needs_update(true);
+}
+
 void LayerTreeImpl::UpdatePropertyTreesForBoundsDelta() {
   DCHECK(IsActiveTree());
   LayerImpl* inner_container = InnerViewportContainerLayer();
   LayerImpl* outer_container = OuterViewportContainerLayer();
   LayerImpl* inner_scroll = InnerViewportScrollLayer();
 
   UpdateClipTreeForBoundsDeltaOnLayer(inner_container,
                                       &property_trees_.clip_tree);
   UpdateClipTreeForBoundsDeltaOnLayer(InnerViewportScrollLayer(),
                                       &property_trees_.clip_tree);
   UpdateClipTreeForBoundsDeltaOnLayer(outer_container,
                                       &property_trees_.clip_tree);
 
   if (inner_container)
     property_trees_.SetInnerViewportContainerBoundsDelta(
         inner_container->bounds_delta());
   if (outer_container)
     property_trees_.SetOuterViewportContainerBoundsDelta(
         outer_container->bounds_delta());
   if (inner_scroll)
     property_trees_.SetInnerViewportScrollBoundsDelta(
         inner_scroll->bounds_delta());
 }
 
 void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) {
   // The request queue should have been processed and does not require a push.
   DCHECK_EQ(ui_resource_request_queue_.size(), 0u);
 
   LayerImpl* layer = target_tree->CurrentlyScrollingLayer();
-  target_tree->SetPropertyTrees(property_trees_);
+  target_tree->SetPropertyTrees(&property_trees_);
   target_tree->SetCurrentlyScrollingLayer(layer);
   target_tree->UpdatePropertyTreeScrollOffset(&property_trees_);
 
   if (next_activation_forces_redraw_) {
     target_tree->ForceRedrawNextActivation();
     next_activation_forces_redraw_ = false;
   }
 
   target_tree->PassSwapPromises(&swap_promise_list_);
 
@@ skipping 397 matching lines @@
   outer_viewport_scroll_layer_id_ = outer_viewport_scroll_layer_id;
 }
 
 void LayerTreeImpl::ClearViewportLayers() {
   overscroll_elasticity_layer_id_ = Layer::INVALID_ID;
   page_scale_layer_id_ = Layer::INVALID_ID;
   inner_viewport_scroll_layer_id_ = Layer::INVALID_ID;
   outer_viewport_scroll_layer_id_ = Layer::INVALID_ID;
 }
 
-#if DCHECK_IS_ON()
-void SanityCheckCopyRequestCounts(LayerTreeImpl* layer_tree_impl) {
-  EffectTree& effect_tree = layer_tree_impl->property_trees()->effect_tree;
-  const int effect_tree_size = static_cast<int>(effect_tree.size());
-  std::vector<int> copy_requests_count_in_effect_tree(effect_tree_size);
-  for (auto* layer : *layer_tree_impl) {
-    if (layer->HasCopyRequest()) {
-      copy_requests_count_in_effect_tree[layer->effect_tree_index()]++;
-    }
-  }
-  for (int i = effect_tree_size - 1; i >= 0; i--) {
-    EffectNode* node = effect_tree.Node(i);
-    DCHECK_EQ(node->data.num_copy_requests_in_subtree,
-              copy_requests_count_in_effect_tree[i]);
-    if (node->parent_id >= 0)
-      copy_requests_count_in_effect_tree[node->parent_id] +=
-          copy_requests_count_in_effect_tree[i];
-  }
-}
-#endif
-
 bool LayerTreeImpl::UpdateDrawProperties(bool update_lcd_text) {
-#if DCHECK_IS_ON()
-  if (root_layer())
-    SanityCheckCopyRequestCounts(root_layer()->layer_tree_impl());
-#endif
-
   if (!needs_update_draw_properties_)
     return true;
 
   // Calling UpdateDrawProperties must clear this flag, so there can be no
   // early outs before this.
   needs_update_draw_properties_ = false;
 
   // For max_texture_size.  When the renderer is re-created in
   // CreateAndSetRenderer, the needs update draw properties flag is set
   // again.
@@ skipping 664 matching lines @@
   DidUpdateScrollState(layer->id());
 }
 
 void LayerTreeImpl::UnregisterScrollLayer(LayerImpl* layer) {
   if (layer->scroll_clip_layer_id() == Layer::INVALID_ID)
     return;
 
   clip_scroll_map_.erase(layer->scroll_clip_layer_id());
 }
 
-void LayerTreeImpl::AddLayerWithCopyOutputRequest(LayerImpl* layer) {
-  // Only the active tree needs to know about layers with copy requests, as
-  // they are aborted if not serviced during draw.
-  DCHECK(IsActiveTree());
-
-  // DCHECK(std::find(layers_with_copy_output_request_.begin(),
-  //                 layers_with_copy_output_request_.end(),
-  //                 layer) == layers_with_copy_output_request_.end());
-  // TODO(danakj): Remove this once crash is found crbug.com/309777
-  for (size_t i = 0; i < layers_with_copy_output_request_.size(); ++i) {
-    CHECK(layers_with_copy_output_request_[i] != layer)
-        << i << " of " << layers_with_copy_output_request_.size();
-  }
-  layers_with_copy_output_request_.push_back(layer);
-}
-
-void LayerTreeImpl::RemoveLayerWithCopyOutputRequest(LayerImpl* layer) {
-  // Only the active tree needs to know about layers with copy requests, as
-  // they are aborted if not serviced during draw.
-  DCHECK(IsActiveTree());
-
-  std::vector<LayerImpl*>::iterator it =
-      std::find(layers_with_copy_output_request_.begin(),
-                layers_with_copy_output_request_.end(), layer);
-  DCHECK(it != layers_with_copy_output_request_.end());
-  layers_with_copy_output_request_.erase(it);
-
-  // TODO(danakj): Remove this once crash is found crbug.com/309777
-  for (size_t i = 0; i < layers_with_copy_output_request_.size(); ++i) {
-    CHECK(layers_with_copy_output_request_[i] != layer)
-        << i << " of " << layers_with_copy_output_request_.size();
-  }
-}
-
 void LayerTreeImpl::AddSurfaceLayer(LayerImpl* layer) {
   DCHECK(std::find(surface_layers_.begin(), surface_layers_.end(), layer) ==
          surface_layers_.end());
   surface_layers_.push_back(layer);
 }
 
 void LayerTreeImpl::RemoveSurfaceLayer(LayerImpl* layer) {
   std::vector<LayerImpl*>::iterator it =
       std::find(surface_layers_.begin(), surface_layers_.end(), layer);
   DCHECK(it != surface_layers_.end());
   surface_layers_.erase(it);
 }
 
-const std::vector<LayerImpl*>& LayerTreeImpl::LayersWithCopyOutputRequest()
-    const {
-  // Only the active tree needs to know about layers with copy requests, as
-  // they are aborted if not serviced during draw.
-  DCHECK(IsActiveTree());
-
-  return layers_with_copy_output_request_;
-}
-
 template <typename LayerType>
 static inline bool LayerClipsSubtree(LayerType* layer) {
   return layer->masks_to_bounds() || layer->mask_layer();
 }
 
 static bool PointHitsRect(
     const gfx::PointF& screen_space_point,
     const gfx::Transform& local_space_to_screen_space_transform,
     const gfx::Rect& local_space_rect,
     float* distance_to_camera) {
@@ skipping 531 matching lines @@
 }
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   for (auto* layer : *this)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc