cc: Move RenderTarget Information to 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 92 matching lines @@
         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) {
-  if (!stack_.empty() && stack_.back().target == new_target)
+  DCHECK(new_target->has_render_surface());
+  if (!stack_.empty() && stack_.back().target == new_target->render_surface())
     return;
 
-  const LayerImpl* old_target = NULL;
+  const RenderSurfaceImpl* old_target_surface = NULL;
   const RenderSurfaceImpl* old_occlusion_immune_ancestor = NULL;
   if (!stack_.empty()) {
-    old_target = stack_.back().target;
+    old_target_surface = stack_.back().target;
     old_occlusion_immune_ancestor =
-        old_target->render_surface()->nearest_occlusion_immune_ancestor();
+        old_target_surface->nearest_occlusion_immune_ancestor();
   }
   const RenderSurfaceImpl* new_occlusion_immune_ancestor =
       new_target->render_surface()->nearest_occlusion_immune_ancestor();
 
-  stack_.push_back(StackObject(new_target));
+  stack_.push_back(StackObject(new_target->render_surface()));
 
   // We copy the screen occlusion into the new RenderSurfaceImpl subtree, but we
   // never copy in the occlusion from inside the target, since we are looking
   // at a new RenderSurfaceImpl target.
 
   // If entering an unoccluded subtree, do not carry forward the outside
   // occlusion calculated so far.
   bool entering_unoccluded_subtree =
       new_occlusion_immune_ancestor &&
       new_occlusion_immune_ancestor != old_occlusion_immune_ancestor;
@@ skipping 12 matching lines @@
       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->render_surface()->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));
 }
 
@@ skipping 69 matching lines @@
 
     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) {
   DCHECK(!stack_.empty());
   size_t last_index = stack_.size() - 1;
+  DCHECK(new_target->has_render_surface());
   bool surface_will_be_at_top_after_pop =
-      stack_.size() > 1 && stack_[last_index - 1].target == new_target;
+      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 LayerImpl* old_target = stack_[last_index].target;
-  const RenderSurfaceImpl* old_surface = old_target->render_surface();
+  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_target->has_replica() && !old_target->replica_has_mask()) {
     old_occlusion_from_inside_target_in_new_target.Union(
         TransformSurfaceOpaqueRegion(
             stack_[last_index].occlusion_from_inside_target,
@@ skipping 27 matching lines @@
         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)) {
       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_target;
+    stack_.back().target = new_target->render_surface();
     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();
     }
   }
 
@@ skipping 43 matching lines @@
     return;
 
   DCHECK(layer->visible_layer_rect().Contains(opaque_layer_region.bounds()));
 
   gfx::Transform draw_transform = layer->DrawTransform();
   // TODO(danakj): Find a rect interior to each transformed quad.
   if (!draw_transform.Preserves2dAxisAlignment())
     return;
 
   gfx::Rect clip_rect_in_target = ScreenSpaceClipRectInTargetSurface(
-      layer->render_target()->render_surface(), screen_space_clip_rect_);
+      layer->render_target(), screen_space_clip_rect_);
   if (layer->is_clipped()) {
     clip_rect_in_target.Intersect(layer->clip_rect());
   } else {
-    clip_rect_in_target.Intersect(
-        layer->render_target()->render_surface()->content_rect());
+    clip_rect_in_target.Intersect(layer->render_target()->content_rect());
   }
 
   for (size_t i = 0; i < opaque_layer_region.GetRegionComplexity(); ++i) {
     gfx::Rect transformed_rect =
         MathUtil::MapEnclosedRectWith2dAxisAlignedTransform(
             draw_transform, opaque_layer_region.GetRect(i));
     transformed_rect.Intersect(clip_rect_in_target);
     if (transformed_rect.width() < minimum_tracking_size_.width() &&
         transformed_rect.height() < minimum_tracking_size_.height())
       continue;
     stack_.back().occlusion_from_inside_target.Union(transformed_rect);
   }
 }
 
-Region OcclusionTracker::ComputeVisibleRegionInScreen() const {
-  DCHECK(stack_.back().target->layer_tree_impl()->IsRootLayer(
-      stack_.back().target));
+Region OcclusionTracker::ComputeVisibleRegionInScreen(
+    const LayerTreeImpl* layer_tree) const {
+  DCHECK(layer_tree->root_layer()->render_surface() == 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