Revert 168245 "Drop background color optimization for composited..."

trunk/Source/core/rendering/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 Apple 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 328 matching lines @@
     if (m_owningLayer->renderer()->containingBlock()->enclosingLayer() != m_owningLayer->ancestorScrollingLayer())
         return true;
 
     return false;
 }
 
 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();
+    updateDrawsContent(isSimpleContainerCompositingLayer());
 
     LayoutRect layerBounds = compositor()->calculateCompositedBounds(m_owningLayer, m_owningLayer);
 
     // Clip to the size of the document or enclosing overflow-scroll layer.
     // If this or an ancestor is transformed, we can't currently compute the correct rect to intersect with.
     // We'd need RenderObject::convertContainerToLocalQuad(), which doesn't yet exist.
     if (shouldClipCompositedBounds()) {
         RenderView* view = m_owningLayer->renderer()->view();
         RenderLayer* rootLayer = view->layer();
 
@@ skipping 147 matching lines @@
 
     if (m_owningLayer->reflectionInfo()) {
         if (m_owningLayer->reflectionInfo()->reflectionLayer()->hasCompositedLayerMapping()) {
             GraphicsLayer* reflectionLayer = m_owningLayer->reflectionInfo()->reflectionLayer()->compositedLayerMapping()->mainGraphicsLayer();
             m_graphicsLayer->setReplicatedByLayer(reflectionLayer);
         }
     } else {
         m_graphicsLayer->setReplicatedByLayer(0);
     }
 
-    updateBackgroundColor();
+    updateBackgroundColor(isSimpleContainerCompositingLayer());
 
     if (isDirectlyCompositedImage())
         updateImageContents();
 
     if (renderer->isEmbeddedObject() && toRenderEmbeddedObject(renderer)->allowsAcceleratedCompositing()) {
         PluginView* pluginView = toPluginView(toRenderWidget(renderer)->widget());
         m_graphicsLayer->setContentsToPlatformLayer(pluginView->platformLayer());
     } else if (renderer->node() && renderer->node()->isFrameOwnerElement() && toHTMLFrameOwnerElement(renderer->node())->contentFrame()) {
         blink::WebLayer* layer = toHTMLFrameOwnerElement(renderer->node())->contentFrame()->remotePlatformLayer();
         if (layer)
@@ skipping 97 matching lines @@
 
     // Set transform property, if it is not animating. We have to do this here because the transform
     // is affected by the layer dimensions.
     if (!hasActiveAnimationsOnCompositor(*renderer(), CSSPropertyWebkitTransform))
         updateTransform(renderer()->style());
 
     // Set opacity, if it is not animating.
     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
     // descendants. So, the visibility flag for m_graphicsLayer should be true if there are any
     // non-compositing visible layers.
     bool contentsVisible = m_owningLayer->hasVisibleContent() || hasVisibleNonCompositingDescendantLayers();
     if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled() && renderer()->isVideo()) {
         HTMLMediaElement* mediaElement = toHTMLMediaElement(renderer()->node());
         if (mediaElement->isFullscreen())
             contentsVisible = false;
@@ skipping 197 matching lines @@
 
     // We can't make this call in RenderLayerCompositor::allocateOrClearCompositedLayerMapping
     // since it depends on whether compAncestor draws content, which gets updated later.
     updateRequiresOwnBackingStoreForAncestorReasons(compAncestor);
 
     if (RuntimeEnabledFeatures::cssCompositingEnabled()) {
         updateLayerBlendMode(style);
         updateIsRootForIsolatedGroup();
     }
 
-    updateContentsRect();
-    updateBackgroundColor();
-    updateDrawsContent();
+    updateContentsRect(isSimpleContainer);
+    updateBackgroundColor(isSimpleContainer);
+    updateDrawsContent(isSimpleContainer);
     updateContentsOpaque();
     updateAfterWidgetResize();
     updateRenderingContext();
     updateShouldFlattenTransform();
     updateChildrenTransform();
     registerScrollingLayers();
 
     updateCompositingReasons();
 }
 
@@ skipping 64 matching lines @@
 
         if (m_ancestorClippingLayer)
             m_squashingContainmentLayer->addChild(m_ancestorClippingLayer.get());
         else
             m_squashingContainmentLayer->addChild(m_graphicsLayer.get());
 
         m_squashingContainmentLayer->addChild(m_squashingLayer.get());
     }
 }
 
-void CompositedLayerMapping::updateContentsRect()
+void CompositedLayerMapping::updateContentsRect(bool isSimpleContainer)
 {
-    m_graphicsLayer->setContentsRect(pixelSnappedIntRect(contentsBox()));
+    LayoutRect contentsRect;
+    if (isSimpleContainer && renderer()->hasBackground())
+        contentsRect = backgroundBox();
+    else
+        contentsRect = contentsBox();
+
+    m_graphicsLayer->setContentsRect(pixelSnappedIntRect(contentsRect));
 }
 
-void CompositedLayerMapping::updateDrawsContent()
+void CompositedLayerMapping::updateDrawsContent(bool isSimpleContainer)
 {
     if (m_scrollingLayer) {
         // We don't have to consider overflow controls, because we know that the scrollbars are drawn elsewhere.
         // m_graphicsLayer only needs backing store if the non-scrolling parts (background, outlines, borders, shadows etc) need to paint.
         // m_scrollingLayer never has backing store.
         // m_scrollingContentsLayer only needs backing store if the scrolled contents need to paint.
         bool hasNonScrollingPaintedContent = m_owningLayer->hasVisibleContent() && m_owningLayer->hasBoxDecorationsOrBackground();
         m_graphicsLayer->setDrawsContent(hasNonScrollingPaintedContent);
 
         bool hasScrollingPaintedContent = m_owningLayer->hasVisibleContent() && (renderer()->hasBackground() || paintsChildren());
         m_scrollingContentsLayer->setDrawsContent(hasScrollingPaintedContent);
         return;
     }
 
-    bool hasPaintedContent = containsPaintedContent();
+    bool hasPaintedContent = containsPaintedContent(isSimpleContainer);
     if (hasPaintedContent && isAcceleratedCanvas(renderer())) {
         CanvasRenderingContext* context = toHTMLCanvasElement(renderer()->node())->renderingContext();
         // Content layer may be null if context is lost.
         if (blink::WebLayer* contentLayer = context->platformLayer()) {
             Color bgColor(Color::transparent);
             if (contentLayerSupportsDirectBackgroundComposition(renderer())) {
                 bgColor = rendererBackgroundColor();
                 hasPaintedContent = false;
             }
             contentLayer->setBackgroundColor(bgColor.rgb());
@@ skipping 513 matching lines @@
 
 Color CompositedLayerMapping::rendererBackgroundColor() const
 {
     RenderObject* backgroundRenderer = renderer();
     if (backgroundRenderer->isRoot())
         backgroundRenderer = backgroundRenderer->rendererForRootBackground();
 
     return backgroundRenderer->resolveColor(CSSPropertyBackgroundColor);
 }
 
-void CompositedLayerMapping::updateBackgroundColor()
+void CompositedLayerMapping::updateBackgroundColor(bool isSimpleContainer)
 {
-    m_graphicsLayer->setBackgroundColor(rendererBackgroundColor());
+    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
+{
+    if (!m_owningLayer->hasVisibleBoxDecorations())
+        return false;
+
+    if (!supportsDirectBoxDecorationsComposition(renderer()))
+        return true;
+
+    return false;
 }
 
 bool CompositedLayerMapping::paintsChildren() const
 {
     if (m_owningLayer->hasVisibleContent() && m_owningLayer->hasNonEmptyChildRenderers())
         return true;
 
     if (hasVisibleNonCompositingDescendantLayers())
         return true;
 
     return false;
 }
 
 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
+{
+    RenderObject* renderObject = renderer();
+    if (renderObject->hasMask()) // masks require special treatment
+        return false;
+
+    if (renderObject->isReplaced() && !isCompositedPlugin(renderObject))
+        return false;
+
+    if (paintsBoxDecorations() || paintsChildren())
+        return false;
+
+    if (renderObject->isRenderRegion())
+        return false;
+
+    if (renderObject->node() && renderObject->node()->isDocumentNode()) {
+        // Look to see if the root object has a non-simple background
+        RenderObject* rootObject = renderObject->document().documentElement() ? renderObject->document().documentElement()->renderer() : 0;
+        if (!rootObject)
+            return false;
+
+        RenderStyle* style = rootObject->style();
+
+        // 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;
+
+        // Now look at the body's renderer.
+        HTMLElement* body = renderObject->document().body();
+        RenderObject* bodyObject = (body && body->hasLocalName(bodyTag)) ? body->renderer() : 0;
+        if (!bodyObject)
+            return false;
+
+        style = bodyObject->style();
+
+        if (hasBoxDecorationsOrBackgroundImage(style))
+            return false;
+    }
+
+    return true;
+}
+
 static bool hasVisibleNonCompositingDescendant(RenderLayer* parent)
 {
     // FIXME: We shouldn't be called with a stale z-order lists. See bug 85512.
     parent->stackingNode()->updateLayerListsIfNeeded();
 
 #if !ASSERT_DISABLED
     LayerListMutationDetector mutationChecker(parent->stackingNode());
 #endif
 
     RenderLayerStackingNodeIterator normalFlowIterator(*parent->stackingNode(), NormalFlowChildren);
@@ skipping 19 matching lines @@
 }
 
 // FIXME: By name the implementation is correct. But the code that uses this function means something
 // very slightly different - the implementation needs to also include composited descendants that
 // don't paint into their own backing, and instead paint into this backing.
 bool CompositedLayerMapping::hasVisibleNonCompositingDescendantLayers() const
 {
     return hasVisibleNonCompositingDescendant(m_owningLayer);
 }
 
-bool CompositedLayerMapping::containsPaintedContent() const
+bool CompositedLayerMapping::containsPaintedContent(bool isSimpleContainer) const
 {
-    if (paintsIntoCompositedAncestor() || m_artificiallyInflatedBounds || m_owningLayer->isReflection())
+    if (isSimpleContainer || paintsIntoCompositedAncestor() || m_artificiallyInflatedBounds || m_owningLayer->isReflection())
         return false;
 
     if (isDirectlyCompositedImage())
         return false;
 
-    RenderObject* renderObject = renderer();
     // FIXME: we could optimize cases where the image, video or canvas is known to fill the border box entirely,
     // and set background color on the layer in that case, instead of allocating backing store and painting.
-    if (renderObject->isVideo() && toRenderVideo(renderer())->shouldDisplayVideo())
+    if (renderer()->isVideo() && toRenderVideo(renderer())->shouldDisplayVideo())
         return m_owningLayer->hasBoxDecorationsOrBackground();
 
-    if (m_owningLayer->hasVisibleBoxDecorations())
-        return true;
-
-    if (renderObject->hasMask()) // masks require special treatment
-        return true;
-
-    if (renderObject->isReplaced() && !isCompositedPlugin(renderObject))
-        return true;
-
-    if (renderObject->isRenderRegion())
-        return true;
-
-    if (renderObject->node() && renderObject->node()->isDocumentNode() && renderObject->document().documentElement()) {
-        // Look to see if the root object has a non-simple background
-        RenderObject* rootObject = renderObject->document().documentElement()->renderer();
-        RenderStyle* style = rootObject->style();
-
-        // 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 true;
-
-        // Now look at the body's renderer.
-        HTMLElement* body = renderObject->document().body();
-        RenderObject* bodyObject = (body && body->hasLocalName(bodyTag)) ? body->renderer() : 0;
-        if (bodyObject) {
-            style = bodyObject->style();
-            if (hasBoxDecorationsOrBackgroundImage(style))
-                return true;
-        }
-    }
-
-    // FIXME: it's O(n^2). A better solution is needed.
-    return paintsChildren();
+    return true;
 }
 
 // An image can be directly compositing if it's the sole content of the layer, and has no box decorations
 // that require painting. Direct compositing saves backing store.
 bool CompositedLayerMapping::isDirectlyCompositedImage() const
 {
     RenderObject* renderObject = renderer();
 
     if (!renderObject->isImage() || m_owningLayer->hasBoxDecorationsOrBackground() || renderObject->hasClip())
         return false;
@@ skipping 35 matching lines @@
     Image* image = cachedImage->imageForRenderer(imageRenderer);
     if (!image)
         return;
 
     // We have to wait until the image is fully loaded before setting it on the layer.
     if (!cachedImage->isLoaded())
         return;
 
     // This is a no-op if the layer doesn't have an inner layer for the image.
     m_graphicsLayer->setContentsToImage(image);
-    updateDrawsContent();
+    bool isSimpleContainer = false;
+    updateDrawsContent(isSimpleContainer);
 
     // 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
     // image will keep animating, even if its layer is not visible.
     image->startAnimation();
 }
 
 FloatPoint3D CompositedLayerMapping::computeTransformOrigin(const IntRect& borderBox) const
 {
     RenderStyle* style = renderer()->style();
@@ skipping 26 matching lines @@
     return LayoutSize(-m_compositedBounds.x(), -m_compositedBounds.y());
 }
 
 LayoutRect CompositedLayerMapping::contentsBox() const
 {
     LayoutRect contentsBox = contentsRect(renderer());
     contentsBox.move(contentOffsetInCompostingLayer());
     return contentsBox;
 }
 
+IntRect CompositedLayerMapping::backgroundBox() const
+{
+    LayoutRect backgroundBox = backgroundRect(renderer());
+    backgroundBox.move(contentOffsetInCompostingLayer());
+    return pixelSnappedIntRect(backgroundBox);
+}
+
 GraphicsLayer* CompositedLayerMapping::parentForSublayers() const
 {
     if (m_scrollingContentsLayer)
         return m_scrollingContentsLayer.get();
 
     if (m_childContainmentLayer)
         return m_childContainmentLayer.get();
 
     if (m_childTransformLayer)
         return m_childTransformLayer.get();
@@ skipping 387 matching lines @@
     } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
         name = "Scrolling Contents Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore