cc: Replace LayerIterator with iterator that walks layer list and 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 38 matching lines @@
 }
 
 const RenderSurfaceImpl*
 OcclusionTracker::OcclusionSurfaceForContributingSurface() const {
   // A contributing surface doesn't get occluded by things inside its own
   // surface, so only things outside the surface can occlude it. That occlusion
   // is found just below the top of the stack (if it exists).
   return (stack_.size() < 2) ? nullptr : stack_[stack_.size() - 2].target;
 }
 
-void OcclusionTracker::EnterLayer(const LayerIteratorPosition& layer_iterator) {
-  LayerImpl* render_target = layer_iterator.target_render_surface_layer;
+void OcclusionTracker::EnterLayer(
+    const EffectTreeLayerListIterator::Position& iterator) {
+  RenderSurfaceImpl* render_target = iterator.target_render_surface;
 
-  if (layer_iterator.represents_itself)
+  if (iterator.state == EffectTreeLayerListIterator::State::LAYER)
     EnterRenderTarget(render_target);
-  else if (layer_iterator.represents_target_render_surface)
+  else if (iterator.state == EffectTreeLayerListIterator::State::TARGET_SURFACE)
     FinishedRenderTarget(render_target);
 }
 
-void OcclusionTracker::LeaveLayer(const LayerIteratorPosition& layer_iterator) {
-  LayerImpl* render_target = layer_iterator.target_render_surface_layer;
+void OcclusionTracker::LeaveLayer(
+    const EffectTreeLayerListIterator::Position& iterator) {
+  RenderSurfaceImpl* render_target = iterator.target_render_surface;
 
-  if (layer_iterator.represents_itself)
-    MarkOccludedBehindLayer(layer_iterator.current_layer);
+  if (iterator.state == EffectTreeLayerListIterator::State::LAYER)
+    MarkOccludedBehindLayer(iterator.current_layer);
   // TODO(danakj): This should be done when entering the contributing surface,
   // but in a way that the surface's own occlusion won't occlude itself.
-  else if (layer_iterator.represents_contributing_render_surface)
+  else if (iterator.state ==
+           EffectTreeLayerListIterator::State::CONTRIBUTING_SURFACE)
     LeaveToRenderTarget(render_target);
 }
 
 static gfx::Rect ScreenSpaceClipRectInTargetSurface(
     const RenderSurfaceImpl* target_surface,
     const gfx::Rect& screen_space_clip_rect) {
   gfx::Transform inverse_screen_space_transform(
       gfx::Transform::kSkipInitialization);
   if (!target_surface->screen_space_transform().GetInverse(
           &inverse_screen_space_transform))
@@ skipping 24 matching lines @@
     gfx::Rect transformed_rect =
         MathUtil::MapEnclosedRectWith2dAxisAlignedTransform(transform,
                                                             region.GetRect(i));
     if (have_clip_rect)
       transformed_rect.Intersect(clip_rect_in_new_target);
     transformed_region.Union(transformed_rect);
   }
   return transformed_region;
 }
 
-void OcclusionTracker::EnterRenderTarget(const LayerImpl* new_target) {
-  DCHECK(new_target->GetRenderSurface());
-  RenderSurfaceImpl* new_target_surface = new_target->GetRenderSurface();
+void OcclusionTracker::EnterRenderTarget(
+    const RenderSurfaceImpl* new_target_surface) {
+  DCHECK(new_target_surface);
   if (!stack_.empty() && stack_.back().target == new_target_surface)
     return;
 
   const RenderSurfaceImpl* old_target_surface = NULL;
   const RenderSurfaceImpl* old_occlusion_immune_ancestor = NULL;
   if (!stack_.empty()) {
     old_target_surface = stack_.back().target;
     old_occlusion_immune_ancestor =
         old_target_surface->nearest_occlusion_immune_ancestor();
   }
@@ skipping 13 matching lines @@
       new_occlusion_immune_ancestor != old_occlusion_immune_ancestor;
 
   gfx::Transform inverse_new_target_screen_space_transform(
       // Note carefully, not used if screen space transform is uninvertible.
       gfx::Transform::kSkipInitialization);
   bool have_transform_from_screen_to_new_target =
       new_target_surface->screen_space_transform().GetInverse(
           &inverse_new_target_screen_space_transform);
 
   bool entering_root_target =
-      new_target->layer_tree_impl()->IsRootLayer(new_target);
+      new_target_surface->render_target() == new_target_surface;
 
   bool copy_outside_occlusion_forward =
       stack_.size() > 1 &&
       !entering_unoccluded_subtree &&
       have_transform_from_screen_to_new_target &&
       !entering_root_target;
   if (!copy_outside_occlusion_forward)
     return;
 
   size_t last_index = stack_.size() - 1;
   gfx::Transform old_target_to_new_target_transform(
       inverse_new_target_screen_space_transform,
       old_target_surface->screen_space_transform());
   stack_[last_index].occlusion_from_outside_target =
       TransformSurfaceOpaqueRegion(
           stack_[last_index - 1].occlusion_from_outside_target, false,
           gfx::Rect(), old_target_to_new_target_transform);
   stack_[last_index].occlusion_from_outside_target.Union(
       TransformSurfaceOpaqueRegion(
           stack_[last_index - 1].occlusion_from_inside_target, false,
           gfx::Rect(), old_target_to_new_target_transform));
 }
 
-void OcclusionTracker::FinishedRenderTarget(const LayerImpl* finished_target) {
+void OcclusionTracker::FinishedRenderTarget(
+    const RenderSurfaceImpl* finished_target_surface) {
   // Make sure we know about the target surface.
-  EnterRenderTarget(finished_target);
+  EnterRenderTarget(finished_target_surface);
 
-  RenderSurfaceImpl* surface = finished_target->GetRenderSurface();
+  bool is_hidden =
+      finished_target_surface->OwningEffectNode()->screen_space_opacity == 0.f;
 
   // Readbacks always happen on render targets so we only need to check
   // for readbacks here.
   bool target_is_only_for_copy_request =
-      surface->HasCopyRequest() && finished_target->IsHidden();
+      finished_target_surface->HasCopyRequest() && is_hidden;
 
   // If the occlusion within the surface can not be applied to things outside of
   // the surface's subtree, then clear the occlusion here so it won't be used.
-  if (surface->MaskLayer() || surface->draw_opacity() < 1 ||
-      !surface->UsesDefaultBlendMode() || target_is_only_for_copy_request ||
-      surface->Filters().HasFilterThatAffectsOpacity()) {
+  if (finished_target_surface->HasMask() ||
+      finished_target_surface->draw_opacity() < 1 ||
+      !finished_target_surface->UsesDefaultBlendMode() ||
+      target_is_only_for_copy_request ||
+      finished_target_surface->Filters().HasFilterThatAffectsOpacity()) {
     stack_.back().occlusion_from_outside_target.Clear();
     stack_.back().occlusion_from_inside_target.Clear();
   }
 }
 
 static void ReduceOcclusionBelowSurface(
     const RenderSurfaceImpl* contributing_surface,
     const gfx::Rect& surface_rect,
     const gfx::Transform& surface_transform,
     SimpleEnclosedRegion* occlusion_from_inside_target) {
@@ skipping 39 matching lines @@
     int shrink_bottom =
         occlusion_rect.bottom() == affected_area_in_target.bottom() ?
         0 : outset_top;
 
     occlusion_rect.Inset(shrink_left, shrink_top, shrink_right, shrink_bottom);
 
     occlusion_from_inside_target->Union(occlusion_rect);
   }
 }
 
-void OcclusionTracker::LeaveToRenderTarget(const LayerImpl* new_target) {
+void OcclusionTracker::LeaveToRenderTarget(
+    const RenderSurfaceImpl* new_target_surface) {
   DCHECK(!stack_.empty());
   size_t last_index = stack_.size() - 1;
-  DCHECK(new_target->GetRenderSurface());
-  RenderSurfaceImpl* new_surface = new_target->GetRenderSurface();
+  DCHECK(new_target_surface);
   bool surface_will_be_at_top_after_pop =
-      stack_.size() > 1 && stack_[last_index - 1].target == new_surface;
+      stack_.size() > 1 && stack_[last_index - 1].target == new_target_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;
 
   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());
 
   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;
   if (old_surface->BackgroundFilters().HasFilterThatMovesPixels()) {
     Occlusion surface_occlusion = GetCurrentOcclusionForContributingSurface(
         old_surface->draw_transform());
     unoccluded_surface_rect =
         surface_occlusion.GetUnoccludedContentRect(old_surface->content_rect());
   }
 
+  bool is_root = new_target_surface->render_target() == new_target_surface;
   if (surface_will_be_at_top_after_pop) {
     // Merge the top of the stack down.
     stack_[last_index - 1].occlusion_from_inside_target.Union(
         old_occlusion_from_inside_target_in_new_target);
     // TODO(danakj): Strictly this should subtract the inside target occlusion
     // before union.
-    if (!new_target->layer_tree_impl()->IsRootLayer(new_target)) {
+    if (!is_root) {
       stack_[last_index - 1].occlusion_from_outside_target.Union(
           old_occlusion_from_outside_target_in_new_target);
     }
     stack_.pop_back();
   } else {
     // Replace the top of the stack with the new pushed surface.
-    stack_.back().target = new_surface;
+    stack_.back().target = new_target_surface;
     stack_.back().occlusion_from_inside_target =
         old_occlusion_from_inside_target_in_new_target;
-    if (!new_target->layer_tree_impl()->IsRootLayer(new_target)) {
+    if (!is_root) {
       stack_.back().occlusion_from_outside_target =
           old_occlusion_from_outside_target_in_new_target;
     } else {
       stack_.back().occlusion_from_outside_target.Clear();
     }
   }
 
   if (!old_surface->BackgroundFilters().HasFilterThatMovesPixels())
     return;
 
@@ skipping 55 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