cc : Compute render surface is_clipped outside property tree building

cc/trees/layer_tree_host.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.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 660 matching lines @@
   LayerList update_layer_list;
 
   {
     base::AutoReset<bool> update_property_trees(&in_update_property_trees_,
                                                 true);
     TRACE_EVENT0("cc",
                  "LayerTreeHostInProcess::UpdateLayers::BuildPropertyTrees");
     TRACE_EVENT0(
         TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
         "LayerTreeHostInProcessCommon::ComputeVisibleRectsWithPropertyTrees");
-    PropertyTreeBuilder::PreCalculateMetaInformation(root_layer);
     bool can_render_to_separate_surface = true;
     PropertyTrees* property_trees = &property_trees_;
     if (!settings_.use_layer_lists) {
       // If use_layer_lists is set, then the property trees should have been
       // built by the client already.
       PropertyTreeBuilder::BuildPropertyTrees(
           root_layer, page_scale_layer, inner_viewport_scroll_layer(),
           outer_viewport_scroll_layer(), overscroll_elasticity_layer(),
           elastic_overscroll_, page_scale_factor_, device_scale_factor_,
           gfx::Rect(device_viewport_size_), identity_transform, property_trees);
@@ skipping 371 matching lines @@
 
 std::unordered_set<Layer*>& LayerTreeHost::LayersThatShouldPushProperties() {
   return layers_that_should_push_properties_;
 }
 
 bool LayerTreeHost::LayerNeedsPushPropertiesForTesting(Layer* layer) const {
   return layers_that_should_push_properties_.find(layer) !=
          layers_that_should_push_properties_.end();
 }
 
-void LayerTreeHost::SetNeedsMetaInfoRecomputation(bool needs_recomputation) {
-  needs_meta_info_recomputation_ = needs_recomputation;
-}
-
 void LayerTreeHost::SetPageScaleFromImplSide(float page_scale) {
   DCHECK(CommitRequested());
   page_scale_factor_ = page_scale;
   SetPropertyTreesNeedRebuild();
 }
 
 void LayerTreeHost::SetElasticOverscrollFromImplSide(
     gfx::Vector2dF elastic_overscroll) {
   DCHECK(CommitRequested());
   elastic_overscroll_ = elastic_overscroll;
 }
 
 void LayerTreeHost::UpdateHudLayer(bool show_hud_info) {
   if (show_hud_info) {
     if (!hud_layer_.get()) {
       hud_layer_ = HeadsUpDisplayLayer::Create();
     }
 
     if (root_layer_.get() && !hud_layer_->parent())
       root_layer_->AddChild(hud_layer_);
   } else if (hud_layer_.get()) {
     hud_layer_->RemoveFromParent();
     hud_layer_ = nullptr;
   }
 }
 
 void LayerTreeHost::SetNeedsFullTreeSync() {
   needs_full_tree_sync_ = true;
-  needs_meta_info_recomputation_ = true;
-
   property_trees_.needs_rebuild = true;
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetPropertyTreesNeedRebuild() {
   property_trees_.needs_rebuild = true;
   SetNeedsUpdateLayers();
 }
 
 void LayerTreeHost::PushPropertiesTo(LayerTreeImpl* tree_impl) {
@@ skipping 106 matching lines @@
 
 static void SetElementIdForTesting(Layer* layer) {
   layer->SetElementId(LayerIdToElementIdForTesting(layer->id()));
 }
 
 void LayerTreeHost::SetElementIdsForTesting() {
   LayerTreeHostCommon::CallFunctionForEveryLayer(this, SetElementIdForTesting);
 }
 
 void LayerTreeHost::BuildPropertyTreesForTesting() {
-  PropertyTreeBuilder::PreCalculateMetaInformation(root_layer());
   gfx::Transform identity_transform;
   PropertyTreeBuilder::BuildPropertyTrees(
       root_layer(), page_scale_layer(), inner_viewport_scroll_layer(),
       outer_viewport_scroll_layer(), overscroll_elasticity_layer(),
       elastic_overscroll(), page_scale_factor(), device_scale_factor(),
       gfx::Rect(device_viewport_size()), identity_transform, property_trees());
 }
 
 bool LayerTreeHost::IsElementInList(ElementId element_id,
                                     ElementListType list_type) const {
@@ skipping 182 matching lines @@
 LayerListReverseIterator<Layer> LayerTreeHost::rend() {
   return LayerListReverseIterator<Layer>(nullptr);
 }
 
 void LayerTreeHost::SetNeedsDisplayOnAllLayers() {
   for (auto* layer : *this)
     layer->SetNeedsDisplay();
 }
 
 }  // namespace cc