cc: Consolidate LayerList types.

cc/trees/damage_tracker.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/damage_tracker.h"
 
 #include <algorithm>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 28 matching lines @@
   gfx::RectF expanded_damage_rect = *damage_rect;
   ExpandRectWithFilters(&expanded_damage_rect, filters);
   gfx::RectF filter_rect = pre_filter_rect;
   ExpandRectWithFilters(&filter_rect, filters);
 
   expanded_damage_rect.Intersect(filter_rect);
   damage_rect->Union(expanded_damage_rect);
 }
 
 void DamageTracker::UpdateDamageTrackingState(
-    const std::vector<LayerImpl*>& layer_list,
+    const LayerImplList& layer_list,
     int target_surface_layer_id,
     bool target_surface_property_changed_only_from_descendant,
     gfx::Rect target_surface_content_rect,
     LayerImpl* target_surface_mask_layer,
     const WebKit::WebFilterOperations& filters,
     SkImageFilter* filter) {
   //
   // This function computes the "damage rect" of a target surface, and updates
   // the state that is used to correctly track damage across frames. The damage
   // rect is the region of the surface that may have changed and needs to be
@@ skipping 117 matching lines @@
 
 void DamageTracker::SaveRectForNextFrame(int layer_id,
                                          const gfx::RectF& target_space_rect) {
   // This layer should not yet exist in next frame's history.
   DCHECK_GT(layer_id, 0);
   DCHECK(next_rect_history_->find(layer_id) == next_rect_history_->end());
   (*next_rect_history_)[layer_id] = target_space_rect;
 }
 
 gfx::RectF DamageTracker::TrackDamageFromActiveLayers(
-    const std::vector<LayerImpl*>& layer_list,
+    const LayerImplList& layer_list,
     int target_surface_layer_id) {
   gfx::RectF damage_rect = gfx::RectF();
 
   for (size_t layer_index = 0; layer_index < layer_list.size(); ++layer_index) {
     // Visit layers in back-to-front order.
     LayerImpl* layer = layer_list[layer_index];
 
     if (LayerTreeHostCommon::RenderSurfaceContributesToTarget<LayerImpl>(
             layer, target_surface_layer_id))
       ExtendDamageForRenderSurface(layer, &damage_rect);
@@ skipping 188 matching lines @@
   // one in them. This means we need to redraw any pixels in the surface being
   // used for the blur in this layer this frame.
   if (layer->background_filters().hasFilterThatMovesPixels()) {
     ExpandDamageRectInsideRectWithFilters(target_damage_rect,
                                           surface_rect_in_target_space,
                                           layer->background_filters());
   }
 }
 
 }  // namespace cc