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

[ojan, 2016/08/16 23:54:32]

I think we'll still need to exclude out of flow positioned elements from being
anchors, but we can try this for now and see how it works on the web in
practice.

[skobes, 2016/08/17 18:50:32]

Acknowledged.  Either way we shouldn't special-case non-zero top/left so I think
it makes sense for this change to remove the hack that was added for
http://crbug.com/604996, then land a separate change to exclude all abspos if we
decide to do that.

I'm updating the WICG explainer to include a section on why I think we shouldn't
exclude all abspos so we can have a public discussion about that.

-            // 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::computeHasLayoutAffectingPropertyChanged()

[ojan, 2016/08/16 23:54:32]

This is n^2 in the depth of the scrollable areas. I think that's probably fine
in practice since there shouldn't be that many nested scrollable areas and we
only do it for scrollers that are scrolled to a non-zero scroll offset. Just
calling it out in case I'm missing some reason it's not fine. :)

[skobes, 2016/08/17 18:50:32]

I agree this is probably fine.

+{
+    LayoutObject* current = anchorObject();
+    if (!current)
+        return false;
+
+    LayoutObject* scrollerBox = scrollerLayoutBox(m_scroller);
+    while (true) {
+        DCHECK(current);
+        if (current->hasLayoutAffectingStyleChanged())
+            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_hasLayoutAffectingPropertyChanged = computeHasLayoutAffectingPropertyChanged();
 }
 
-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_hasLayoutAffectingPropertyChanged) {
+        // Note that we only clear if the adjustment would have been non-zero.
+        // This minimizes redundant calls to findAnchor.
         clear();
-        adjust(-m_lastAdjustment);
         return;
     }
-    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);
 }
 
 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