Drop background color optimization for composited layers

Source/core/rendering/compositing/CompositedLayerMapping.cpp

Index: Source/core/rendering/compositing/CompositedLayerMapping.cpp
diff --git a/Source/core/rendering/compositing/CompositedLayerMapping.cpp b/Source/core/rendering/compositing/CompositedLayerMapping.cpp
index 352a2c2eb93b04ef501000dfca5aa714af09251e..a85656d57e96246a4a311b617a4e653ff2954df4 100644
--- a/Source/core/rendering/compositing/CompositedLayerMapping.cpp
+++ b/Source/core/rendering/compositing/CompositedLayerMapping.cpp
@@ -345,7 +345,7 @@ void CompositedLayerMapping::updateCompositedBounds()
 {
     // We need to know if we draw content in order to update our bounds (this has an effect
     // on whether or not descendands will paint into our backing). Update this value now.
-    updateDrawsContent(isSimpleContainerCompositingLayer());
+    updateDrawsContent();
 
     LayoutRect layerBounds = compositor()->calculateCompositedBounds(m_owningLayer, m_owningLayer);
 
@@ -513,7 +513,7 @@ bool CompositedLayerMapping::updateGraphicsLayerConfiguration()
         m_graphicsLayer->setReplicatedByLayer(0);
     }
 
-    updateBackgroundColor(isSimpleContainerCompositingLayer());
+    updateBackgroundColor();
 
     if (isDirectlyCompositedImage())
         updateImageContents();
@@ -631,8 +631,6 @@ void CompositedLayerMapping::updateGraphicsLayerGeometry()
     if (!hasActiveAnimationsOnCompositor(*renderer(), CSSPropertyOpacity))
         updateOpacity(renderer()->style());
 
-    bool isSimpleContainer = isSimpleContainerCompositingLayer();
-
     m_owningLayer->updateDescendantDependentFlags();
 
     // m_graphicsLayer is the corresponding GraphicsLayer for this RenderLayer and its non-compositing
@@ -853,9 +851,9 @@ void CompositedLayerMapping::updateGraphicsLayerGeometry()
         updateIsRootForIsolatedGroup();
     }
 
-    updateContentsRect(isSimpleContainer);
-    updateBackgroundColor(isSimpleContainer);
-    updateDrawsContent(isSimpleContainer);
+    updateContentsRect();
+    updateBackgroundColor();
+    updateDrawsContent();
     updateContentsOpaque();
     updateAfterWidgetResize();
     updateRenderingContext();
@@ -940,18 +938,12 @@ void CompositedLayerMapping::updateInternalHierarchy()
     }
 }
 
-void CompositedLayerMapping::updateContentsRect(bool isSimpleContainer)
+void CompositedLayerMapping::updateContentsRect()
 {
-    LayoutRect contentsRect;
-    if (isSimpleContainer && renderer()->hasBackground())
-        contentsRect = backgroundBox();
-    else
-        contentsRect = contentsBox();
-
-    m_graphicsLayer->setContentsRect(pixelSnappedIntRect(contentsRect));
+    m_graphicsLayer->setContentsRect(pixelSnappedIntRect(contentsBox()));
 }
 
-void CompositedLayerMapping::updateDrawsContent(bool isSimpleContainer)
+void CompositedLayerMapping::updateDrawsContent()
 {
     if (m_scrollingLayer) {
         // We don't have to consider overflow controls, because we know that the scrollbars are drawn elsewhere.
@@ -966,7 +958,7 @@ void CompositedLayerMapping::updateDrawsContent(bool isSimpleContainer)
         return;
     }
 
-    bool hasPaintedContent = containsPaintedContent(isSimpleContainer);
+    bool hasPaintedContent = containsPaintedContent();
     if (hasPaintedContent && isAcceleratedCanvas(renderer())) {
         CanvasRenderingContext* context = toHTMLCanvasElement(renderer()->node())->renderingContext();
         // Content layer may be null if context is lost.
@@ -1500,45 +1492,9 @@ Color CompositedLayerMapping::rendererBackgroundColor() const
     return backgroundRenderer->resolveColor(CSSPropertyBackgroundColor);
 }
 
-void CompositedLayerMapping::updateBackgroundColor(bool isSimpleContainer)
-{
-    Color backgroundColor = rendererBackgroundColor();
-    if (isSimpleContainer) {
-        m_graphicsLayer->setContentsToSolidColor(backgroundColor);
-        m_graphicsLayer->setBackgroundColor(Color::transparent);
-    } else {
-        m_graphicsLayer->setContentsToSolidColor(Color::transparent);
-        m_graphicsLayer->setBackgroundColor(backgroundColor);
-    }
-}
-
-static bool supportsDirectBoxDecorationsComposition(const RenderObject* renderer)
-{
-    if (renderer->hasClip())
-        return false;
-
-    if (hasBoxDecorationsOrBackgroundImage(renderer->style()))
-        return false;
-
-    // FIXME: we should be able to allow backgroundComposite; However since this is not a common use case it has been deferred for now.
-    if (renderer->style()->backgroundComposite() != CompositeSourceOver)
-        return false;
-
-    if (renderer->style()->backgroundClip() == TextFillBox)
-        return false;
-
-    return true;
-}
-
-bool CompositedLayerMapping::paintsBoxDecorations() const
+void CompositedLayerMapping::updateBackgroundColor()
 {
-    if (!m_owningLayer->hasVisibleBoxDecorations())
-        return false;
-
-    if (!supportsDirectBoxDecorationsComposition(renderer()))
-        return true;
-
-    return false;
+    m_graphicsLayer->setBackgroundColor(rendererBackgroundColor());
 }
 
 bool CompositedLayerMapping::paintsChildren() const
@@ -1557,23 +1513,21 @@ static bool isCompositedPlugin(RenderObject* renderer)
     return renderer->isEmbeddedObject() && toRenderEmbeddedObject(renderer)->allowsAcceleratedCompositing();
 }
 
-// A "simple container layer" is a RenderLayer which has no visible content to render.
-// It may have no children, or all its children may be themselves composited.
-// This is a useful optimization, because it allows us to avoid allocating backing store.
-bool CompositedLayerMapping::isSimpleContainerCompositingLayer() const
+// FIXME: it's O(n^2). A better solution is needed.
+bool CompositedLayerMapping::hasVisibleContentOrNonCompositingDescendantLayers() const
 {
     RenderObject* renderObject = renderer();
     if (renderObject->hasMask()) // masks require special treatment
-        return false;
+        return true;
 
     if (renderObject->isReplaced() && !isCompositedPlugin(renderObject))
-        return false;
+        return true;
 
-    if (paintsBoxDecorations() || paintsChildren())
-        return false;
+    if (m_owningLayer->hasVisibleBoxDecorations() || paintsChildren())
+        return true;
 
     if (renderObject->isRenderRegion())
-        return false;
+        return true;
 
     if (renderObject->node() && renderObject->node()->isDocumentNode()) {
         // Look to see if the root object has a non-simple background
@@ -1586,7 +1540,7 @@ bool CompositedLayerMapping::isSimpleContainerCompositingLayer() const
         // Reject anything that has a border, a border-radius or outline,
         // or is not a simple background (no background, or solid color).
         if (hasBoxDecorationsOrBackgroundImage(style))
-            return false;
+            return true;
 
         // Now look at the body's renderer.
         HTMLElement* body = renderObject->document().body();
@@ -1597,10 +1551,9 @@ bool CompositedLayerMapping::isSimpleContainerCompositingLayer() const
         style = bodyObject->style();
 
         if (hasBoxDecorationsOrBackgroundImage(style))
-            return false;
+            return true;
     }
-
-    return true;
+    return false;
 }
 
 static bool hasVisibleNonCompositingDescendant(RenderLayer* parent)
@@ -1642,9 +1595,9 @@ bool CompositedLayerMapping::hasVisibleNonCompositingDescendantLayers() const
     return hasVisibleNonCompositingDescendant(m_owningLayer);
 }
 
-bool CompositedLayerMapping::containsPaintedContent(bool isSimpleContainer) const
+bool CompositedLayerMapping::containsPaintedContent() const

[alokp, 2014/02/28 06:50:28]

We already have too many functions with similar names. I think it will be less
confusing if the code in isSimpleContainerCompositingLayer is moved into this
function.

Re-arranging the order in which the tests are done would also help performance.
If paintsIntoOwningLayer is expensive then you should not be calling that first.
You should first try trivial checks. Is there any problem with combining the two
functions?

[dshwang, 2014/02/28 10:59:53]

That's excellent idea.
I guess no. let me test.

 {
-    if (isSimpleContainer || paintsIntoCompositedAncestor() || m_artificiallyInflatedBounds || m_owningLayer->isReflection())
+    if (!hasVisibleContentOrNonCompositingDescendantLayers() || paintsIntoCompositedAncestor() || m_artificiallyInflatedBounds || m_owningLayer->isReflection())
         return false;
 
     if (isDirectlyCompositedImage())
@@ -1711,8 +1664,7 @@ void CompositedLayerMapping::updateImageContents()
 
     // This is a no-op if the layer doesn't have an inner layer for the image.
     m_graphicsLayer->setContentsToImage(image);
-    bool isSimpleContainer = false;
-    updateDrawsContent(isSimpleContainer);
+    updateDrawsContent();
 
     // Image animation is "lazy", in that it automatically stops unless someone is drawing
     // the image. So we have to kick the animation each time; this has the downside that the
@@ -1759,13 +1711,6 @@ LayoutRect CompositedLayerMapping::contentsBox() const
     return contentsBox;
 }
 
-IntRect CompositedLayerMapping::backgroundBox() const
-{
-    LayoutRect backgroundBox = backgroundRect(renderer());
-    backgroundBox.move(contentOffsetInCompostingLayer());
-    return pixelSnappedIntRect(backgroundBox);
-}
-
 GraphicsLayer* CompositedLayerMapping::parentForSublayers() const
 {
     if (m_scrollingContentsLayer)