cc: Move background filters to the effect tree

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 178 matching lines @@
     // 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 (layer->render_surface() && layer->render_surface() != target_surface)
-      ExtendDamageForRenderSurface(layer, &damage_rect);
+      ExtendDamageForRenderSurface(layer->render_surface(), &damage_rect);
     else
       ExtendDamageForLayer(layer, &damage_rect);
   }
 
   return damage_rect;
 }
 
 gfx::Rect DamageTracker::TrackDamageFromSurfaceMask(
     LayerImpl* target_surface_mask_layer) {
   gfx::Rect damage_rect;
@@ skipping 126 matching lines @@
       gfx::UnionRects(layer->update_rect(), layer->damage_rect());
   damage_rect.Intersect(gfx::Rect(layer->bounds()));
   if (!damage_rect.IsEmpty()) {
     gfx::Rect damage_rect_in_target_space =
         MathUtil::MapEnclosingClippedRect(layer->DrawTransform(), damage_rect);
     target_damage_rect->Union(damage_rect_in_target_space);
   }
 }
 
 void DamageTracker::ExtendDamageForRenderSurface(
-    LayerImpl* layer,
+    RenderSurfaceImpl* render_surface,
     gfx::Rect* target_damage_rect) {
   // There are two ways a "descendant surface" can damage regions of the "target
   // surface":
   //   1. Property change:
   //        - a surface's geometry can change because of
   //            - changes to descendants (i.e. the subtree) that affect the
   //              surface's content rect
   //            - changes to ancestor layers that propagate their property
   //              changes to their entire subtree.
   //        - just like layers, both the old surface rect and new surface rect
   //          will damage the target surface in this case.
   //
   //   2. Damage rect: This surface may have been damaged by its own layer_list
   //      as well, and that damage should propagate to the target surface.
   //
 
-  RenderSurfaceImpl* render_surface = layer->render_surface();
-
   bool surface_is_new = false;
-  SurfaceRectMapData& data = RectDataForSurface(layer->id(), &surface_is_new);
+  SurfaceRectMapData& data =
+      RectDataForSurface(render_surface->OwningLayerId(), &surface_is_new);
   gfx::Rect old_surface_rect = data.rect_;
 
   // The drawableContextRect() already includes the replica if it exists.
   gfx::Rect surface_rect_in_target_space =
       gfx::ToEnclosingRect(render_surface->DrawableContentRect());
   data.Update(surface_rect_in_target_space, mailboxId_);
 
   if (surface_is_new || render_surface->SurfacePropertyChanged()) {
     // The entire surface contributes damage.
     target_damage_rect->Union(surface_rect_in_target_space);
@@ skipping 44 matching lines @@
         !replica_mask_layer->update_rect().IsEmpty())
       target_damage_rect->Union(replica_mask_layer_rect);
   }
 
   // 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->background_filters().HasFilterThatMovesPixels()) {
-    ExpandDamageRectInsideRectWithFilters(target_damage_rect,
-                                          surface_rect_in_target_space,
-                                          layer->background_filters());
+  const FilterOperations& background_filters =
+      render_surface->BackgroundFilters();
+  if (background_filters.HasFilterThatMovesPixels()) {
+    ExpandDamageRectInsideRectWithFilters(
+        target_damage_rect, surface_rect_in_target_space, background_filters);
   }
 }
 
 }  // namespace cc