Drop background color optimization for composited layers

Source/core/rendering/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 326 matching lines @@
     if (hasAncestorClippingLayer && clippingAncestorIsScrollParent)
         return false;
 
     return true;
 }
 
 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);
 
     // 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(isSimpleContainerCompositingLayer());
+    updateBackgroundColor();
 
     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 100 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 200 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(isSimpleContainer);
-    updateBackgroundColor(isSimpleContainer);
-    updateDrawsContent(isSimpleContainer);
+    updateContentsRect();
+    updateBackgroundColor();
+    updateDrawsContent();
     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(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.
         // 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(isSimpleContainer);
+    bool hasPaintedContent = containsPaintedContent();
     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(bool isSimpleContainer)
+void CompositedLayerMapping::updateBackgroundColor()
 {
-    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;
+    m_graphicsLayer->setBackgroundColor(rendererBackgroundColor());
 }
 
 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
+// Check if RenderLayer which has visible content to render.
+// It may have its own visible content, or its children composited into its own backing store.
+bool CompositedLayerMapping::paintsIntoOwningLayer() 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
         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;
+            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)
             return false;
 
         style = bodyObject->style();
 
         if (hasBoxDecorationsOrBackgroundImage(style))
-            return false;
+            return true;
     }
-
-    return true;
+    return false;
 }
 
 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
@@ skipping 21 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(bool isSimpleContainer) const
+bool CompositedLayerMapping::containsPaintedContent() const
 {
-    if (isSimpleContainer || paintsIntoCompositedAncestor() || m_artificiallyInflatedBounds || m_owningLayer->isReflection())
+    if (!paintsIntoOwningLayer() || paintsIntoCompositedAncestor() || m_artificiallyInflatedBounds || m_owningLayer->isReflection())

[dshwang, 2014/02/25 18:44:49]

I guess isSimpleContainerCompositingLayer() was implemented to check the given
layer can be background-color layer. However this method abuses
isSimpleContainerCompositingLayer() for other purpose.
In this CL, I don't change isSimpleContainerCompositingLayer() logic except for
renaming to paintsIntoOwningLayer(). I guess paintsIntoOwningLayer() needs
refactoring.

         return false;
 
     if (isDirectlyCompositedImage())
         return false;
 
     // 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 (renderer()->isVideo() && toRenderVideo(renderer())->shouldDisplayVideo())
         return m_owningLayer->hasBoxDecorationsOrBackground();
 
@@ skipping 46 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);
-    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
     // 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 451 matching lines @@
     } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
         name = "Scrolling Contents Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore