Implement SANACLAP (http://bit.ly/sanaclap).

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_anchorObject(nullptr)
+    , m_corner(Corner::TopLeft)
+    , m_scrollAnchorDisablingStyleChanged(false)
 {
 }
 
 ScrollAnchor::ScrollAnchor(ScrollableArea* scroller)
     : ScrollAnchor()
 {
     setScroller(scroller);
 }
 
 ScrollAnchor::~ScrollAnchor()
@@ skipping 80 matching lines @@
 static LayoutPoint computeRelativeOffset(const LayoutObject* layoutObject, const ScrollableArea* scroller, Corner corner)
 {
     return cornerPointOfRect(relativeBounds(layoutObject, scroller), corner);
 }
 
 static bool candidateMayMoveWithScroller(const LayoutObject* candidate, const ScrollableArea* scroller)
 {
     if (const ComputedStyle* style = candidate->style()) {
         if (style->hasViewportConstrainedPosition())
             return false;
-
-        if (style->hasOutOfFlowPosition()) {
-            // Absolute positioned elements with non-zero scrollTop/Left/Bottom/
-            // Right can stick to the viewport.
-            if (!style->top().isZero() || !style->left().isZero()
-                || !style->bottom().isZero() || !style->right().isZero())
-                return false;
-        }
     }
 
     bool skippedByContainerLookup = false;
     candidate->container(scrollerLayoutBox(scroller), &skippedByContainerLookup);
     return !skippedByContainerLookup;
 }
 
 ScrollAnchor::ExamineResult ScrollAnchor::examine(const LayoutObject* candidate) const
 {
     if (candidate->isLayoutInline())
@@ skipping 29 matching lines @@
 void ScrollAnchor::findAnchor()
 {
     TRACE_EVENT0("blink", "ScrollAnchor::findAnchor");
     SCOPED_BLINK_UMA_HISTOGRAM_TIMER("Layout.ScrollAnchor.TimeToFindAnchor");
 
     LayoutObject* stayWithin = scrollerLayoutBox(m_scroller);
     LayoutObject* candidate = stayWithin->nextInPreOrder(stayWithin);
     while (candidate) {
         ExamineResult result = examine(candidate);
         if (result.viable) {
-            m_current.m_anchorObject = candidate;
-            m_current.m_corner = result.corner;
+            m_anchorObject = candidate;
+            m_corner = result.corner;
         }
         switch (result.status) {
         case Skip:
             candidate = candidate->nextInPreOrderAfterChildren(stayWithin);
             break;
         case Constrain:
             stayWithin = candidate;
             // fall through
         case Continue:
             candidate = candidate->nextInPreOrder(stayWithin);
             break;
         case Return:
             return;
         }
     }
 }
 
+bool ScrollAnchor::computeScrollAnchorDisablingStyleChanged()
+{
+    LayoutObject* current = anchorObject();
+    if (!current)
+        return false;
+
+    LayoutObject* scrollerBox = scrollerLayoutBox(m_scroller);
+    while (true) {
+        DCHECK(current);
+        if (current->scrollAnchorDisablingStyleChanged())
+            return true;
+        if (current == scrollerBox)
+            return false;
+        current = current->parent();
+    }
+}
+
 void ScrollAnchor::save()
 {
     DCHECK(m_scroller);
     if (m_scroller->scrollPosition() == IntPoint::zero()) {
         clear();
         return;
     }
 
-    // TODO(ymalik): Just because we have a previously selected anchor doesn't
-    // mean that it's guaranteed to be valid. For e.g. overflow-anchor: none
-    // may have been added after anchor selection. The SANACLAP design poposal
-    // may fix this (see crbug.com/637626).
-    if (m_current)
-        return;
+    if (!m_anchorObject) {
+        findAnchor();
+        if (!m_anchorObject)
+            return;
 
-    findAnchor();
-    if (!m_current)
-        return;
+        m_anchorObject->setIsScrollAnchorObject();
+        m_savedRelativeOffset = computeRelativeOffset(
+            m_anchorObject, m_scroller, m_corner);
+    }
 
-    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();
-        } else if (m_lastAdjusted.m_anchorObject == m_current.m_anchorObject
-            && m_lastAdjusted.m_corner == m_current.m_corner) {
-            m_lastAdjusted.m_savedRelativeOffset = m_current.m_savedRelativeOffset;
-        } else {
-            m_lastAdjusted.m_savedRelativeOffset = computeRelativeOffset(
-                m_lastAdjusted.m_anchorObject, m_scroller, m_lastAdjusted.m_corner);
-        }
-    }
+    // Note that we must compute this during save() since the scroller's
+    // descendants have finished layout (and had the bit cleared) by the
+    // time restore() is called.
+    m_scrollAnchorDisablingStyleChanged = computeScrollAnchorDisablingStyleChanged();
 }
 
-IntSize ScrollAnchor::computeAdjustment(const AnchorPoint& anchorPoint) const
+IntSize ScrollAnchor::computeAdjustment() const
 {
     // The anchor node can report fractional positions, but it is DIP-snapped when
     // painting (crbug.com/610805), so we must round the offsets to determine the
     // 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);
+    return roundedIntSize(computeRelativeOffset(m_anchorObject, m_scroller, m_corner)) -
+        roundedIntSize(m_savedRelativeOffset);
 }
 
 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.
+    if (!m_anchorObject)
+        return;
+    IntSize adjustment = computeAdjustment();
+    if (adjustment.isZero())
+        return;
+
+    if (m_scrollAnchorDisablingStyleChanged) {
+        // Note that we only clear if the adjustment would have been non-zero.
+        // This minimizes redundant calls to findAnchor.
         clear();
-        adjust(-m_lastAdjustment);
         return;

[ymalik, 2016/08/18 07:44:20]

Will it be useful to have an UMA metric for the number of times we skip
anchoring because of this?

[skobes, 2016/08/18 17:45:56]

Added TODO.

     }
-    if (!m_current)
-        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.
-    if (++m_adjustmentCount <= kMaxAdjustments)
-        adjust(adjustment);
+
+    adjust(adjustment);

[ymalik, 2016/08/18 07:44:20]

nit: we don't seem to be using adjust elsewhere anymore. Move the code here?

[skobes, 2016/08/18 17:45:56]

Done.

 }
 
 void ScrollAnchor::adjust(IntSize adjustment)
 {
     m_scroller->setScrollPosition(m_scroller->scrollPositionDouble() + adjustment, AnchoringScroll);
 
-    if (m_current && m_lastAdjusted.m_anchorObject != m_current.m_anchorObject) {
-        m_lastAdjusted.clear();
-        m_lastAdjusted = m_current;
-    }
-    m_hasBounced = (m_lastAdjustment == -adjustment);
-    m_lastAdjustment = adjustment;
-
     // Update UMA metric.
     DEFINE_STATIC_LOCAL(EnumerationHistogram, adjustedOffsetHistogram,
         ("Layout.ScrollAnchor.AdjustedScrollOffset", 2));
     adjustedOffsetHistogram.count(1);
     UseCounter::count(scrollerLayoutBox(m_scroller)->document(), UseCounter::ScrollAnchored);
 }
 
 void ScrollAnchor::clear()
 {
-    m_adjustmentCount = 0;
-    m_current.clear();
-}
-
-void ScrollAnchor::AnchorPoint::clear()
-{
     LayoutObject* anchorObject = m_anchorObject;
     m_anchorObject = nullptr;
 
     if (anchorObject)
         anchorObject->maybeClearIsScrollAnchorObject();
 }
 
 bool ScrollAnchor::refersTo(const LayoutObject* layoutObject) const
 {
-    return m_current.m_anchorObject == layoutObject
-        || m_lastAdjusted.m_anchorObject == layoutObject;
+    return m_anchorObject == layoutObject;
 }
 
 void ScrollAnchor::notifyRemoved(LayoutObject* layoutObject)
 {
-    if (m_current.m_anchorObject == layoutObject)
-        m_current.clear();
-    if (m_lastAdjusted.m_anchorObject == layoutObject)
-        m_lastAdjusted.clear();
+    if (m_anchorObject == layoutObject)
+        clear();
 }
 
 } // namespace blink