Paint local attachment backgrounds into composited scrolling contents 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)
+        || !m_layoutBox.scrollsOverflow()) {
+        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());
+    }
+
     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
+        ? 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);
 
     // 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))
+    if (!paintBackgroundOnly

[Stephen Chennney, 2016/07/27 22:33:36]

You can have 1 if and put both of the remaining blocks inside it.

[flackr, 2016/07/28 14:39:20]

Done.

+        && !m_layoutBox.boxShadowShouldBeAppliedToBackground(boxDecorationData.bleedAvoidance)) {
         paintBoxShadow(paintInfo, paintRect, style, Normal);
+    }
 
     GraphicsContextStateSaver stateSaver(paintInfo.context, false);
-    if (bleedAvoidanceIsClipping(boxDecorationData.bleedAvoidance)) {
+    if (!paintBackgroundOnly

[Stephen Chennney, 2016/07/27 22:33:36]

i.e unify this if with the one above.

[flackr, 2016/07/28 14:39:20]

Done.

+        && bleedAvoidanceIsClipping(boxDecorationData.bleedAvoidance)) {
         stateSaver.save();
         FloatRoundedRect border = style.getRoundedBorderFor(paintRect);
         paintInfo.context.clipRoundedRect(border);
 
         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.paintFlags() & PaintLayerPaintingCompositingForegroundPhase
+            || !(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);
+
+    if (!paintBackgroundOnly)

[Stephen Chennney, 2016/07/27 22:33:36]

And here too.

[flackr, 2016/07/28 14:39:20]

Done.

+        paintBoxShadow(paintInfo, paintRect, style, Inset);
 
     // The theme will tell us whether or not we should also paint the CSS border.
-    if (boxDecorationData.hasBorderDecoration
+    if (!paintBackgroundOnly
+        && boxDecorationData.hasBorderDecoration
         && (!boxDecorationData.hasAppearance || (!themePainted && LayoutTheme::theme().painter().paintBorderOnly(m_layoutBox, paintInfo, snappedPaintRect)))
-        && !(m_layoutBox.isTable() && toLayoutTable(&m_layoutBox)->collapseBorders()))
+        && !(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 340 matching lines @@
 
     const FillLayerInfo info(obj, color, bgLayer, bleedAvoidance, box);
     Optional<BackgroundImageGeometry> geometry;
 
     // Fast path for drawing simple color backgrounds.
     if (paintFastBottomLayer(obj, paintInfo, info, bgLayer, rect, bleedAvoidance, box, boxSize, op,
         backgroundObject, geometry)) {
         return;
     }
 
+    bool avoidBorder = paintInfo.paintFlags() & PaintLayerPaintingCompositingBackgroundPhase;
     Optional<RoundedInnerRectClipper> clipToBorder;
     if (info.isRoundedFill) {
         FloatRoundedRect border = info.isBorderFill
             ? backgroundRoundedRectAdjustedForBleedAvoidance(obj, rect, bleedAvoidance, box, boxSize, info.includeLeftEdge, info.includeRightEdge)
             : getBackgroundRoundedRect(obj, rect, box, boxSize.width(), boxSize.height(), info.includeLeftEdge, info.includeRightEdge);
 
         // Clip to the padding or content boxes as necessary.
         if (bgLayer.clip() == ContentFillBox) {
             border = obj.style()->getRoundedInnerBorderFor(LayoutRect(border.rect()),
                 LayoutRectOutsets(
-                    -(obj.paddingTop() + obj.borderTop()),
-                    -(obj.paddingRight() + obj.borderRight()),
-                    -(obj.paddingBottom() + obj.borderBottom()),
-                    -(obj.paddingLeft() + obj.borderLeft())),
+                    -(obj.paddingTop() + (avoidBorder ? obj.borderTop() : 0)),
+                    -(obj.paddingRight() + (avoidBorder ? obj.borderRight() : 0)),
+                    -(obj.paddingBottom() + (avoidBorder ? obj.borderBottom() : 0)),
+                    -(obj.paddingLeft() + (avoidBorder ? obj.borderLeft() : 0))),
                 info.includeLeftEdge, info.includeRightEdge);
         } else if (bgLayer.clip() == PaddingFillBox) {
             border = obj.style()->getRoundedInnerBorderFor(LayoutRect(border.rect()), info.includeLeftEdge, info.includeRightEdge);
         }
 
         clipToBorder.emplace(obj, paintInfo, rect, border, ApplyToContext);
     }
 
-    int bLeft = info.includeLeftEdge ? obj.borderLeft() : 0;
-    int bRight = info.includeRightEdge ? obj.borderRight() : 0;
+    int bLeft = info.includeLeftEdge && avoidBorder ? obj.borderLeft() : 0;
+    int bRight = info.includeRightEdge && avoidBorder ? 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 && paintInfo.paintFlags() & PaintLayerPaintingCompositingBackgroundPhase) {
         // 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());
+        scrolledPaintRect.setHeight((avoidBorder ? thisBox.borderTop() : 0) + thisBox.scrollHeight() + (avoidBorder ? thisBox.borderBottom() : 0));
     }
 
     GraphicsContextStateSaver backgroundClipStateSaver(context, false);
     IntRect maskRect;
 
     switch (bgLayer.clip()) {
     case PaddingFillBox:
     case ContentFillBox: {
         if (info.isRoundedFill)
             break;
 
         // Clip to the padding or content boxes as necessary.
         bool includePadding = bgLayer.clip() == ContentFillBox;
         LayoutRect clipRect(scrolledPaintRect.x() + bLeft + (includePadding ? pLeft : LayoutUnit()),
-            scrolledPaintRect.y() + obj.borderTop() + (includePadding ? obj.paddingTop() : LayoutUnit()),
+            scrolledPaintRect.y() + (avoidBorder ? obj.borderTop() : 0) + (includePadding ? obj.paddingTop() : LayoutUnit()),
             scrolledPaintRect.width() - bLeft - bRight - (includePadding ? pLeft + pRight : LayoutUnit()),
-            scrolledPaintRect.height() - obj.borderTop() - obj.borderBottom() - (includePadding ? obj.paddingTop() + obj.paddingBottom() : LayoutUnit()));
+            scrolledPaintRect.height() - (avoidBorder ? obj.borderTop() + obj.borderBottom() : 0) - (includePadding ? obj.paddingTop() + obj.paddingBottom() : LayoutUnit()));
         backgroundClipStateSaver.save();
         // TODO(chrishtr): this should be pixel-snapped.
         context.clip(FloatRect(clipRect));
 
         break;
     }
     case TextFillBox: {
         // First figure out how big the mask has to be. It should be no bigger than what we need
         // to actually render, so we should intersect the dirty rect with the border box of the background.
         maskRect = pixelSnappedIntRect(rect);
@@ skipping 21 matching lines @@
         if (info.shouldPaintColor || info.shouldPaintShadow)  {
             const ShadowContext shadowContext(context, obj, info.shouldPaintShadow);
             context.fillRect(backgroundRect, info.color);
         }
     }
 
     // no progressive loading of the background image
     if (info.shouldPaintImage) {
         if (!geometry) {
             geometry.emplace();
-            geometry->calculate(obj, paintInfo.paintContainer(), paintInfo.getGlobalPaintFlags(), bgLayer, scrolledPaintRect);
+            geometry->calculate(obj, paintInfo.paintContainer(), paintInfo.getGlobalPaintFlags(), bgLayer, scrolledPaintRect, paintInfo.paintFlags() & PaintLayerPaintingCompositingBackgroundPhase);
         } else {
             // The geometry was calculated in paintFastBottomLayer().
             DCHECK(info.isBottomLayer && info.isBorderFill && !info.isClippedWithLocalScrolling);
         }
 
         if (!geometry->destRect().isEmpty()) {
             const ImagePaintContext imageContext(obj, context, bgLayer, *info.image, op,
                 backgroundObject, geometry->tileSize());
             TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "PaintImage", "data",
                 InspectorPaintImageEvent::data(obj, *info.image));
@@ skipping 231 matching lines @@
     }
 }
 
 bool BoxPainter::shouldForceWhiteBackgroundForPrintEconomy(const ComputedStyle& style, const Document& document)
 {
     return document.printing() && style.getPrintColorAdjust() == PrintColorAdjustEconomy
         && (!document.settings() || !document.settings()->shouldPrintBackgrounds());
 }
 
 } // namespace blink