[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()) {

[chrishtr, 2015/06/03 18:46:08]

Can you explain more why we need to do this accumulation?

Also, test?

[Xianzhu, 2015/06/03 19:06:59]

This is covered by existing tests. Previously the failures were hidden because
we invalidate the whole scrolled tree.

I should have kept the comments at line 637-639 of the old code, and modified it
into:
  // 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.

Will insert this comment below.

Previously (code at left) we compensate the scroll offset of the root painting
layer only, missing the intermediate scroll layers between the root layer and
this layer.

[Xianzhu, 2015/06/03 19:42:41]

Done.

+        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