Paint local background colors onto foreground layer.

third_party/WebKit/Source/core/paint/BoxPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/BoxPainter.h"
 
 #include "core/HTMLNames.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/layout/ImageQualityController.h"
@@ skipping 28 matching lines @@
 {
     LayoutPoint adjustedPaintOffset = paintOffset + m_layoutBox.location();
     // Default implementation. Just pass paint through to the children.
     PaintInfo childInfo(paintInfo);
     for (LayoutObject* child = m_layoutBox.slowFirstChild(); child; child = child->nextSibling())
         child->paint(childInfo, adjustedPaintOffset);
 }
 
 void BoxPainter::paintBoxDecorationBackground(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
-    LayoutRect paintRect = m_layoutBox.borderBoxRect();
+    LayoutRect paintRect;
+    if ((paintInfo.paintFlags() & PaintLayerPaintingCompositingBackgroundPhase)
+        || !(paintInfo.paintFlags() & PaintLayerPaintingBackgroundOntoForeground)) {
+        paintRect = m_layoutBox.borderBoxRect();
+    } else {
+        // Need to include overflow when drawing into the scrolling contents layer.
+        paintRect = m_layoutBox.layoutOverflowRect();
+        paintRect.move(-m_layoutBox.scrolledContentOffset());

[bokan, 2016/07/29 19:22:54]

I hit the ASSERTs in LayoutBox::scrolledContentOffset here on
http://bokan.ca/rootscroller.html (while painting a #greenbox). The reason is
that we end up in here even though the box being painted doesn't have overflow.
Doing this inside an if(m_layoutBox.hasOverflowClip()) seems to work but I think
the root problem is that we got here at all;  the box has background-attachment:
scroll but paintFlags has "BackgroundOntoForeground" set which I think shouldn't
happen in this patch.

I'm guessing that we're not clearing the flag in paintInfo properly as we paint
the children of the scrolling layer. OTOH, since the LayoutObjects in the
scrolling contents layer aren't getting painted into their own layer, perhaps
this is ok and the 'if' is all we need. I'm just starting to dabble in this area
so hopefully this made sense...

[flackr, 2016/07/29 19:28:17]

I think this is already fixed in the latest patch. The problem was that this
patch still propagates PaintLayerPaintingBackgroundOntoForeground to children
but shouldn't.

+
+        // The background painting code assumes that the borders are part of the paintRect so we
+        // expand the paintRect by the border size when painting the background into the
+        // scrolling contents layer.
+        paintRect.expandEdges(
+            LayoutUnit(m_layoutBox.borderTop()),
+            LayoutUnit(m_layoutBox.borderRight()),
+            LayoutUnit(m_layoutBox.borderBottom()),
+            LayoutUnit(m_layoutBox.borderLeft()));
+    }
+
     paintRect.moveBy(paintOffset);
     paintBoxDecorationBackgroundWithRect(paintInfo, paintOffset, paintRect);
 }
 
-LayoutRect BoxPainter::boundsForDrawingRecorder(const LayoutPoint& adjustedPaintOffset)
+LayoutRect BoxPainter::boundsForDrawingRecorder(const PaintInfo& paintInfo, const LayoutPoint& adjustedPaintOffset)
 {
-    LayoutRect bounds = m_layoutBox.selfVisualOverflowRect();
+    LayoutRect bounds =
+        (paintInfo.paintFlags() & PaintLayerPaintingCompositingBackgroundPhase
+            || !(paintInfo.paintFlags() & PaintLayerPaintingBackgroundOntoForeground))
+        ? m_layoutBox.selfVisualOverflowRect()
+        : m_layoutBox.layoutOverflowRect();
     bounds.moveBy(adjustedPaintOffset);
     return bounds;
 }
 
 namespace {
 
 bool bleedAvoidanceIsClipping(BackgroundBleedAvoidance bleedAvoidance)
 {
     return bleedAvoidance == BackgroundBleedClipOnly || bleedAvoidance == BackgroundBleedClipLayer;
 }
 
 } // anonymous namespace
 
 void BoxPainter::paintBoxDecorationBackgroundWithRect(const PaintInfo& paintInfo, const LayoutPoint& paintOffset, const LayoutRect& paintRect)
 {
+    bool paintBackgroundOnly = !(paintInfo.paintFlags() & PaintLayerPaintingCompositingBackgroundPhase)
+        && (paintInfo.paintFlags() & PaintLayerPaintingBackgroundOntoForeground);
     const ComputedStyle& style = m_layoutBox.styleRef();
 
     // FIXME: For now we don't have notification on media buffered range change from media player
     // and miss paint invalidation on buffered range change. crbug.com/484288.
     Optional<DisplayItemCacheSkipper> cacheSkipper;
     if (style.appearance() == MediaSliderPart)
         cacheSkipper.emplace(paintInfo.context);
 
     if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(paintInfo.context, m_layoutBox, DisplayItem::BoxDecorationBackground))
         return;
 
-    LayoutObjectDrawingRecorder recorder(paintInfo.context, m_layoutBox, DisplayItem::BoxDecorationBackground, boundsForDrawingRecorder(paintOffset));
+    LayoutObjectDrawingRecorder recorder(paintInfo.context, m_layoutBox, DisplayItem::BoxDecorationBackground, boundsForDrawingRecorder(paintInfo, paintOffset));
 
     BoxDecorationData boxDecorationData(m_layoutBox);
+    GraphicsContextStateSaver stateSaver(paintInfo.context, false);
 
-    // FIXME: Should eventually give the theme control over whether the box shadow should paint, since controls could have
-    // custom shadows of their own.
-    if (!m_layoutBox.boxShadowShouldBeAppliedToBackground(boxDecorationData.bleedAvoidance))
-        paintBoxShadow(paintInfo, paintRect, style, Normal);
+    if (!paintBackgroundOnly) {
+        // FIXME: Should eventually give the theme control over whether the box shadow should paint, since controls could have
+        // custom shadows of their own.
+        if (!m_layoutBox.boxShadowShouldBeAppliedToBackground(boxDecorationData.bleedAvoidance)) {
+            paintBoxShadow(paintInfo, paintRect, style, Normal);
+        }
 
-    GraphicsContextStateSaver stateSaver(paintInfo.context, false);
-    if (bleedAvoidanceIsClipping(boxDecorationData.bleedAvoidance)) {
-        stateSaver.save();
-        FloatRoundedRect border = style.getRoundedBorderFor(paintRect);
-        paintInfo.context.clipRoundedRect(border);
+        if (bleedAvoidanceIsClipping(boxDecorationData.bleedAvoidance)) {
+            stateSaver.save();
+            FloatRoundedRect border = style.getRoundedBorderFor(paintRect);
+            paintInfo.context.clipRoundedRect(border);
 
-        if (boxDecorationData.bleedAvoidance == BackgroundBleedClipLayer)
-            paintInfo.context.beginLayer();
+            if (boxDecorationData.bleedAvoidance == BackgroundBleedClipLayer)
+                paintInfo.context.beginLayer();
+        }
     }
 
     // If we have a native theme appearance, paint that before painting our background.
     // The theme will tell us whether or not we should also paint the CSS background.
     IntRect snappedPaintRect(pixelSnappedIntRect(paintRect));
     ThemePainter& themePainter = LayoutTheme::theme().painter();
     bool themePainted = boxDecorationData.hasAppearance && !themePainter.paint(m_layoutBox, paintInfo, snappedPaintRect);
-    if (!themePainted) {
+    bool shouldPaintBackground = !themePainted
+        && (paintBackgroundOnly || !(paintInfo.paintFlags() & PaintLayerPaintingBackgroundOntoForeground));
+    if (shouldPaintBackground) {
         paintBackground(paintInfo, paintRect, boxDecorationData.backgroundColor, boxDecorationData.bleedAvoidance);
 
         if (boxDecorationData.hasAppearance)
             themePainter.paintDecorations(m_layoutBox, paintInfo, snappedPaintRect);
     }
-    paintBoxShadow(paintInfo, paintRect, style, Inset);
 
-    // The theme will tell us whether or not we should also paint the CSS border.
-    if (boxDecorationData.hasBorderDecoration
-        && (!boxDecorationData.hasAppearance || (!themePainted && LayoutTheme::theme().painter().paintBorderOnly(m_layoutBox, paintInfo, snappedPaintRect)))
-        && !(m_layoutBox.isTable() && toLayoutTable(&m_layoutBox)->collapseBorders()))
-        paintBorder(m_layoutBox, paintInfo, paintRect, style, boxDecorationData.bleedAvoidance);
+    if (!paintBackgroundOnly) {
+        paintBoxShadow(paintInfo, paintRect, style, Inset);
+
+        // The theme will tell us whether or not we should also paint the CSS border.
+        if (boxDecorationData.hasBorderDecoration
+            && (!boxDecorationData.hasAppearance || (!themePainted && LayoutTheme::theme().painter().paintBorderOnly(m_layoutBox, paintInfo, snappedPaintRect)))
+            && !(m_layoutBox.isTable() && toLayoutTable(&m_layoutBox)->collapseBorders())) {
+            paintBorder(m_layoutBox, paintInfo, paintRect, style, boxDecorationData.bleedAvoidance);
+        }
+    }
 
     if (boxDecorationData.bleedAvoidance == BackgroundBleedClipLayer)
         paintInfo.context.endLayer();
 }
 
 void BoxPainter::paintBackground(const PaintInfo& paintInfo, const LayoutRect& paintRect, const Color& backgroundColor, BackgroundBleedAvoidance bleedAvoidance)
 {
     if (m_layoutBox.isDocumentElement())
         return;
     if (m_layoutBox.backgroundStolenForBeingBody())
@@ skipping 369 matching lines @@
         clipToBorder.emplace(obj, paintInfo, rect, border, ApplyToContext);
     }
 
     int bLeft = info.includeLeftEdge ? obj.borderLeft() : 0;
     int bRight = info.includeRightEdge ? obj.borderRight() : 0;
     LayoutUnit pLeft = info.includeLeftEdge ? obj.paddingLeft() : LayoutUnit();
     LayoutUnit pRight = info.includeRightEdge ? obj.paddingRight() : LayoutUnit();
 
     GraphicsContextStateSaver clipWithScrollingStateSaver(context, info.isClippedWithLocalScrolling);
     LayoutRect scrolledPaintRect = rect;
-    if (info.isClippedWithLocalScrolling) {
+    bool isPaintingScrollingContentsLayer = !(paintInfo.paintFlags() & PaintLayerPaintingCompositingBackgroundPhase)
+        && paintInfo.paintFlags() & PaintLayerPaintingBackgroundOntoForeground;
+    if (info.isClippedWithLocalScrolling && !isPaintingScrollingContentsLayer) {
         // Clip to the overflow area.
         const LayoutBox& thisBox = toLayoutBox(obj);
         // TODO(chrishtr): this should be pixel-snapped.
         context.clip(FloatRect(thisBox.overflowClipRect(rect.location())));
 
         // Adjust the paint rect to reflect a scrolled content box with borders at the ends.
         IntSize offset = thisBox.scrolledContentOffset();
         scrolledPaintRect.move(-offset);
         scrolledPaintRect.setWidth(bLeft + thisBox.scrollWidth() + bRight);
         scrolledPaintRect.setHeight(thisBox.borderTop() + thisBox.scrollHeight() + thisBox.borderBottom());
@@ skipping 300 matching lines @@
     }
 }
 
 bool BoxPainter::shouldForceWhiteBackgroundForPrintEconomy(const ComputedStyle& style, const Document& document)
 {
     return document.printing() && style.getPrintColorAdjust() == PrintColorAdjustEconomy
         && (!document.settings() || !document.settings()->shouldPrintBackgrounds());
 }
 
 } // namespace blink