cc: Remove dead code in ComputeVisibleRects

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 295 matching lines @@
         IsLayerBackFaceVisible(layer, backface_transform_id, tree))
       return false;
   }
 
   return true;
 }
 
 void FindLayersThatNeedUpdates(LayerTreeImpl* layer_tree_impl,
                                const TransformTree& transform_tree,
                                const EffectTree& effect_tree,
-                               LayerImplList* update_layer_list,
                                std::vector<LayerImpl*>* visible_layer_list) {
   for (auto* layer_impl : *layer_tree_impl) {
     bool layer_is_drawn =
         effect_tree.Node(layer_impl->effect_tree_index())->data.is_drawn;
 
     if (!IsRootLayer(layer_impl) &&
         LayerShouldBeSkipped(layer_impl, layer_is_drawn, transform_tree,
                              effect_tree))
       continue;
 
-    if (LayerNeedsUpdate(layer_impl, layer_is_drawn, transform_tree)) {
+    if (LayerNeedsUpdate(layer_impl, layer_is_drawn, transform_tree))
       visible_layer_list->push_back(layer_impl);
-      update_layer_list->push_back(layer_impl);
-    }
-
-    if (LayerImpl* mask_layer = layer_impl->mask_layer())
-      update_layer_list->push_back(mask_layer);
-    if (LayerImpl* replica_layer = layer_impl->replica_layer()) {
-      if (LayerImpl* mask_layer = replica_layer->mask_layer())
-        update_layer_list->push_back(mask_layer);
-    }
   }
 }
 
 void UpdateRenderSurfaceForLayer(EffectTree* effect_tree,
                                  bool non_root_surfaces_enabled,
                                  LayerImpl* layer) {
   if (!non_root_surfaces_enabled) {
     layer->SetHasRenderSurface(IsRootLayer(layer));
     return;
   }
@@ skipping 405 matching lines @@
         << gfx::ToEnclosingRect(clip_tree->Node(layer->clip_tree_index())
                                     ->data.clip_in_target_space)
                .ToString();
   }
 }
 
 static void ComputeVisibleRectsInternal(
     LayerImpl* root_layer,
     PropertyTrees* property_trees,
     bool can_render_to_separate_surface,
-    LayerImplList* update_layer_list,
     std::vector<LayerImpl*>* visible_layer_list) {
   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);
   }
   UpdateRenderTarget(&property_trees->effect_tree,
                      property_trees->non_root_surfaces_enabled);
   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);
+  FindLayersThatNeedUpdates(root_layer->layer_tree_impl(),
+                            property_trees->transform_tree,
+                            property_trees->effect_tree, visible_layer_list);
   CalculateVisibleRects<LayerImpl>(
       *visible_layer_list, property_trees->clip_tree,
       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) {
@@ skipping 60 matching lines @@
                                 can_render_to_separate_surface, layer);
     EffectNode* node =
         property_trees->effect_tree.Node(layer->effect_tree_index());
     if (node->owner_id == layer->id())
       node->data.render_surface = layer->render_surface();
 #if DCHECK_IS_ON()
     if (can_render_to_separate_surface)
       ValidateRenderSurfaceForLayer(layer);
 #endif
   }
-  LayerImplList update_layer_list;
   ComputeVisibleRectsInternal(root_layer, property_trees,
                               can_render_to_separate_surface,
-                              &update_layer_list, visible_layer_list);
+                              visible_layer_list);
 }
 
 bool LayerNeedsUpdate(Layer* layer,
                       bool layer_is_drawn,
                       const TransformTree& tree) {
   return LayerNeedsUpdateInternal(layer, layer_is_drawn, tree);
 }
 
 bool LayerNeedsUpdate(LayerImpl* layer,
                       bool layer_is_drawn,
@@ skipping 380 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