Disable anchoring if ancestor changes padding or margin

third_party/WebKit/Source/core/layout/ScrollAnchor.cpp

 // Copyright 2015 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/layout/ScrollAnchor.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/UseCounter.h"
 #include "core/layout/line/InlineTextBox.h"
 #include "core/paint/PaintLayerScrollableArea.h"
 #include "platform/Histogram.h"
 
 namespace blink {
 
 using Corner = ScrollAnchor::Corner;
 
 static const int kMaxAdjustments = 20;
 
 ScrollAnchor::ScrollAnchor()
     : m_hasBounced(false)
     , m_adjustmentCount(0)
+    , m_anyAncestorChangedPaddingOrMargin(false)
 {
 }
 
 ScrollAnchor::ScrollAnchor(ScrollableArea* scroller)
     : ScrollAnchor()
 {
     setScroller(scroller);
 }
 
 ScrollAnchor::~ScrollAnchor()
@@ skipping 160 matching lines @@
     }
 }
 
 void ScrollAnchor::save()
 {
     DCHECK(m_scroller);
     if (m_scroller->scrollPosition() == IntPoint::zero()) {
         clear();
         return;
     }
-    if (m_current)
+
+    if (m_current) {
+        m_anyAncestorChangedPaddingOrMargin = paddingOrBorderChanged();
         return;
+    }
 
     findAnchor();
     if (!m_current)
         return;
 
+    m_anyAncestorChangedPaddingOrMargin = paddingOrBorderChanged();
+
     m_current.m_anchorObject->setIsScrollAnchorObject();
     m_current.m_savedRelativeOffset = computeRelativeOffset(
         m_current.m_anchorObject, m_scroller, m_current.m_corner);
 
     if (m_lastAdjusted) {
         // We need to update m_lastAdjusted.m_savedRelativeOffset, since it is
         // relative to the visible rect and the user may have scrolled since the
         // last adjustment.
         if (!candidateMayMoveWithScroller(m_lastAdjusted.m_anchorObject, m_scroller)) {
             m_lastAdjusted.clear();
@@ skipping 14 matching lines @@
     // visual delta. If we scroll by the delta in LayoutUnits, the snapping of the
     // anchor node may round differently from the snapping of the scroll position.
     // (For example, anchor moving from 2.4px -> 2.6px is really 2px -> 3px, so we
     // should scroll by 1px instead of 0.2px.) This is true regardless of whether
     // the ScrollableArea actually uses fractional scroll positions.
     return roundedIntSize(computeRelativeOffset(
         anchorPoint.m_anchorObject, m_scroller, anchorPoint.m_corner)) -
         roundedIntSize(anchorPoint.m_savedRelativeOffset);
 }
 
+bool ScrollAnchor::paddingOrBorderChanged() const
+{
+    LayoutObject* current = anchorObject();
+    while (current && current != scrollerLayoutBox(m_scroller)) {
+        if (current->isLayoutBlock()
+            && (toLayoutBlock(current)->heightAvailableToChildrenChanged()))
+            return true;
+        current = current->parent();
+    }
+    return false;
+}
+
 void ScrollAnchor::restore()
 {
     DCHECK(m_scroller);
     if (m_lastAdjusted && m_lastAdjusted.m_anchorObject != m_current.m_anchorObject
         && !m_hasBounced && computeAdjustment(m_lastAdjusted) == -m_lastAdjustment) {
         // If previous anchor point has bounced, follow the bounce.
         clear();
         adjust(-m_lastAdjustment);
         return;
     }
+
     if (!m_current)
         return;
+
+    // Authors often change the padding or margin when trying to simulate
+    // position:sticky on headers. Use this as a heuristic to disable scroll
+    // anchoring so that we don't conflict with JS changes.
+    // TODO(ymalik): Does this change allow us to remove the de-bouncing hack?
+    if (m_anyAncestorChangedPaddingOrMargin) {
+        clear();
+        return;
+    }
+
     IntSize adjustment = computeAdjustment(m_current);
     if (adjustment.isZero())
         return;
+
     if (adjustment == -m_lastAdjustment && m_hasBounced) {
         // Don't bounce more than once.
         clear();
         m_hasBounced = false;
         m_lastAdjustment = IntSize();
         m_lastAdjusted.clear();
         return;
     }
     // We impose a limit on the number of adjustments between user scrolls, to
     // mitigate the impact of pathological feedback loops with event handlers.
@@ skipping 42 matching lines @@
 
 void ScrollAnchor::notifyRemoved(LayoutObject* layoutObject)
 {
     if (m_current.m_anchorObject == layoutObject)
         m_current.clear();
     if (m_lastAdjusted.m_anchorObject == layoutObject)
         m_lastAdjusted.clear();
 }
 
 } // namespace blink