Paint local background colors onto foreground layer.

third_party/WebKit/Source/core/layout/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 291 matching lines @@
         if (!context->hasAlpha())
             m_graphicsLayer->setContentsOpaque(true);
         else if (WebLayer* layer = context->platformLayer())
             m_graphicsLayer->setContentsOpaque(!Color(layer->backgroundColor()).hasAlpha());
         else
             m_graphicsLayer->setContentsOpaque(false);
     } else if (m_backgroundLayer) {
         m_graphicsLayer->setContentsOpaque(false);
         m_backgroundLayer->setContentsOpaque(m_owningLayer.backgroundIsKnownToBeOpaqueInRect(compositedBounds()));
     } else {
-        // For non-root layers, background is always painted by the primary graphics layer.
+        // For non-root layers, background is painted by the scrolling contents layer if all backgrounds
+        // are background attachment local, otherwise background is painted by the primary graphics layer.

[chrishtr, 2016/07/29 21:04:34]

Even with this CL, doesn't m_graphicsLayer still paint its background?

[flackr, 2016/08/02 16:58:14]

No, it's either painted into m_scrollingContentsLayer or m_graphicsLayer (the
condition in shouldPaintBackground excludes it if we're painting the background
layer with PaintsBackgroundOntoForeground set). m_graphicsLayer will however
always paint the border. We'll probably want to have exceptions to this (like
when you have an opaque color non-local border-box background with alpha
transparent border) however until this case is handled I didn't think it was
worth risking the cost of double-painting the background which will never be
seen.

[chrishtr, 2016/08/03 18:58:00]

1. I don't see this exclusion in the current patch. The logic is:

 bool shouldPaintBackground = shouldPaintContent && !selectionOnly
            && (shouldPaintBackgroundOntoForeground ||
isPaintingCompositedBackground);

Where does this exclude? It is true only more often than before.

2. If the background is not painted onto the background or m_graphicsLayer
layers, then won't their opaqueness bit be invalid?

[flackr, 2016/08/03 20:58:52]

We always paint the border and shadows into the m_graphicsLayer, but in
BoxPainter.cpp these lines should only paint the actual background into one of
the layers:
bool paintBackgroundOnly = !(paintInfo.paintFlags() &
PaintLayerPaintingCompositingBackgroundPhase)
        && (paintInfo.paintFlags() &
PaintLayerPaintingRootBackgroundOntoForeground);
bool shouldPaintBackground = !themePainted
    && (paintBackgroundOnly || !(paintInfo.paintFlags() &
PaintLayerPaintingRootBackgroundOntoForeground));

Basically paintBackgroundOnly should be true when we're painting onto the
composited foreground, and the painting into background layer only happens when
we are not going to paint into the composited foreground.
Yes, it's a bit of a lie but only for a region which is completely obscured.
I.e. we don't paint the background region but it should be covered up completely
by the opaque scrolling contents layer.

[chrishtr, 2016/08/04 05:20:52]

I still don't see the logic that leads to this...

but in any case, I don't see the harm in painting the background twice. In fact,
it avoids the danger of under-painting layers
which must be opaque. Is there a downside?

+        if (hasScrollingLayer() && m_owningLayer.shouldPaintBackgroundOntoForeground()) {
+            // Backgrounds painted onto the foreground are clipped by the padding box rect.
+            // TODO(flackr): This should actually check the entire overflow rect within the
+            // scrolling contents layer but since we currently only trigger this for solid
+            // color backgrounds the answer will be the same.
+            m_scrollingContentsLayer->setContentsOpaque(m_owningLayer.backgroundIsKnownToBeOpaqueInRect(toLayoutBox(layoutObject())->paddingBoxRect()));
+        }
+        // The border is always painted into the m_graphicsLayer, so we check if it is known to be
+        // opaque separately.
         m_graphicsLayer->setContentsOpaque(m_owningLayer.backgroundIsKnownToBeOpaqueInRect(compositedBounds()));
     }
 }
 
 void CompositedLayerMapping::updateCompositedBounds()
 {
     ASSERT(m_owningLayer.compositor()->lifecycle().state() == DocumentLifecycle::InCompositingUpdate);
     // FIXME: if this is really needed for performance, it would be better to store it on Layer.
     m_compositedBounds = m_owningLayer.boundingBoxForCompositing();
     m_contentOffsetInCompositingLayerDirty = true;
@@ skipping 2091 matching lines @@
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintBackground)
         paintLayerFlags |= PaintLayerPaintingCompositingBackgroundPhase;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintForeground)
         paintLayerFlags |= PaintLayerPaintingCompositingForegroundPhase;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintMask)
         paintLayerFlags |= PaintLayerPaintingCompositingMaskPhase;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintChildClippingMask)
         paintLayerFlags |= PaintLayerPaintingChildClippingMaskPhase;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintOverflowContents)
         paintLayerFlags |= PaintLayerPaintingOverflowContents;
-    if (graphicsLayerPaintingPhase & GraphicsLayerPaintCompositedScroll)
+    if (graphicsLayerPaintingPhase & GraphicsLayerPaintCompositedScroll) {
         paintLayerFlags |= PaintLayerPaintingCompositingScrollingPhase;
+        if (m_owningLayer.shouldPaintBackgroundOntoForeground())
+            paintLayerFlags |= PaintLayerPaintingBackgroundOntoForeground;
+    }
 
     if (graphicsLayer == m_backgroundLayer.get())
         paintLayerFlags |= (PaintLayerPaintingRootBackgroundOnly | PaintLayerPaintingCompositingForegroundPhase); // Need PaintLayerPaintingCompositingForegroundPhase to walk child layers.
     else if (compositor()->fixedRootBackgroundLayer())
         paintLayerFlags |= PaintLayerPaintingSkipRootBackground;
 
     if (graphicsLayer == m_graphicsLayer.get()
         || graphicsLayer == m_foregroundLayer.get()
         || graphicsLayer == m_backgroundLayer.get()
         || graphicsLayer == m_maskLayer.get()
@@ skipping 224 matching lines @@
     } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
         name = "Scrolling Contents Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink