Do not clip inside OcclusionTracker: Contributing Surfaces Edition.

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 <algorithm>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
@@ skipping 317 matching lines @@
       TransformSurfaceOpaqueRegion<typename LayerType::RenderSurfaceType>(
           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()) {
     unoccluded_surface_rect = UnoccludedContributingSurfaceContentRect(
-        old_target, false, old_surface->content_rect());
+        old_target, old_surface->content_rect(), old_surface->draw_transform());
     if (old_target->has_replica()) {
       unoccluded_replica_rect = UnoccludedContributingSurfaceContentRect(
-          old_target, true, old_surface->content_rect());
+          old_target,
+          old_surface->content_rect(),
+          old_surface->replica_draw_transform());
     }
   }
 
   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->parent()) {
@@ skipping 232 matching lines @@
   gfx::Rect unoccluded_rect = MathUtil::ProjectEnclosingClippedRect(
       inverse_draw_transform, unoccluded_rect_in_target_surface);
   unoccluded_rect.Intersect(content_rect);
 
   return unoccluded_rect;
 }
 
 template <typename LayerType>
 gfx::Rect OcclusionTracker<LayerType>::UnoccludedContributingSurfaceContentRect(
     const LayerType* layer,
-    bool for_replica,
-    const gfx::Rect& content_rect) const {
+    const gfx::Rect& content_rect,
+    const gfx::Transform& draw_transform) const {
   DCHECK(!stack_.empty());
   // The layer is a contributing render_target so it should have a surface.
   DCHECK(layer->render_surface());
   // The layer is a contributing render_target so its target should be itself.
   DCHECK_EQ(layer->render_target(), layer);
   // The layer should not be the root, else what is is contributing to?
   DCHECK(layer->parent());
   // This should be called while the layer is still considered the current
   // target in the occlusion tracker.
   DCHECK_EQ(layer, stack_.back().target);
 
   if (content_rect.IsEmpty())
     return content_rect;
 
-  const typename LayerType::RenderSurfaceType* surface =
-      layer->render_surface();
-  const LayerType* contributing_surface_render_target =
-      layer->parent()->render_target();
-
-  if (!SurfaceTransformsToTargetKnown(surface))
-    return content_rect;
-
-  gfx::Transform draw_transform =
-      for_replica ? surface->replica_draw_transform()
-                  : surface->draw_transform();
-  gfx::Transform inverse_draw_transform(gfx::Transform::kSkipInitialization);
-  if (!draw_transform.GetInverse(&inverse_draw_transform))
-    return content_rect;
-
   // 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).
   bool has_occlusion = stack_.size() > 1;
+  if (!has_occlusion)
+    return content_rect;
+
+  const StackObject& second_last = stack_[stack_.size() - 2];
+
+  if (second_last.occlusion_from_inside_target.IsEmpty() &&
+      second_last.occlusion_from_outside_target.IsEmpty())
+    return content_rect;
+
+  gfx::Transform inverse_draw_transform(gfx::Transform::kSkipInitialization);
+  if (!draw_transform.GetInverse(&inverse_draw_transform))
+    return content_rect;
 
   // Take the ToEnclosingRect at each step, as we want to contain any unoccluded
   // partial pixels in the resulting Rect.
   Region unoccluded_region_in_target_surface =
       MathUtil::MapEnclosingClippedRect(draw_transform, content_rect);
-  // Layers can't clip across surfaces, so count this as internal occlusion.
-  if (surface->is_clipped())
-    unoccluded_region_in_target_surface.Intersect(surface->clip_rect());
-  if (has_occlusion) {
-    const StackObject& second_last = stack_[stack_.size() - 2];
-    unoccluded_region_in_target_surface.Subtract(
-        second_last.occlusion_from_inside_target);
-    unoccluded_region_in_target_surface.Subtract(
-        second_last.occlusion_from_outside_target);
-  }
-
-  // Treat other clipping as occlusion from outside the target surface.
-  unoccluded_region_in_target_surface.Intersect(
-      contributing_surface_render_target->render_surface()->content_rect());
-  unoccluded_region_in_target_surface.Intersect(
-      ScreenSpaceClipRectInTargetSurface(
-          contributing_surface_render_target->render_surface(),
-          screen_space_clip_rect_));
+  unoccluded_region_in_target_surface.Subtract(
+      second_last.occlusion_from_inside_target);
+  unoccluded_region_in_target_surface.Subtract(
+      second_last.occlusion_from_outside_target);
 
   gfx::Rect unoccluded_rect_in_target_surface =
       unoccluded_region_in_target_surface.bounds();
   gfx::Rect unoccluded_rect = MathUtil::ProjectEnclosingClippedRect(
       inverse_draw_transform, unoccluded_rect_in_target_surface);
   unoccluded_rect.Intersect(content_rect);
 
   return unoccluded_rect;
 }
 
 // Instantiate (and export) templates here for the linker.
 template class OcclusionTracker<Layer>;
 template class OcclusionTracker<LayerImpl>;
 
 }  // namespace cc