cc: Move DamageTracker filter handling to MapRect.

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 11 matching lines @@
 
 std::unique_ptr<DamageTracker> DamageTracker::Create() {
   return base::WrapUnique(new DamageTracker());
 }
 
 DamageTracker::DamageTracker()
   : mailboxId_(0) {}
 
 DamageTracker::~DamageTracker() {}
 
-static inline void ExpandRectWithFilters(gfx::Rect* rect,
-                                         const FilterOperations& filters) {
-  int top, right, bottom, left;
-  filters.GetOutsets(&top, &right, &bottom, &left);
-  rect->Inset(-left, -top, -right, -bottom);
-}
-
 static inline void ExpandDamageRectInsideRectWithFilters(
     gfx::Rect* damage_rect,
     const gfx::Rect& pre_filter_rect,
     const FilterOperations& filters) {
-  gfx::Rect expanded_damage_rect = *damage_rect;
-  ExpandRectWithFilters(&expanded_damage_rect, filters);
-  gfx::Rect filter_rect = pre_filter_rect;
-  ExpandRectWithFilters(&filter_rect, filters);
+  // Compute the pixels in the background of the surface that could be affected
+  // by the damage in the content below.
+  gfx::Rect expanded_damage_rect = filters.MapRect(*damage_rect, SkMatrix::I());
 
-  expanded_damage_rect.Intersect(filter_rect);
+  // Restrict it to the rectangle in which the background filter is shown.
+  expanded_damage_rect.Intersect(pre_filter_rect);
+
   damage_rect->Union(expanded_damage_rect);
 }
 
 void DamageTracker::UpdateDamageTrackingState(
     const LayerImplList& layer_list,
     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) {
@@ skipping 78 matching lines @@
   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?
     // (affects performance, but not correctness)
     damage_rect_for_this_update = damage_from_active_layers;
     damage_rect_for_this_update.Union(damage_from_surface_mask);
     damage_rect_for_this_update.Union(damage_from_leftover_rects);
-
-    ExpandRectWithFilters(&damage_rect_for_this_update, filters);
+    damage_rect_for_this_update =
+        filters.MapRect(damage_rect_for_this_update, SkMatrix::I());
   }
 
   // Damage accumulates until we are notified that we actually did draw on that
   // frame.
   current_damage_rect_.Union(damage_rect_for_this_update);
 }
 
 DamageTracker::LayerRectMapData& DamageTracker::RectDataForLayer(
     int layer_id,
     bool* layer_is_new) {
@@ skipping 276 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