Refactor root element background painting

Source/core/layout/LayoutView.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. 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
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 177 matching lines @@
     if (!style()->isHorizontalWritingMode())
         return true;
 
     // The width/height checks below assume horizontal writing mode.
     ASSERT(style()->isHorizontalWritingMode());
 
     if (size().width() != viewLogicalWidthForBoxSizing())
         return true;
 
     if (size().height() != viewLogicalHeightForBoxSizing()) {
-        if (LayoutObject* backgroundLayoutObject = this->backgroundLayoutObject()) {
-            // When background-attachment is 'fixed', we treat the viewport (instead of the 'root'
-            // i.e. html or body) as the background positioning area, and we should full paint invalidation
-            // viewport resize if the background image is not composited and needs full paint invalidation on
-            // background positioning area resize.
-            if (!m_compositor || !m_compositor->needsFixedRootBackgroundLayer(layer())) {
-                if (backgroundLayoutObject->style()->hasFixedBackgroundImage()
-                    && mustInvalidateFillLayersPaintOnHeightChange(backgroundLayoutObject->style()->backgroundLayers()))
-                    return true;
-            }
+        // When background-attachment is 'fixed', we treat the viewport (instead of the 'root'
+        // i.e. html or body) as the background positioning area, and we should full paint invalidation
+        // viewport resize if the background image is not composited and needs full paint invalidation on
+        // background positioning area resize.
+        if (!m_compositor || !m_compositor->needsFixedRootBackgroundLayer(layer())) {
+            if (style()->hasFixedBackgroundImage()
+                && mustInvalidateFillLayersPaintOnHeightChange(style()->backgroundLayers()))
+                return true;
         }
     }
 
     return false;
 }
 
 void LayoutView::layout()
 {
     if (!document().paginated())
         setPageLogicalHeight(0);
 
     if (shouldUsePrintingLayout())
         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = logicalWidth();
 
     SubtreeLayoutScope layoutScope(*this);
 
-    LayoutRect oldLayoutOverflowRect = layoutOverflowRect();
-
     // Use calcWidth/Height to get the new width/height, since this will take the full page zoom factor into account.
     bool relayoutChildren = !shouldUsePrintingLayout() && (!m_frameView
         || logicalWidth() != viewLogicalWidthForBoxSizing()
         || logicalHeight() != viewLogicalHeightForBoxSizing());
     if (relayoutChildren) {
         layoutScope.setChildNeedsLayout(this);
         for (LayoutObject* child = firstChild(); child; child = child->nextSibling()) {
             if (child->isSVGRoot())
                 continue;
 
@@ skipping 11 matching lines @@
     ASSERT(!m_layoutState);
     if (!needsLayout())
         return;
 
     LayoutState rootLayoutState(pageLogicalHeight(), pageLogicalHeightChanged(), *this);
 
     m_pageLogicalHeightChanged = false;
 
     layoutContent();
 
-    if (RuntimeEnabledFeatures::slimmingPaintEnabled() && layoutOverflowRect() != oldLayoutOverflowRect) {
-        // The document element paints the viewport background, so we need to invalidate it when
-        // layout overflow changes.
-        // FIXME: Improve viewport background styling/invalidation/painting. crbug.com/475115
-        if (Element* documentElement = document().documentElement()) {
-            if (LayoutObject* rootObject = documentElement->layoutObject())
-                rootObject->setShouldDoFullPaintInvalidation();
-        }
-    }
-
 #if ENABLE(ASSERT)
     checkLayoutState();
 #endif
     clearNeedsLayout();
 }
 
+void LayoutView::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
+{
+    const ComputedStyle& newStyle = styleRef();
+
+    if (oldStyle && oldStyle->hasEntirelyFixedBackground() != newStyle.hasEntirelyFixedBackground())
+        compositor()->setNeedsUpdateFixedBackground();
+
+    LayoutBlockFlow::styleDidChange(diff, oldStyle);
+}
+
+PaintInvalidationReason LayoutView::invalidatePaintIfNeeded(PaintInvalidationState& paintInvalidationState, const LayoutBoxModelObject& newPaintInvalidationContainer)
+{
+    const LayoutObject* rootObject = document().documentElement() ? document().documentElement()->layoutObject() : nullptr;
+    TransformationMatrix newTransform;
+    LayoutSize newBorderBoxSize;
+    LayoutRect newPaddingBoxRect;
+    LayoutRect newContentBoxRect;
+
+    if (rootObject && rootObject->isBox()) {
+        const LayoutBox& rootBox = toLayoutBox(*rootObject);
+        if (rootBox.hasLayer()) {
+            const DeprecatedPaintLayer& rootLayer = *rootBox.layer();
+            LayoutPoint offset;
+            rootLayer.convertToLayerCoords(nullptr, offset);
+            newTransform.translate(offset.x(), offset.y());
+            newTransform.multiply(rootLayer.currentTransform());
+        }
+        newBorderBoxSize = rootBox.size();
+        newPaddingBoxRect = rootBox.paddingBoxRect();
+        newContentBoxRect = rootBox.contentBoxRect();
+    }
+
+    if (m_previousRootBackgroundPositioning.transform != newTransform)
+        setShouldDoFullPaintInvalidation(PaintInvalidationLocationChange);
+
+    const FillLayer& backgroundLayers = style()->backgroundLayers();
+    if (mustInvalidateFillLayersPaintOnWidthChange(backgroundLayers) || mustInvalidateFillLayersPaintOnHeightChange(backgroundLayers)) {
+        if (m_previousRootBackgroundPositioning.borderBoxSize != newBorderBoxSize
+            || m_previousRootBackgroundPositioning.paddingBoxRect != newPaddingBoxRect
+            || m_previousRootBackgroundPositioning.contentBoxRect != newContentBoxRect) {
+            setShouldDoFullPaintInvalidation(PaintInvalidationBorderBoxChange);
+        }
+    }

[Xianzhu, 2015/06/05 03:44:51]

We don't allow setShouldDoFullPaintInvalidation() during paint invalidation to
prevent invalidation flags set after clearing. Though there is no problem for
LayoutView, the above code looks to me more proper to be executed during
setStyle and layout.

I'm also confused about how root box's border, padding, content box affect
layout view's background painting. Can you explain more?

+
+    m_previousRootBackgroundPositioning.transform = newTransform;
+    m_previousRootBackgroundPositioning.borderBoxSize = newBorderBoxSize;
+    m_previousRootBackgroundPositioning.paddingBoxRect = newPaddingBoxRect;
+    m_previousRootBackgroundPositioning.contentBoxRect = newContentBoxRect;
+
+    return LayoutBox::invalidatePaintIfNeeded(paintInvalidationState, newPaintInvalidationContainer);
+}
+
 void LayoutView::mapLocalToContainer(const LayoutBoxModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed, const PaintInvalidationState* paintInvalidationState) const
 {
     ASSERT_UNUSED(wasFixed, !wasFixed || *wasFixed == static_cast<bool>(mode & IsFixed));
 
     if (!paintInvalidationContainer && mode & UseTransforms && shouldUseTransformFromContainer(0)) {
         TransformationMatrix t;
         getTransformFromContainer(0, LayoutSize(), t);
         transformState.applyTransform(t);
     }
 
@@ skipping 554 matching lines @@
 
 IntRect LayoutView::unscaledDocumentRect() const
 {
     LayoutRect overflowRect(layoutOverflowRect());
     flipForWritingMode(overflowRect);
     return pixelSnappedIntRect(overflowRect);
 }
 
 bool LayoutView::rootBackgroundIsEntirelyFixed() const
 {
-    if (LayoutObject* backgroundLayoutObject = this->backgroundLayoutObject())
-        return backgroundLayoutObject->style()->hasEntirelyFixedBackground();
-    return false;
-}
-
-LayoutObject* LayoutView::backgroundLayoutObject() const
-{
-    if (Element* documentElement = document().documentElement()) {
-        if (LayoutObject* rootObject = documentElement->layoutObject())
-            return rootObject->layoutObjectForRootBackground();
-    }
-    return 0;
+    return style()->hasEntirelyFixedBackground();
 }
 
 LayoutRect LayoutView::backgroundRect(LayoutBox* backgroundLayoutObject) const
 {
     return LayoutRect(unscaledDocumentRect());
 }
 
 IntRect LayoutView::documentRect() const
 {
     FloatRect overflowRect(unscaledDocumentRect());
@@ skipping 105 matching lines @@
     return viewHeight(IncludeScrollbars) / scale;
 }
 
 void LayoutView::willBeDestroyed()
 {
     LayoutBlockFlow::willBeDestroyed();
     m_compositor.clear();
 }
 
 } // namespace blink