cc: Stop using drawableContentRect for occlusion.

cc/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/occlusion_tracker.h"
 
 #include <algorithm>
 
 #include "cc/layer.h"
 #include "cc/layer_impl.h"
@@ skipping 29 matching lines @@
         finishedRenderTarget(renderTarget);
 }
 
 template<typename LayerType, typename RenderSurfaceType>
 void OcclusionTrackerBase<LayerType, RenderSurfaceType>::leaveLayer(const LayerIteratorPosition<LayerType>& layerIterator)
 {
     LayerType* renderTarget = layerIterator.targetRenderSurfaceLayer;
 
     if (layerIterator.representsItself)
         markOccludedBehindLayer(layerIterator.currentLayer);
+    // 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 (layerIterator.representsContributingRenderSurface)
         leaveToRenderTarget(renderTarget);
 }
 
 template<typename RenderSurfaceType>
 static gfx::Rect screenSpaceClipRectInTargetSurface(const RenderSurfaceType* targetSurface, gfx::Rect screenSpaceClipRect)
 {
     gfx::Transform inverseScreenSpaceTransform(gfx::Transform::kSkipInitialization);
     if (!targetSurface->screenSpaceTransform().GetInverse(&inverseScreenSpaceTransform))
         return targetSurface->contentRect();
@@ skipping 212 matching lines @@
     DCHECK(layer->renderTarget() == m_stack.back().target);
     if (m_stack.empty())
         return;
 
     if (!layerOpacityKnown(layer) || layer->drawOpacity() < 1)
         return;
 
     if (layerIsInUnsorted3dRenderingContext(layer))
         return;
 
+    if (!layerTransformsToTargetKnown(layer))
+        return;
+
     Region opaqueContents = layer->visibleContentOpaqueRegion();
     if (opaqueContents.IsEmpty())
         return;
 
     DCHECK(layer->visibleContentRect().Contains(opaqueContents.bounds()));
 
-    if (!layerTransformsToTargetKnown(layer))
-        return;
-
     bool clipped;
     gfx::QuadF visibleTransformedQuad = MathUtil::mapQuad(layer->drawTransform(), gfx::QuadF(opaqueContents.bounds()), clipped);
     // FIXME: Find a rect interior to each transformed quad.
     if (clipped || !visibleTransformedQuad.IsRectilinear())
         return;
 
     gfx::Rect clipRectInTarget = gfx::IntersectRects(
-        layerClipRectInTarget(layer),
+        layer->renderTarget()->renderSurface()->contentRect(),
         screenSpaceClipRectInTargetSurface(layer->renderTarget()->renderSurface(), m_screenSpaceClipRect));
 
     for (Region::Iterator opaqueContentRects(opaqueContents); opaqueContentRects.has_rect(); opaqueContentRects.next()) {
         gfx::Rect transformedRect = gfx::ToEnclosedRect(MathUtil::mapQuad(layer->drawTransform(), gfx::QuadF(opaqueContentRects.rect()), clipped).BoundingBox());
         DCHECK(!clipped); // We only map if the transform preserves axis alignment.
         transformedRect.Intersect(clipRectInTarget);
         if (transformedRect.width() < m_minimumTrackingSize.width() && transformedRect.height() < m_minimumTrackingSize.height())
             continue;
         m_stack.back().occlusionFromInsideTarget.Union(transformedRect);
 
@@ skipping 19 matching lines @@
             continue;
 
         gfx::QuadF screenSpaceQuad = MathUtil::mapQuad(layer->renderTarget()->renderSurface()->screenSpaceTransform(), gfx::QuadF(transformedRect), clipped);
         // TODO(danakj): Store the quad in the debug info instead of the bounding box.
         gfx::Rect screenSpaceRect = gfx::ToEnclosedRect(screenSpaceQuad.BoundingBox());
         m_nonOccludingScreenSpaceRects->push_back(screenSpaceRect);
     }
 }
 
 template<typename LayerType, typename RenderSurfaceType>
-bool OcclusionTrackerBase<LayerType, RenderSurfaceType>::occluded(const LayerType* renderTarget, const gfx::Rect& contentRect, const gfx::Transform& drawTransform, bool implDrawTransformIsUnknown, const gfx::Rect& clippedRectInTarget, bool* hasOcclusionFromOutsideTargetSurface) const
+bool OcclusionTrackerBase<LayerType, RenderSurfaceType>::occluded(const LayerType* renderTarget, gfx::Rect contentRect, const gfx::Transform& drawTransform, bool implDrawTransformIsUnknown, bool isClipped, gfx::Rect clipRectInTarget, bool* hasOcclusionFromOutsideTargetSurface) const
 {
     if (hasOcclusionFromOutsideTargetSurface)
         *hasOcclusionFromOutsideTargetSurface = false;
 
     DCHECK(!m_stack.empty());
     if (m_stack.empty())
         return false;
     if (contentRect.IsEmpty())
         return true;
     if (implDrawTransformIsUnknown)
         return false;
 
     // For tests with no render target.
     if (!renderTarget)
         return false;
 
     DCHECK(renderTarget->renderTarget() == renderTarget);
     DCHECK(renderTarget->renderSurface());
     DCHECK(renderTarget == m_stack.back().target);
 
     gfx::Transform inverseDrawTransform(gfx::Transform::kSkipInitialization);
     if (!drawTransform.GetInverse(&inverseDrawTransform))
         return false;
 
     // Take the ToEnclosingRect at each step, as we want to contain any unoccluded partial pixels in the resulting Rect.
     Region unoccludedRegionInTargetSurface = gfx::ToEnclosingRect(MathUtil::mapClippedRect(drawTransform, gfx::RectF(contentRect)));
     // Layers can't clip across surfaces, so count this as internal occlusion.
-    // TODO(danakj): This would change if we clipped to the visibleContentRect().
-    unoccludedRegionInTargetSurface.Intersect(clippedRectInTarget);
+    if (isClipped)
+      unoccludedRegionInTargetSurface.Intersect(clipRectInTarget);
     unoccludedRegionInTargetSurface.Subtract(m_stack.back().occlusionFromInsideTarget);
     gfx::RectF unoccludedRectInTargetSurfaceWithoutOutsideOcclusion = unoccludedRegionInTargetSurface.bounds();
     unoccludedRegionInTargetSurface.Subtract(m_stack.back().occlusionFromOutsideTarget);
 
     // Treat other clipping as occlusion from outside the surface.
+    // TODO(danakj): Clip to visibleContentRect?
     unoccludedRegionInTargetSurface.Intersect(renderTarget->renderSurface()->contentRect());
     unoccludedRegionInTargetSurface.Intersect(screenSpaceClipRectInTargetSurface(renderTarget->renderSurface(), m_screenSpaceClipRect));
 
     gfx::RectF unoccludedRectInTargetSurface = unoccludedRegionInTargetSurface.bounds();
 
     if (hasOcclusionFromOutsideTargetSurface) {
         // Check if the unoccluded rect shrank when applying outside occlusion.
         *hasOcclusionFromOutsideTargetSurface = !gfx::SubtractRects(unoccludedRectInTargetSurfaceWithoutOutsideOcclusion, unoccludedRectInTargetSurface).IsEmpty();
     }
 
     return unoccludedRectInTargetSurface.IsEmpty();
 }
 
 template<typename LayerType, typename RenderSurfaceType>
-gfx::Rect OcclusionTrackerBase<LayerType, RenderSurfaceType>::unoccludedContentRect(const LayerType* renderTarget, const gfx::Rect& contentRect, const gfx::Transform& drawTransform, bool implDrawTransformIsUnknown, const gfx::Rect& clippedRectInTarget, bool* hasOcclusionFromOutsideTargetSurface) const
+gfx::Rect OcclusionTrackerBase<LayerType, RenderSurfaceType>::unoccludedContentRect(const LayerType* renderTarget, gfx::Rect contentRect, const gfx::Transform& drawTransform, bool implDrawTransformIsUnknown, bool isClipped, gfx::Rect clipRectInTarget, bool* hasOcclusionFromOutsideTargetSurface) const
 {
     if (hasOcclusionFromOutsideTargetSurface)
         *hasOcclusionFromOutsideTargetSurface = false;
 
     DCHECK(!m_stack.empty());
     if (m_stack.empty())
         return contentRect;
     if (contentRect.IsEmpty())
         return contentRect;
     if (implDrawTransformIsUnknown)
         return contentRect;
 
     // For tests with no render target.
     if (!renderTarget)
         return contentRect;
 
     DCHECK(renderTarget->renderTarget() == renderTarget);
     DCHECK(renderTarget->renderSurface());
     DCHECK(renderTarget == m_stack.back().target);
 
     gfx::Transform inverseDrawTransform(gfx::Transform::kSkipInitialization);
     if (!drawTransform.GetInverse(&inverseDrawTransform))
         return contentRect;
 
     // Take the ToEnclosingRect at each step, as we want to contain any unoccluded partial pixels in the resulting Rect.
     Region unoccludedRegionInTargetSurface = gfx::ToEnclosingRect(MathUtil::mapClippedRect(drawTransform, gfx::RectF(contentRect)));
     // Layers can't clip across surfaces, so count this as internal occlusion.
-    // TODO(danakj): This would change if we clipped to the visibleContentRect().
-    unoccludedRegionInTargetSurface.Intersect(clippedRectInTarget);
+    if (isClipped)
+      unoccludedRegionInTargetSurface.Intersect(clipRectInTarget);
     unoccludedRegionInTargetSurface.Subtract(m_stack.back().occlusionFromInsideTarget);
     gfx::RectF unoccludedRectInTargetSurfaceWithoutOutsideOcclusion = unoccludedRegionInTargetSurface.bounds();
     unoccludedRegionInTargetSurface.Subtract(m_stack.back().occlusionFromOutsideTarget);
 
     // Treat other clipping as occlusion from outside the surface.
+    // TODO(danakj): Clip to visibleContentRect?
     unoccludedRegionInTargetSurface.Intersect(renderTarget->renderSurface()->contentRect());
     unoccludedRegionInTargetSurface.Intersect(screenSpaceClipRectInTargetSurface(renderTarget->renderSurface(), m_screenSpaceClipRect));
 
     gfx::RectF unoccludedRectInTargetSurface = unoccludedRegionInTargetSurface.bounds();
     gfx::Rect unoccludedRect = gfx::ToEnclosingRect(MathUtil::projectClippedRect(inverseDrawTransform, unoccludedRectInTargetSurface));
     unoccludedRect.Intersect(contentRect);
 
     if (hasOcclusionFromOutsideTargetSurface) {
         // Check if the unoccluded rect shrank when applying outside occlusion.
         *hasOcclusionFromOutsideTargetSurface = !gfx::SubtractRects(unoccludedRectInTargetSurfaceWithoutOutsideOcclusion, unoccludedRectInTargetSurface).IsEmpty();
@@ skipping 32 matching lines @@
     if (!drawTransform.GetInverse(&inverseDrawTransform))
         return contentRect;
 
     // 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 hasOcclusion = m_stack.size() > 1;
 
     // Take the ToEnclosingRect at each step, as we want to contain any unoccluded partial pixels in the resulting Rect.
     Region unoccludedRegionInTargetSurface = gfx::ToEnclosingRect(MathUtil::mapClippedRect(drawTransform, gfx::RectF(contentRect)));
     // Layers can't clip across surfaces, so count this as internal occlusion.
-    // TODO(danakj): This would change if we clipped to the visibleContentRect().
     if (surface->isClipped())
         unoccludedRegionInTargetSurface.Intersect(surface->clipRect());
     if (hasOcclusion) {
         const StackObject& secondLast = m_stack[m_stack.size() - 2];
         unoccludedRegionInTargetSurface.Subtract(secondLast.occlusionFromInsideTarget);
     }
     gfx::RectF unoccludedRectInTargetSurfaceWithoutOutsideOcclusion = unoccludedRegionInTargetSurface.bounds();
     if (hasOcclusion) {
         const StackObject& secondLast = m_stack[m_stack.size() - 2];
         unoccludedRegionInTargetSurface.Subtract(secondLast.occlusionFromOutsideTarget);
     }
 
     // Treat other clipping as occlusion from outside the target surface.
     unoccludedRegionInTargetSurface.Intersect(contributingSurfaceRenderTarget->renderSurface()->contentRect());
     unoccludedRegionInTargetSurface.Intersect(screenSpaceClipRectInTargetSurface(contributingSurfaceRenderTarget->renderSurface(), m_screenSpaceClipRect));
 
     gfx::RectF unoccludedRectInTargetSurface = unoccludedRegionInTargetSurface.bounds();
     gfx::Rect unoccludedRect = gfx::ToEnclosingRect(MathUtil::projectClippedRect(inverseDrawTransform, unoccludedRectInTargetSurface));
     unoccludedRect.Intersect(contentRect);
 
     if (hasOcclusionFromOutsideTargetSurface) {
         // Check if the unoccluded rect shrank when applying outside occlusion.
         *hasOcclusionFromOutsideTargetSurface = !gfx::SubtractRects(unoccludedRectInTargetSurfaceWithoutOutsideOcclusion, unoccludedRectInTargetSurface).IsEmpty();
     }
 
     return unoccludedRect;
 }
 
-template<typename LayerType, typename RenderSurfaceType>
-gfx::Rect OcclusionTrackerBase<LayerType, RenderSurfaceType>::layerClipRectInTarget(const LayerType* layer) const
-{
-    // TODO(danakj): Can we remove this use of drawableContentRect and just use the clipRect() and target surface contentRect?
-    // TODO(danakj): Or can we use visibleContentRect() which is much tighter?
-    return layer->drawableContentRect();
-}
-
 // Instantiate (and export) templates here for the linker.
 template class OcclusionTrackerBase<Layer, RenderSurface>;
 template class OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>;
 
 }  // namespace cc