Add support for converting cc::FilterOperations into an SkImageFilter

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/heads_up_display_layer_impl.h"
@@ skipping 34 matching lines @@
   expanded_damage_rect.Intersect(filter_rect);
   damage_rect->Union(expanded_damage_rect);
 }
 
 void DamageTracker::UpdateDamageTrackingState(
     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 FilterOperations& filters,
-    SkImageFilter* filter) {
+    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.
   //
   // The surface's damage rect is computed as the union of all possible changes
   // that have happened to the surface since the last frame was drawn. This
   // includes:
@@ skipping 69 matching lines @@
 
   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);
 
-    if (filters.HasFilterThatMovesPixels()) {
-      ExpandRectWithFilters(&damage_rect_for_this_update, filters);
-    } else if (filter) {
+    if (filters.HasReferenceFilter()) {
       // TODO(senorblanco):  Once SkImageFilter reports its outsets, use
       // those here to limit damage.
       damage_rect_for_this_update = target_surface_content_rect;
+    } else if (filters.HasFilterThatMovesPixels()) {
+      ExpandRectWithFilters(&damage_rect_for_this_update, filters);
     }
   }
 
   // Damage accumulates until we are notified that we actually did draw on that
   // frame.
   current_damage_rect_.Union(damage_rect_for_this_update);
 
   // The next history map becomes the current map for the next frame. Note this
   // must happen every frame to correctly track changes, even if damage
   // accumulates over multiple frames before actually being drawn.
@@ skipping 229 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