[SP] Don't invalidate the whole scrolled tree

Source/core/paint/DeprecatedPaintLayerPainter.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 "config.h"
 #include "core/paint/DeprecatedPaintLayerPainter.h"
 
 #include "core/frame/Settings.h"
 #include "core/layout/ClipPathOperation.h"
 #include "core/layout/LayoutBlock.h"
@@ skipping 405 matching lines @@
 
 void DeprecatedPaintLayerPainter::paintChildren(unsigned childrenToVisit, GraphicsContext* context, const DeprecatedPaintLayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
 {
     if (!m_paintLayer.hasSelfPaintingLayerDescendant())
         return;
 
 #if ENABLE(ASSERT)
     LayerListMutationDetector mutationChecker(m_paintLayer.stackingNode());
 #endif
 
+    IntSize scrollOffsetAccumulation = paintingInfo.scrollOffsetAccumulation;
+    if (m_paintLayer.layoutObject()->hasOverflowClip())
+        scrollOffsetAccumulation += m_paintLayer.layoutBox()->scrolledContentOffset();
+
     DeprecatedPaintLayerStackingNodeIterator iterator(*m_paintLayer.stackingNode(), childrenToVisit);
     while (DeprecatedPaintLayerStackingNode* child = iterator.next()) {
         DeprecatedPaintLayerPainter childPainter(*child->layer());
         // If this Layer should paint into its own backing or a grouped backing, that will be done via CompositedDeprecatedPaintLayerMapping::paintContents()
         // and CompositedDeprecatedPaintLayerMapping::doPaintTask().
         if (!childPainter.shouldPaintLayerInSoftwareMode(paintingInfo, paintFlags))
             continue;
 
+        DeprecatedPaintLayerPaintingInfo childPaintingInfo = paintingInfo;
+        childPaintingInfo.scrollOffsetAccumulation = scrollOffsetAccumulation;
+        // Rare case: accumulate scroll offset of non-stacking-context ancestors up to m_paintLayer.
+        for (DeprecatedPaintLayer* parentLayer = child->layer()->parent(); parentLayer != &m_paintLayer; parentLayer = parentLayer->parent()) {
+            if (parentLayer->layoutObject()->hasOverflowClip())
+                childPaintingInfo.scrollOffsetAccumulation += parentLayer->layoutBox()->scrolledContentOffset();
+        }
+
         if (!child->layer()->isPaginated())
-            childPainter.paintLayer(context, paintingInfo, paintFlags);
+            childPainter.paintLayer(context, childPaintingInfo, paintFlags);
         else
-            childPainter.paintPaginatedChildLayer(context, paintingInfo, paintFlags);
+            childPainter.paintPaginatedChildLayer(context, childPaintingInfo, paintFlags);
     }
 }
 
 // FIXME: inline this.
 static bool paintForFixedRootBackground(const DeprecatedPaintLayer* layer, PaintLayerFlags paintFlags)
 {
     return layer->layoutObject()->isDocumentElement() && (paintFlags & PaintLayerPaintingRootBackgroundOnly);
 }
 
 bool DeprecatedPaintLayerPainter::shouldPaintLayerInSoftwareMode(const DeprecatedPaintLayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
@@ skipping 178 matching lines @@
             clippingRule = LayerClipRecorder::IncludeSelfForBorderRadius;
             break;
         }
 
         clipRecorder.emplace(*context, *m_paintLayer.layoutObject(), clipType, clipRect, &paintingInfo, fragment.paginationOffset, paintFlags, clippingRule);
     }
 
     PaintInfo paintInfo(context, pixelSnappedIntRect(clipRect.rect()), phase, paintBehavior, paintingRootForLayoutObject, 0, paintingInfo.rootLayer->layoutObject());
     OwnPtr<ScrollRecorder> scrollRecorder;
     LayoutPoint paintOffset = toPoint(fragment.layerBounds.location() - m_paintLayer.layoutBoxLocation());
-    if (&m_paintLayer != paintingInfo.rootLayer && paintingInfo.rootLayer->layoutObject()->hasOverflowClip()) {
-        // As a sublayer of the root layer, m_paintLayer's painting is not controlled by the ScrollRecorder
-        // created by BlockPainter of the root layer, so we need to issue ScrollRecorder for them separately.
-        // FIXME: This doesn't apply in slimming paint phase 2.
-        IntSize scrollOffset = paintingInfo.rootLayer->layoutBox()->scrolledContentOffset();
-        if (paintingInfo.rootLayer->scrollsOverflow() || !scrollOffset.isZero()) {
-            paintOffset += scrollOffset;
-            paintInfo.rect.move(scrollOffset);
-            scrollRecorder = adoptPtr(new ScrollRecorder(*paintInfo.context, *m_paintLayer.layoutObject(), paintInfo.phase, scrollOffset));
-        }
+    if (!paintingInfo.scrollOffsetAccumulation.isZero()) {
+        // As a descendant of the root layer, m_paintLayer's painting is not controlled by the ScrollRecorders
+        // created by BlockPainter of the ancestor layers up to the root layer, so we need to issue ScrollRecorder
+        // for this layer seperately, with the scroll offset accumulated from the root layer to the parent of this
+        // layer, to get the same result as ScrollRecorder in BlockPainter.
+        paintOffset += paintingInfo.scrollOffsetAccumulation;
+        paintInfo.rect.move(paintingInfo.scrollOffsetAccumulation);
+        scrollRecorder = adoptPtr(new ScrollRecorder(*paintInfo.context, *m_paintLayer.layoutObject(), paintInfo.phase, paintingInfo.scrollOffsetAccumulation));
     }
     m_paintLayer.layoutObject()->paint(paintInfo, paintOffset);
 }
 
 void DeprecatedPaintLayerPainter::paintBackgroundForFragments(const DeprecatedPaintLayerFragments& layerFragments, GraphicsContext* context,
     const LayoutRect& transparencyPaintDirtyRect, const DeprecatedPaintLayerPaintingInfo& localPaintingInfo, PaintBehavior paintBehavior,
     LayoutObject* paintingRootForLayoutObject, PaintLayerFlags paintFlags)
 {
     bool needsScope = layerFragments.size() > 1;
     for (auto& fragment : layerFragments) {
@@ skipping 86 matching lines @@
     if (!m_paintLayer.containsDirtyOverlayScrollbars())
         return;
 
     DeprecatedPaintLayerPaintingInfo paintingInfo(&m_paintLayer, LayoutRect(enclosingIntRect(damageRect)), paintBehavior, LayoutSize(), paintingRoot);
     paintLayer(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
 
     m_paintLayer.setContainsDirtyOverlayScrollbars(false);
 }
 
 } // namespace blink