cc: Move background filters to the effect tree

cc/trees/occlusion_tracker.cc

 // Copyright 2012 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/occlusion_tracker.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 173 matching lines @@
   if (surface->MaskLayer() || surface->draw_opacity() < 1 ||
       !finished_target->uses_default_blend_mode() ||
       target_is_only_for_copy_request ||
       finished_target->filters().HasFilterThatAffectsOpacity()) {
     stack_.back().occlusion_from_outside_target.Clear();
     stack_.back().occlusion_from_inside_target.Clear();
   }
 }
 
 static void ReduceOcclusionBelowSurface(
-    const LayerImpl* contributing_layer,
+    const RenderSurfaceImpl* contributing_surface,
     const gfx::Rect& surface_rect,
     const gfx::Transform& surface_transform,
-    const LayerImpl* render_target,
     SimpleEnclosedRegion* occlusion_from_inside_target) {
   if (surface_rect.IsEmpty())
     return;
 
   gfx::Rect affected_area_in_target =
       MathUtil::MapEnclosingClippedRect(surface_transform, surface_rect);
-  if (contributing_layer->render_surface()->is_clipped()) {
-    affected_area_in_target.Intersect(
-        contributing_layer->render_surface()->clip_rect());
+  if (contributing_surface->is_clipped()) {
+    affected_area_in_target.Intersect(contributing_surface->clip_rect());
   }
   if (affected_area_in_target.IsEmpty())
     return;
 
   int outset_top, outset_right, outset_bottom, outset_left;
-  contributing_layer->background_filters().GetOutsets(
+  contributing_surface->BackgroundFilters().GetOutsets(
       &outset_top, &outset_right, &outset_bottom, &outset_left);
 
   // The filter can move pixels from outside of the clip, so allow affected_area
   // to expand outside the clip.
   affected_area_in_target.Inset(
       -outset_left, -outset_top, -outset_right, -outset_bottom);
   SimpleEnclosedRegion affected_occlusion = *occlusion_from_inside_target;
   affected_occlusion.Intersect(affected_area_in_target);
 
   occlusion_from_inside_target->Subtract(affected_area_in_target);
@@ skipping 27 matching lines @@
   DCHECK(new_target->has_render_surface());
   bool surface_will_be_at_top_after_pop =
       stack_.size() > 1 &&
       stack_[last_index - 1].target == new_target->render_surface();
 
   // We merge the screen occlusion from the current RenderSurfaceImpl subtree
   // out to its parent target RenderSurfaceImpl. The target occlusion can be
   // merged out as well but needs to be transformed to the new target.
 
   const RenderSurfaceImpl* old_surface = stack_[last_index].target;
-  const LayerImpl* old_target =
-      new_target->layer_tree_impl()->LayerById(old_surface->OwningLayerId());
 
   SimpleEnclosedRegion old_occlusion_from_inside_target_in_new_target =
       TransformSurfaceOpaqueRegion(
           stack_[last_index].occlusion_from_inside_target,
           old_surface->is_clipped(), old_surface->clip_rect(),
           old_surface->draw_transform());
   if (old_surface->HasReplica() && !old_surface->HasReplicaMask()) {
     old_occlusion_from_inside_target_in_new_target.Union(
         TransformSurfaceOpaqueRegion(
             stack_[last_index].occlusion_from_inside_target,
             old_surface->is_clipped(), old_surface->clip_rect(),
             old_surface->replica_draw_transform()));
   }
 
   SimpleEnclosedRegion old_occlusion_from_outside_target_in_new_target =
       TransformSurfaceOpaqueRegion(
           stack_[last_index].occlusion_from_outside_target, false, gfx::Rect(),
           old_surface->draw_transform());
 
   gfx::Rect unoccluded_surface_rect;
   gfx::Rect unoccluded_replica_rect;
-  if (old_target->background_filters().HasFilterThatMovesPixels()) {
+  if (old_surface->BackgroundFilters().HasFilterThatMovesPixels()) {
     Occlusion surface_occlusion = GetCurrentOcclusionForContributingSurface(
         old_surface->draw_transform());
     unoccluded_surface_rect =
         surface_occlusion.GetUnoccludedContentRect(old_surface->content_rect());
     if (old_surface->HasReplica()) {
       Occlusion replica_occlusion = GetCurrentOcclusionForContributingSurface(
           old_surface->replica_draw_transform());
       unoccluded_replica_rect = replica_occlusion.GetUnoccludedContentRect(
           old_surface->content_rect());
     }
@@ skipping 16 matching lines @@
     stack_.back().occlusion_from_inside_target =
         old_occlusion_from_inside_target_in_new_target;
     if (!new_target->layer_tree_impl()->IsRootLayer(new_target)) {
       stack_.back().occlusion_from_outside_target =
           old_occlusion_from_outside_target_in_new_target;
     } else {
       stack_.back().occlusion_from_outside_target.Clear();
     }
   }
 
-  if (!old_target->background_filters().HasFilterThatMovesPixels())
+  if (!old_surface->BackgroundFilters().HasFilterThatMovesPixels())
     return;
 
-  ReduceOcclusionBelowSurface(old_target,
-                              unoccluded_surface_rect,
+  ReduceOcclusionBelowSurface(old_surface, unoccluded_surface_rect,
                               old_surface->draw_transform(),
-                              new_target,
                               &stack_.back().occlusion_from_inside_target);
-  ReduceOcclusionBelowSurface(old_target,
-                              unoccluded_surface_rect,
+  ReduceOcclusionBelowSurface(old_surface, unoccluded_surface_rect,
                               old_surface->draw_transform(),
-                              new_target,
                               &stack_.back().occlusion_from_outside_target);
 
   if (!old_surface->HasReplica())
     return;
-  ReduceOcclusionBelowSurface(old_target,
-                              unoccluded_replica_rect,
+  ReduceOcclusionBelowSurface(old_surface, unoccluded_replica_rect,
                               old_surface->replica_draw_transform(),
-                              new_target,
                               &stack_.back().occlusion_from_inside_target);
-  ReduceOcclusionBelowSurface(old_target,
-                              unoccluded_replica_rect,
+  ReduceOcclusionBelowSurface(old_surface, unoccluded_replica_rect,
                               old_surface->replica_draw_transform(),
-                              new_target,
                               &stack_.back().occlusion_from_outside_target);
 }
 
 void OcclusionTracker::MarkOccludedBehindLayer(const LayerImpl* layer) {
   DCHECK(!stack_.empty());
   DCHECK_EQ(layer->render_target(), stack_.back().target);
 
   if (layer->draw_opacity() < 1)
     return;
 
@@ skipping 39 matching lines @@
   DCHECK(layer_tree->RootRenderSurface() == stack_.back().target);
   const SimpleEnclosedRegion& occluded =
       stack_.back().occlusion_from_inside_target;
   Region visible_region(screen_space_clip_rect_);
   for (size_t i = 0; i < occluded.GetRegionComplexity(); ++i)
     visible_region.Subtract(occluded.GetRect(i));
   return visible_region;
 }
 
 }  // namespace cc