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"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/render_surface.h"
 #include "cc/layers/render_surface_impl.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 
 template <typename LayerType, typename RenderSurfaceType>
 OcclusionTrackerBase<LayerType, RenderSurfaceType>::OcclusionTrackerBase(
-    gfx::Rect screen_space_clip_rect, bool record_metrics_for_frame)
-    : screen_space_clip_rect_(screen_space_clip_rect),
-      overdraw_metrics_(OverdrawMetrics::Create(record_metrics_for_frame)),
+    bool record_metrics_for_frame)
+    : overdraw_metrics_(OverdrawMetrics::Create(record_metrics_for_frame)),
       prevent_occlusion_(false),
       occluding_screen_space_rects_(NULL),
       non_occluding_screen_space_rects_(NULL) {}
 
 template <typename LayerType, typename RenderSurfaceType>
 OcclusionTrackerBase<LayerType, RenderSurfaceType>::~OcclusionTrackerBase() {}
 
 template <typename LayerType, typename RenderSurfaceType>
 void OcclusionTrackerBase<LayerType, RenderSurfaceType>::EnterLayer(
     const LayerIteratorPosition<LayerType>& layer_iterator,
@@ skipping 17 matching lines @@
     MarkOccludedBehindLayer(layer_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)
     LeaveToRenderTarget(render_target);
 
   prevent_occlusion_ = false;
 }
 
 template <typename RenderSurfaceType>
-static gfx::Rect ScreenSpaceClipRectInTargetSurface(
-    const RenderSurfaceType* target_surface, 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))
-    return target_surface->content_rect();
-
-  return gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
-      inverse_screen_space_transform, screen_space_clip_rect));
-}
-
-template <typename RenderSurfaceType>
 static Region TransformSurfaceOpaqueRegion(const Region& region,
-                                           bool have_clip_rect,
-                                           gfx::Rect clip_rect_in_new_target,
                                            const gfx::Transform& transform) {
   if (region.IsEmpty())
     return Region();
 
   // Verify that rects within the |surface| will remain rects in its target
   // surface after applying |transform|. If this is true, then apply |transform|
   // to each rect within |region| in order to transform the entire Region.
 
   // TODO(danakj): Find a rect interior to each transformed quad.
   if (!transform.Preserves2dAxisAlignment())
     return Region();
 
   // TODO(danakj): If the Region is too complex, degrade gracefully here by
   // skipping rects in it.
   Region transformed_region;
   for (Region::Iterator rects(region); rects.has_rect(); rects.next()) {
     bool clipped;
     gfx::QuadF transformed_quad =
         MathUtil::MapQuad(transform, gfx::QuadF(rects.rect()), &clipped);
     gfx::Rect transformed_rect =
         gfx::ToEnclosedRect(transformed_quad.BoundingBox());
     DCHECK(!clipped);  // We only map if the transform preserves axis alignment.
-    if (have_clip_rect)

[danakj, 2013/09/16 17:29:08]

I don't really understand this change. It's just an intersect, it's not costly.
Have you tried to construct a counter-example that would hit your DCHECK for
this?

-      transformed_rect.Intersect(clip_rect_in_new_target);
     transformed_region.Union(transformed_rect);
   }
   return transformed_region;
 }
 
 static inline bool LayerOpacityKnown(const Layer* layer) {
   return !layer->draw_opacity_is_animating();
 }
 static inline bool LayerOpacityKnown(const LayerImpl* layer) {
   return true;
@@ skipping 88 matching lines @@
   if (!copy_outside_occlusion_forward)
     return;
 
   int 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());
   stack_[last_index].occlusion_from_outside_target =
       TransformSurfaceOpaqueRegion<RenderSurfaceType>(
           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<RenderSurfaceType>(
           stack_[last_index - 1].occlusion_from_inside_target,
-          false,
-          gfx::Rect(),
           old_target_to_new_target_transform));
 }
 
 template <typename LayerType, typename RenderSurfaceType>
 void OcclusionTrackerBase<LayerType, RenderSurfaceType>::FinishedRenderTarget(
     const LayerType* finished_target) {
   // Make sure we know about the target surface.
   EnterRenderTarget(finished_target);
 
   RenderSurfaceType* surface = finished_target->render_surface();
@@ skipping 25 matching lines @@
 static void ReduceOcclusionBelowSurface(LayerType* contributing_layer,
                                         gfx::Rect surface_rect,
                                         const gfx::Transform& surface_transform,
                                         LayerType* render_target,
                                         Region* occlusion_from_inside_target) {
   if (surface_rect.IsEmpty())
     return;
 
   gfx::Rect affected_area_in_target = gfx::ToEnclosingRect(
       MathUtil::MapClippedRect(surface_transform, gfx::RectF(surface_rect)));
-  if (contributing_layer->render_surface()->is_clipped()) {
-    affected_area_in_target.Intersect(

[danakj, 2013/09/16 17:29:08]

Again, just an intersection. I think there's two ways clipping can come up in
here.

One is clipping the unoccluded region, and that makes sense to move out. The
other is clipping occlusion, and that is really important to not over-estimate
what's occluded. I don't think that can go away. This is the latter here. I
would need to be convinced that this will never lead to us considering something
occluded when it is not.

[alokp, 2013/09/17 00:31:41]

I have decided to break this into two patches - one for query function and
another for things that compute occlusion. Lets focus on the query function for
now. This is not slowing us down anyway.

-        contributing_layer->render_surface()->clip_rect());
-  }
-  if (affected_area_in_target.IsEmpty())
-    return;
 
   int outset_top, outset_right, outset_bottom, outset_left;
   contributing_layer->background_filters().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);
 
@@ skipping 41 matching lines @@
   // 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 LayerType* old_target = stack_[last_index].target;
   const RenderSurfaceType* old_surface = old_target->render_surface();
 
   Region old_occlusion_from_inside_target_in_new_target =
       TransformSurfaceOpaqueRegion<RenderSurfaceType>(
           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<RenderSurfaceType>(
             stack_[last_index].occlusion_from_inside_target,
-            old_surface->is_clipped(),
-            old_surface->clip_rect(),
             old_surface->replica_draw_transform()));
   }
+  // Verify that the occluded region is contained inside the
+  // target surface clip-rect.
+  DCHECK(!old_surface->is_clipped() ||
+      old_surface->clip_rect().Contains(
+          old_occlusion_from_inside_target_in_new_target.bounds()));
 
   Region old_occlusion_from_outside_target_in_new_target =
       TransformSurfaceOpaqueRegion<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(), NULL);
     if (old_target->has_replica()) {
       unoccluded_replica_rect = UnoccludedContributingSurfaceContentRect(
           old_target, true, old_surface->content_rect(), NULL);
@@ skipping 68 matching lines @@
 
   if (!LayerTransformsToTargetKnown(layer))
     return;
 
   Region opaque_contents = layer->VisibleContentOpaqueRegion();
   if (opaque_contents.IsEmpty())
     return;
 
   DCHECK(layer->visible_content_rect().Contains(opaque_contents.bounds()));
 
   // TODO(danakj): Find a rect interior to each transformed quad.

[danakj, 2013/09/16 17:29:08]

Remove this TODO and mention we don't support non-axis-aligned layers relative
to their target because their visible content rect may exceed the bounds of
their actual visible post-clip region in their target.

   if (!layer->draw_transform().Preserves2dAxisAlignment())
     return;
 
-  gfx::Rect clip_rect_in_target = ScreenSpaceClipRectInTargetSurface(
-      layer->render_target()->render_surface(), 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());
-  }
-
   for (Region::Iterator opaque_content_rects(opaque_contents);
        opaque_content_rects.has_rect();
        opaque_content_rects.next()) {
     bool clipped;
     gfx::QuadF transformed_quad = MathUtil::MapQuad(
         layer->draw_transform(),
         gfx::QuadF(opaque_content_rects.rect()),
         &clipped);
     gfx::Rect transformed_rect =
         gfx::ToEnclosedRect(transformed_quad.BoundingBox());
     DCHECK(!clipped);  // We only map if the transform preserves axis alignment.
-    transformed_rect.Intersect(clip_rect_in_target);
+#ifndef NDEBUG

[danakj, 2013/09/16 17:29:08]

if (DCHECK_IS_ON()) {

+  // Verify that the occluded region is contained inside the target surface
+  // clip-rect or bounds. We do not do any clipping here in occlusion tracker.
+  // We assume that visible-content-rect has already been clipped during
+  // CalculateDrawProperties.
+  gfx::Rect clip_rect_in_target = layer->is_clipped() ?
+      layer->clip_rect() :
+      layer->render_target()->render_surface()->content_rect();
+  DCHECK(clip_rect_in_target.Contains(transformed_rect));

[danakj, 2013/09/16 17:29:08]

Note that this DCHECK is verifying the clip rect in the target, but it is not
including the viewport in that. I think one could construct a series of render
surfaces such that the visible_content_rect of the layer would end up not
clipped to the viewport, but would be axis-aligned to its target.

Maybe this won't be a problem in the wild, but if we start seeing missing tiles
on non-impl painting around the edge of the viewport.. we'll know why.

+#endif  // NDEBUG
     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);
 
     if (!occluding_screen_space_rects_)
       continue;
 
     // Save the occluding area in screen space for debug visualization.
     gfx::QuadF screen_space_quad = MathUtil::MapQuad(
         layer->render_target()->render_surface()->screen_space_transform(),
         gfx::QuadF(transformed_rect), &clipped);
     // TODO(danakj): Store the quad in the debug info instead of the bounding
     // box.
     gfx::Rect screen_space_rect =
         gfx::ToEnclosedRect(screen_space_quad.BoundingBox());
     occluding_screen_space_rects_->push_back(screen_space_rect);
   }
 
+

[danakj, 2013/09/16 17:29:08]

extra whitespace

[alokp, 2013/09/17 00:31:41]

Done.

   if (!non_occluding_screen_space_rects_)
     return;
 
   Region non_opaque_contents =
       SubtractRegions(gfx::Rect(layer->content_bounds()), opaque_contents);
   for (Region::Iterator non_opaque_content_rects(non_opaque_contents);
        non_opaque_content_rects.has_rect();
        non_opaque_content_rects.next()) {
     // We've already checked for clipping in the MapQuad call above, these calls
     // should not clip anything further.
     gfx::Rect transformed_rect = gfx::ToEnclosedRect(
         MathUtil::MapClippedRect(layer->draw_transform(),
                                  gfx::RectF(non_opaque_content_rects.rect())));
-    transformed_rect.Intersect(clip_rect_in_target);
     if (transformed_rect.IsEmpty())
       continue;
 
     bool clipped;
     gfx::QuadF screen_space_quad = MathUtil::MapQuad(
         layer->render_target()->render_surface()->screen_space_transform(),
         gfx::QuadF(transformed_rect),
         &clipped);
     // TODO(danakj): Store the quad in the debug info instead of the bounding
     // box.
     gfx::Rect screen_space_rect =
         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,
     bool* has_occlusion_from_outside_target_surface) const {
   if (has_occlusion_from_outside_target_surface)
     *has_occlusion_from_outside_target_surface = false;
   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);

[danakj, 2013/09/16 17:29:08]

I think I buy that this can go away (and not move elsewhere). I was worried
about partial culling or rotated layers, but we'll have a clip rect defined at
draw time for these quads so that should prevent wasted drawing.

   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.

[danakj, 2013/09/16 17:29:08]

I'm not sure why you say that the has_occlusion_from_outside_target_surface will
always produce the same results. In the early-out case sure.. but what about
these cases?

For instance, if the render surface is rotated so it's top-left corner is
outside the viewport, and half of this query is outside the viewport in the
top-left corner there.. what is going to set this bool to true so the surface is
known to be incomplete?

Same question for the 2 functions below.

[alokp, 2013/09/17 00:31:41]

You are right. I do not see how I can preserve this bit without clipping. Per
our offline discussion, I will see if I can remove this feature as it is not
being used right now.

-  // 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();
 
   if (has_occlusion_from_outside_target_surface) {
     // Check if the unoccluded rect shrank when applying outside occlusion.
     *has_occlusion_from_outside_target_surface = !gfx::SubtractRects(
         unoccluded_rect_in_target_surface_without_outside_occlusion,
         unoccluded_rect_in_target_surface).IsEmpty();
   }
 
   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,
         bool* has_occlusion_from_outside_target_surface) const {
   if (has_occlusion_from_outside_target_surface)
     *has_occlusion_from_outside_target_surface = false;
   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);
 
   if (has_occlusion_from_outside_target_surface) {
     // Check if the unoccluded rect shrank when applying outside occlusion.
     *has_occlusion_from_outside_target_surface = !gfx::SubtractRects(
@@ skipping 23 matching lines @@
   DCHECK_EQ(layer, stack_.back().target);
 
   if (has_occlusion_from_outside_target_surface)
     *has_occlusion_from_outside_target_surface = false;
   if (prevent_occlusion_)
     return content_rect;
 
   if (content_rect.IsEmpty())
     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).
+  if (stack_.size() == 1)
+    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;
+  }
+
   const 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;
-
   // 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 (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_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.
-  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_outside_target);
 
   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);
 
   if (has_occlusion_from_outside_target_surface) {
     // Check if the unoccluded rect shrank when applying outside occlusion.
     *has_occlusion_from_outside_target_surface = !gfx::SubtractRects(
         unoccluded_rect_in_target_surface_without_outside_occlusion,
         unoccluded_rect_in_target_surface).IsEmpty();
   }
 
   return unoccluded_rect;
 }
 
 // Instantiate (and export) templates here for the linker.
 template class OcclusionTrackerBase<Layer, RenderSurface>;
 template class OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>;
 
 }  // namespace cc