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 17 matching lines @@
 #include "core/paint/ThemePainter.h"
 #include "platform/LengthFunctions.h"
 #include "platform/geometry/LayoutPoint.h"
 #include "platform/geometry/LayoutRectOutsets.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "platform/graphics/paint/CompositingDisplayItem.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 
+namespace {
+
+bool isPaintingBackgroundOfPaintContainerIntoScrollingContentsLayer(const LayoutBoxModelObject* obj, const PaintInfo& paintInfo)
+{
+    return paintInfo.paintFlags() & PaintLayerPaintingOverflowContents
+        && !(paintInfo.paintFlags() & PaintLayerPaintingCompositingBackgroundPhase)
+        && obj == paintInfo.paintContainer();
+}
+
+} // namespace
+
 void BoxPainter::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     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 (isPaintingBackgroundOfPaintContainerIntoScrollingContentsLayer(&m_layoutBox, paintInfo)) {
+        // For the case where we are painting the background into the scrolling contents layer
+        // of a composited scroller we need to include the entire overflow rect.
+        paintRect = m_layoutBox.layoutOverflowRect();
+        paintRect.move(-m_layoutBox.scrolledContentOffset());
+
+        // 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()));
+    } else {
+        paintRect = m_layoutBox.borderBoxRect();
+    }
+
     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 = isPaintingBackgroundOfPaintContainerIntoScrollingContentsLayer(&m_layoutBox, paintInfo)
+        ? m_layoutBox.layoutOverflowRect()
+        : m_layoutBox.selfVisualOverflowRect();
     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 paintingOverflowContents = isPaintingBackgroundOfPaintContainerIntoScrollingContentsLayer(&m_layoutBox, paintInfo);
     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 (!paintingOverflowContents) {
+        // 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
+        && (!paintInfo.skipRootBackground()
+            || paintInfo.paintContainer() != &m_layoutBox);
+    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 (!paintingOverflowContents) {
+        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) {
+    if (info.isClippedWithLocalScrolling && !isPaintingBackgroundOfPaintContainerIntoScrollingContentsLayer(&obj, paintInfo)) {
         // 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