Implement SkImageFilter support in the compositor.

cc/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 "config.h"
 
 #include "CCDamageTracker.h"
 
 #include "CCLayerImpl.h"
 #include "CCLayerTreeHostCommon.h"
@@ skipping 33 matching lines @@
 {
     FloatRect expandedDamageRect = damageRect;
     expandRectWithFilters(expandedDamageRect, filters);
     FloatRect filterRect = preFilterRect;
     expandRectWithFilters(filterRect, filters);
 
     expandedDamageRect.intersect(filterRect);
     damageRect.unite(expandedDamageRect);
 }
 
-void DamageTracker::updateDamageTrackingState(const std::vector<LayerImpl*>& layerList, int targetSurfaceLayerID, bool targetSurfacePropertyChangedOnlyFromDescendant, const IntRect& targetSurfaceContentRect, LayerImpl* targetSurfaceMaskLayer, const WebKit::WebFilterOperations& filters)
+void DamageTracker::updateDamageTrackingState(const std::vector<LayerImpl*>& layerList, int targetSurfaceLayerID, bool targetSurfacePropertyChangedOnlyFromDescendant, const IntRect& targetSurfaceContentRect, LayerImpl* targetSurfaceMaskLayer, 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 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:
     //   - any changes for existing layers/surfaces that contribute to the target surface
@@ skipping 62 matching lines @@
 
     if (m_forceFullDamageNextUpdate || targetSurfacePropertyChangedOnlyFromDescendant) {
         damageRectForThisUpdate = targetSurfaceContentRect;
         m_forceFullDamageNextUpdate = false;
     } else {
         // FIXME: can we clamp this damage to the surface's content rect? (affects performance, but not correctness)
         damageRectForThisUpdate = damageFromActiveLayers;
         damageRectForThisUpdate.uniteIfNonZero(damageFromSurfaceMask);
         damageRectForThisUpdate.uniteIfNonZero(damageFromLeftoverRects);
 
-        if (filters.hasFilterThatMovesPixels())
+        if (filters.hasFilterThatMovesPixels()) {
             expandRectWithFilters(damageRectForThisUpdate, filters);
+        } else if (filter) {
+            // TODO(senorblanco):  Once SkImageFilter reports its outsets, use
+            // those here to limit damage.
+            damageRectForThisUpdate = targetSurfaceContentRect;
+        }
     }
 
     // Damage accumulates until we are notified that we actually did draw on that frame.
     m_currentDamageRect.uniteIfNonZero(damageRectForThisUpdate);
 
     // 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.
     swap(m_currentRectHistory, m_nextRectHistory);
 }
@@ skipping 188 matching lines @@
     // If the layer has a background filter, this may cause pixels in our surface to be expanded, so we will need to expand any damage
     // at or below this layer. We expand the damage from this layer too, as we need to readback those pixels from the surface with only
     // the contents of layers below this 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->backgroundFilters().hasFilterThatMovesPixels())
         expandDamageRectInsideRectWithFilters(targetDamageRect, surfaceRectInTargetSpace, layer->backgroundFilters());
 }
 
 }  // namespace cc