Do not clip inside OcclusionTracker.

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/debug/overdraw_metrics.h"
@@ skipping 490 matching lines @@
         gfx::ToEnclosedRect(screen_space_quad.BoundingBox());
     non_occluding_screen_space_rects_->push_back(screen_space_rect);
   }
 }
 
 template <typename LayerType, typename RenderSurfaceType>
 bool OcclusionTrackerBase<LayerType, RenderSurfaceType>::Occluded(
     const LayerType* render_target,
     gfx::Rect content_rect,
     const gfx::Transform& draw_transform,
-    bool impl_draw_transform_is_unknown,
-    bool is_clipped,
-    gfx::Rect clip_rect_in_target) const {
+    bool impl_draw_transform_is_unknown) const {
   if (prevent_occlusion_)
     return false;
 
   DCHECK(!stack_.empty());
   if (stack_.empty())
     return false;
   if (content_rect.IsEmpty())
     return true;
   if (impl_draw_transform_is_unknown)
     return false;
 
   // For tests with no render target.
   if (!render_target)
     return false;
 
   DCHECK_EQ(render_target->render_target(), render_target);
   DCHECK(render_target->render_surface());
   DCHECK_EQ(render_target, stack_.back().target);
 
+  if (stack_.back().occlusion_from_inside_target.IsEmpty() &&
+      stack_.back().occlusion_from_outside_target.IsEmpty()) {
+    return false;
+  }
+
   gfx::Transform inverse_draw_transform(gfx::Transform::kSkipInitialization);
   if (!draw_transform.GetInverse(&inverse_draw_transform))
     return false;
 
   // 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 = gfx::ToEnclosingRect(
       MathUtil::MapClippedRect(draw_transform, gfx::RectF(content_rect)));
-  // Layers can't clip across surfaces, so count this as internal occlusion.
-  if (is_clipped)
-    unoccluded_region_in_target_surface.Intersect(clip_rect_in_target);
   unoccluded_region_in_target_surface.Subtract(
       stack_.back().occlusion_from_inside_target);
   gfx::RectF unoccluded_rect_in_target_surface_without_outside_occlusion =
       unoccluded_region_in_target_surface.bounds();
   unoccluded_region_in_target_surface.Subtract(
       stack_.back().occlusion_from_outside_target);
 
-  // Treat other clipping as occlusion from outside the surface.
-  // TODO(danakj): Clip to visibleContentRect?
-  unoccluded_region_in_target_surface.Intersect(
-      render_target->render_surface()->content_rect());
-  unoccluded_region_in_target_surface.Intersect(
-      ScreenSpaceClipRectInTargetSurface(render_target->render_surface(),
-                                         screen_space_clip_rect_));
-
   gfx::RectF unoccluded_rect_in_target_surface =
       unoccluded_region_in_target_surface.bounds();
 
   return unoccluded_rect_in_target_surface.IsEmpty();
 }
 
 template <typename LayerType, typename RenderSurfaceType>
 gfx::Rect OcclusionTrackerBase<LayerType, RenderSurfaceType>::
     UnoccludedContentRect(
         const LayerType* render_target,
         gfx::Rect content_rect,
         const gfx::Transform& draw_transform,
-        bool impl_draw_transform_is_unknown,
-        bool is_clipped,
-        gfx::Rect clip_rect_in_target) const {
+        bool impl_draw_transform_is_unknown) const {
   if (prevent_occlusion_)
     return content_rect;
 
   DCHECK(!stack_.empty());
   if (stack_.empty())
     return content_rect;
   if (content_rect.IsEmpty())
     return content_rect;
   if (impl_draw_transform_is_unknown)
     return content_rect;
 
   // For tests with no render target.
   if (!render_target)
     return content_rect;
 
   DCHECK_EQ(render_target->render_target(), render_target);
   DCHECK(render_target->render_surface());
   DCHECK_EQ(render_target, stack_.back().target);
 
+  if (stack_.back().occlusion_from_inside_target.IsEmpty() &&
+      stack_.back().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 = gfx::ToEnclosingRect(
       MathUtil::MapClippedRect(draw_transform, gfx::RectF(content_rect)));
-  // Layers can't clip across surfaces, so count this as internal occlusion.
-  if (is_clipped)
-    unoccluded_region_in_target_surface.Intersect(clip_rect_in_target);
   unoccluded_region_in_target_surface.Subtract(
       stack_.back().occlusion_from_inside_target);
   gfx::RectF unoccluded_rect_in_target_surface_without_outside_occlusion =
       unoccluded_region_in_target_surface.bounds();
   unoccluded_region_in_target_surface.Subtract(
       stack_.back().occlusion_from_outside_target);
 
-  // Treat other clipping as occlusion from outside the surface.
-  // TODO(danakj): Clip to visibleContentRect?
-  unoccluded_region_in_target_surface.Intersect(
-      render_target->render_surface()->content_rect());
-  unoccluded_region_in_target_surface.Intersect(
-      ScreenSpaceClipRectInTargetSurface(render_target->render_surface(),
-                                         screen_space_clip_rect_));
-
   gfx::RectF unoccluded_rect_in_target_surface =
       unoccluded_region_in_target_surface.bounds();
   gfx::Rect unoccluded_rect = gfx::ToEnclosingRect(
       MathUtil::ProjectClippedRect(inverse_draw_transform,
                                    unoccluded_rect_in_target_surface));
   unoccluded_rect.Intersect(content_rect);
 
   return unoccluded_rect;
 }
 
@@ skipping 52 matching lines @@
         second_last.occlusion_from_inside_target);
   }
   gfx::RectF unoccluded_rect_in_target_surface_without_outside_occlusion =
       unoccluded_region_in_target_surface.bounds();
   if (has_occlusion) {
     const StackObject& second_last = stack_[stack_.size() - 2];
     unoccluded_region_in_target_surface.Subtract(
         second_last.occlusion_from_outside_target);
   }
 
   // Treat other clipping as occlusion from outside the target surface.

[danakj, 2013/10/03 21:33:15]

What is your plan for contributing surfaces next?

[alokp, 2013/10/03 23:06:31]

We should be able to get rid of clipping here as well - not for performance
reason but for consistency. I think it should not affect anything because
RenderSurface::content_rect is also clipped. However I do not yet fully
understand how it interacts with filters. I will need to study it further.

   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_));
 
   gfx::RectF unoccluded_rect_in_target_surface =
       unoccluded_region_in_target_surface.bounds();
   gfx::Rect unoccluded_rect = gfx::ToEnclosingRect(
       MathUtil::ProjectClippedRect(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 OcclusionTrackerBase<Layer, RenderSurface>;
 template class OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>;
 
 }  // namespace cc