Split-out change for https://codereview.chromium.org/1145993002/ patch set 11

Source/core/layout/LayoutBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 148 matching lines @@
     }
 
     if (isOutOfFlowPositioned())
         LayoutBlock::removePositionedObject(this);
 }
 
 void LayoutBox::styleWillChange(StyleDifference diff, const ComputedStyle& newStyle)
 {
     const ComputedStyle* oldStyle = style();
     if (oldStyle) {
-        // The background of the root element or the body element could propagate up to
-        // the canvas. Just dirty the entire canvas when our style changes substantially.
-        if ((diff.needsPaintInvalidation() || diff.needsLayout()) && node()
-            && (isHTMLHtmlElement(*node()) || isHTMLBodyElement(*node()))) {
-            view()->setShouldDoFullPaintInvalidation();
-
-            if (oldStyle->hasEntirelyFixedBackground() != newStyle.hasEntirelyFixedBackground())
-                view()->compositor()->setNeedsUpdateFixedBackground();
-        }
-
         // When a layout hint happens and an object's position style changes, we have to do a layout
         // to dirty the layout tree using the old position value now.
         if (diff.needsFullLayout() && parent() && oldStyle->position() != newStyle.position()) {
             markContainerChainForLayout();
             if (oldStyle->position() == StaticPosition)
                 setShouldDoFullPaintInvalidation();
             else if (newStyle.hasOutOfFlowPosition())
                 parent()->setChildNeedsLayout();
             if (isFloating() && !isOutOfFlowPositioned() && newStyle.hasOutOfFlowPosition())
                 removeFloatingOrPositionedChildFromBlockLists();
@@ skipping 3729 matching lines @@
         return invalidationReason;
 
     // If the transform is not identity or translation, incremental invalidation is not applicable
     // because the difference between oldBounds and newBounds doesn't cover all area needing invalidation.
     // FIXME: Should also consider ancestor transforms since paintInvalidationContainer. crbug.com/426111.
     if (invalidationReason == PaintInvalidationIncremental
         && paintInvalidationContainer != this
         && hasLayer() && layer()->transform() && !layer()->transform()->isIdentityOrTranslation())
         return PaintInvalidationBoundsChange;
 
-    if (!style()->hasBackground() && !style()->hasBoxDecorations()) {
+    bool paintsBackground = style()->hasBackground() && !isDocumentElement() && !backgroundStolenForBeingBody();
+    if (!paintsBackground && !style()->hasBoxDecorations()) {
         // We could let incremental invalidation cover non-composited scrollbars, but just
         // do a full invalidation because incremental invalidation will go away with slimming paint.
         if (invalidationReason == PaintInvalidationIncremental && hasNonCompositedScrollbars())
             return PaintInvalidationBorderBoxChange;
         return invalidationReason;
     }
 
-    if (style()->backgroundLayers().thisOrNextLayersUseContentBox() || style()->maskLayers().thisOrNextLayersUseContentBox()) {
+    if (paintsBackground && (style()->backgroundLayers().thisOrNextLayersUseContentBox() || style()->maskLayers().thisOrNextLayersUseContentBox())) {
         LayoutRect oldContentBoxRect = m_rareData ? m_rareData->m_previousContentBoxRect : LayoutRect();
         LayoutRect newContentBoxRect = contentBoxRect();
         if (oldContentBoxRect != newContentBoxRect)
             return PaintInvalidationContentBoxChange;
     }
 
-    if (style()->backgroundLayers().thisOrNextLayersHaveLocalAttachment()) {
+    if (paintsBackground && style()->backgroundLayers().thisOrNextLayersHaveLocalAttachment()) {
         LayoutRect oldLayoutOverflowRect = m_rareData ? m_rareData->m_previousLayoutOverflowRect : LayoutRect();
         LayoutRect newLayoutOverflowRect = layoutOverflowRect();
-        if (oldLayoutOverflowRect != newLayoutOverflowRect)
-            return PaintInvalidationLayoutOverflowBoxChange;
+        if (oldLayoutOverflowRect != newLayoutOverflowRect) {
+            // Background positioning for the LayoutView are based on the box of the root element.
+            // Whether full invalidation is needed will be checked with special logic in
+            // LayoutView::invalidatePaintIfNeeded. Here we only need to guarantee incremental
+            // painting is done for newly expanded area.
+            if (!isLayoutView())
+                return PaintInvalidationLayoutOverflowBoxChange;
+            if (invalidationReason < PaintInvalidationIncremental)
+                invalidationReason = PaintInvalidationIncremental;
+        }
     }
 
     LayoutSize oldBorderBoxSize = computePreviousBorderBoxSize(oldBounds.size());
     LayoutSize newBorderBoxSize = size();
 
     if (oldBorderBoxSize == newBorderBoxSize)
         return invalidationReason;
 
     // See another hasNonCompositedScrollbars() callsite above.
     if (hasNonCompositedScrollbars())
         return PaintInvalidationBorderBoxChange;
 
     if (style()->hasVisualOverflowingEffect() || style()->hasAppearance() || style()->hasFilter() || style()->resize() != RESIZE_NONE)
         return PaintInvalidationBorderBoxChange;
 
     if (style()->hasBorderRadius()) {
         // If a border-radius exists and width/height is smaller than radius width/height,
         // we need to fully invalidate to cover the changed radius.
         FloatRoundedRect oldRoundedRect = style()->getRoundedBorderFor(LayoutRect(LayoutPoint(0, 0), oldBorderBoxSize));
         FloatRoundedRect newRoundedRect = style()->getRoundedBorderFor(LayoutRect(LayoutPoint(0, 0), newBorderBoxSize));
         if (oldRoundedRect.radii() != newRoundedRect.radii())
             return PaintInvalidationBorderBoxChange;
     }
 
+    if (!paintsBackground)
+        return invalidationReason;
+
     if (oldBorderBoxSize.width() != newBorderBoxSize.width() && mustInvalidateBackgroundOrBorderPaintOnWidthChange())
         return PaintInvalidationBorderBoxChange;
     if (oldBorderBoxSize.height() != newBorderBoxSize.height() && mustInvalidateBackgroundOrBorderPaintOnHeightChange())
         return PaintInvalidationBorderBoxChange;
-
     return PaintInvalidationIncremental;
 }
 
 void LayoutBox::incrementallyInvalidatePaint(const LayoutBoxModelObject& paintInvalidationContainer, const LayoutRect& oldBounds, const LayoutRect& newBounds, const LayoutPoint& positionFromPaintInvalidationBacking)
 {
     LayoutObject::incrementallyInvalidatePaint(paintInvalidationContainer, oldBounds, newBounds, positionFromPaintInvalidationBacking);
 
     bool hasBoxDecorations = style()->hasBoxDecorations();
     if (!style()->hasBackground() && !hasBoxDecorations)
         return;
@@ skipping 690 matching lines @@
     computedValues.m_margins.m_start = marginStart();
     computedValues.m_margins.m_end = marginEnd();
 
     setLogicalTop(oldLogicalTop);
     setLogicalWidth(oldLogicalWidth);
     setLogicalLeft(oldLogicalLeft);
     setMarginLeft(oldMarginLeft);
     setMarginRight(oldMarginRight);
 }
 
-inline bool LayoutBox::mustInvalidateFillLayersPaintOnWidthChange(const FillLayer& layer) const
+bool LayoutBox::mustInvalidateFillLayersPaintOnWidthChange(const FillLayer& layer) const
 {
     // Nobody will use multiple layers without wanting fancy positioning.
     if (layer.next())
         return true;
 
     // Make sure we have a valid image.
     StyleImage* img = layer.image();
     if (!img || !img->canRender(*this, style()->effectiveZoom()))
         return false;
 
@@ skipping 66 matching lines @@
 bool LayoutBox::canRenderBorderImage() const
 {
     if (!style()->hasBorderDecoration())
         return false;
 
     StyleImage* borderImage = style()->borderImage().image();
     return borderImage && borderImage->canRender(*this, style()->effectiveZoom()) && borderImage->isLoaded();
 }
 
 } // namespace blink