Merge 113677 - [chromium] Viewport is not filled when out of texture memory on mac

Source/WebCore/platform/graphics/chromium/cc/CCOcclusionTracker.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 176 matching lines @@
                               boundsInLayerSpace.height() / static_cast<double>(boundsInContentSpace.height()));
 
     // The draw transform expects the origin to be in the middle of the layer.
     transform.translate(-boundsInContentSpace.width() / 2.0, -boundsInContentSpace.height() / 2.0);
 
     return transform;
 }
 
 // FIXME: Remove usePaintTracking when paint tracking is on for paint culling.
 template<typename LayerType>
-static inline Region computeOcclusionBehindLayer(const LayerType* layer, const TransformationMatrix& transform, bool usePaintTracking)
+static inline Region computeOcclusionBehindLayer(const LayerType* layer, const TransformationMatrix& transform, const Region& opaqueContents, bool usePaintTracking)
 {
-    Region opaqueRegion;
+    ASSERT(layer->visibleLayerRect().contains(opaqueContents.bounds()));
 
     FloatQuad unoccludedQuad = transform.mapQuad(FloatQuad(layer->visibleLayerRect()));
     bool isPaintedAxisAligned = unoccludedQuad.isRectilinear();
     if (!isPaintedAxisAligned)
-        return opaqueRegion;
+        return Region();
 
-    if (layer->opaque())
-        opaqueRegion = enclosedIntRect(unoccludedQuad.boundingBox());
-    else if (usePaintTracking && transform.isIdentity())
-        opaqueRegion = layer->visibleContentOpaqueRegion();
+    Region transformedOpaqueContents;
+    if (usePaintTracking && transform.isIdentity())
+        transformedOpaqueContents = opaqueContents;
     else if (usePaintTracking) {
-        Region contentRegion = layer->visibleContentOpaqueRegion();
-        Vector<IntRect> contentRects = contentRegion.rects();
+        Vector<IntRect> contentRects = opaqueContents.rects();
         for (size_t i = 0; i < contentRects.size(); ++i)
-            opaqueRegion.unite(enclosedIntRect(transform.mapRect(FloatRect(contentRects[i]))));
+            transformedOpaqueContents.unite(enclosedIntRect(transform.mapRect(FloatRect(contentRects[i]))));
     }
-    return opaqueRegion;
+
+    return transformedOpaqueContents;
 }
 
 template<typename LayerType, typename RenderSurfaceType>
 void CCOcclusionTrackerBase<LayerType, RenderSurfaceType>::markOccludedBehindLayer(const LayerType* layer)
 {
     ASSERT(!m_stack.isEmpty());
     ASSERT(layer->targetRenderSurface() == m_stack.last().surface);
     if (m_stack.isEmpty())
         return;
 
     if (!layerOpacityKnown(layer) || layer->drawOpacity() < 1)
         return;
 
+    Region opaqueContents = layer->visibleContentOpaqueRegion();
+    if (opaqueContents.isEmpty())
+        return;
+
     // FIXME: Remove m_usePaintTracking when paint tracking is on for paint culling.
     if (layerTransformsToScreenKnown(layer))
-        m_stack.last().occlusionInScreen.unite(computeOcclusionBehindLayer<LayerType>(layer, contentToScreenSpaceTransform<LayerType>(layer), m_usePaintTracking));
+        m_stack.last().occlusionInScreen.unite(computeOcclusionBehindLayer<LayerType>(layer, contentToScreenSpaceTransform<LayerType>(layer), opaqueContents, m_usePaintTracking));
     if (layerTransformsToTargetKnown(layer))
-        m_stack.last().occlusionInTarget.unite(computeOcclusionBehindLayer<LayerType>(layer, contentToTargetSurfaceTransform<LayerType>(layer), m_usePaintTracking));
+        m_stack.last().occlusionInTarget.unite(computeOcclusionBehindLayer<LayerType>(layer, contentToTargetSurfaceTransform<LayerType>(layer), opaqueContents, m_usePaintTracking));
 }
 
 static inline bool testContentRectOccluded(const IntRect& contentRect, const TransformationMatrix& contentSpaceTransform, const IntRect& scissorRect, const Region& occlusion)
 {
     FloatRect transformedRect = contentSpaceTransform.mapRect(FloatRect(contentRect));
     // Take the enclosingIntRect, as we want to include partial pixels in the test.
     IntRect targetRect = intersection(enclosingIntRect(transformedRect), scissorRect);
     return targetRect.isEmpty() || occlusion.contains(targetRect);
 }
 
@@ skipping 134 matching lines @@
 template void CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::markOccludedBehindLayer(const CCLayerImpl*);
 template bool CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::occluded(const CCLayerImpl*, const IntRect& contentRect) const;
 template IntRect CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::unoccludedContentRect(const CCLayerImpl*, const IntRect& contentRect) const;
 template const Region& CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::currentOcclusionInScreenSpace() const;
 template const Region& CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::currentOcclusionInTargetSurface() const;
 template IntRect CCOcclusionTrackerBase<CCLayerImpl, CCRenderSurface>::layerScissorRectInTargetSurface(const CCLayerImpl*) const;
 
 
 } // namespace WebCore
 #endif // USE(ACCELERATED_COMPOSITING)