cc: Clean up helper function from layer tree host common

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 <stddef.h>
 
 #include <algorithm>
 
@@ skipping 33 matching lines @@
   ExpandRectWithFilters(&expanded_damage_rect, filters);
   gfx::Rect 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 LayerImplList& layer_list,
-    int target_surface_layer_id,
+    const RenderSurfaceImpl* target_surface,
     bool target_surface_property_changed_only_from_descendant,
     const gfx::Rect& target_surface_content_rect,
     LayerImpl* target_surface_mask_layer,
     const FilterOperations& filters) {
   //
   // 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
   // redrawn. This can be used to scissor what is actually drawn, to save GPU
   // computation and bandwidth.
@@ skipping 57 matching lines @@
   //      3. After the damage rect is computed, the leftover not marked regions
   //         in a map are used to compute are damaged by deleted layers and
   //         erased from map.
   //
 
   PrepareRectHistoryForUpdate();
   // These functions cannot be bypassed with early-exits, even if we know what
   // the damage will be for this frame, because we need to update the damage
   // tracker state to correctly track the next frame.
   gfx::Rect damage_from_active_layers =
-      TrackDamageFromActiveLayers(layer_list, target_surface_layer_id);
+      TrackDamageFromActiveLayers(layer_list, target_surface);
   gfx::Rect damage_from_surface_mask =
       TrackDamageFromSurfaceMask(target_surface_mask_layer);
   gfx::Rect damage_from_leftover_rects = TrackDamageFromLeftoverRects();
 
   gfx::Rect damage_rect_for_this_update;
 
   if (target_surface_property_changed_only_from_descendant) {
     damage_rect_for_this_update = target_surface_content_rect;
   } else {
     // TODO(shawnsingh): can we clamp this damage to the surface's content rect?
@@ skipping 22 matching lines @@
   if (it == rect_history_.end() || it->layer_id_ != layer_id) {
     *layer_is_new = true;
     it = rect_history_.insert(it, data);
   }
 
   return *it;
 }
 
 gfx::Rect DamageTracker::TrackDamageFromActiveLayers(
     const LayerImplList& layer_list,
-    int target_surface_layer_id) {
+    const RenderSurfaceImpl* target_surface) {
   gfx::Rect damage_rect;
 
   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];
 
     // We skip damage from the HUD layer because (a) the HUD layer damages the
     // whole frame and (b) we don't want HUD layer damage to be shown by the
     // HUD damage rect visualization.
     if (layer == layer->layer_tree_impl()->hud_layer())
       continue;
-    if (LayerTreeHostCommon::RenderSurfaceContributesToTarget<LayerImpl>(
-            layer, target_surface_layer_id))
+
+    if (layer->render_surface() && layer->render_surface() != target_surface)
       ExtendDamageForRenderSurface(layer, &damage_rect);
     else
       ExtendDamageForLayer(layer, &damage_rect);
   }
 
   return damage_rect;
 }
 
 gfx::Rect DamageTracker::TrackDamageFromSurfaceMask(
     LayerImpl* target_surface_mask_layer) {
@@ skipping 195 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