Implement bounce suppression in ScrollAnchor.

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/LayoutView.h"
 #include "core/layout/line/InlineTextBox.h"
 #include "core/paint/PaintLayerScrollableArea.h"
 #include "platform/Histogram.h"
 
 namespace blink {
 
 using Corner = ScrollAnchor::Corner;
 
 ScrollAnchor::ScrollAnchor(ScrollableArea* scroller)
     : m_scroller(scroller)
-    , m_anchorObject(nullptr)
-    , m_corner(Corner::TopLeft)
+    , m_hasBounced(false)
 {
     ASSERT(m_scroller);
     ASSERT(m_scroller->isFrameView() || m_scroller->isPaintLayerScrollableArea());
 }
 
 ScrollAnchor::~ScrollAnchor()
 {
 }
 
 // TODO(pilgrim) replace all instances of scrollerLayoutBox with scrollerLayoutBoxItem
@@ skipping 111 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_anchorObject = candidate;
-            m_corner = result.corner;
+            m_current.m_anchorObject = candidate;
+            m_current.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;
         }
     }
 }
 
 void ScrollAnchor::save()
 {
     if (m_scroller->scrollPosition() == IntPoint::zero()) {
         clear();
         return;
     }
-    if (m_anchorObject)
+    if (m_current)
         return;
 
     findAnchor();
-    if (!m_anchorObject)
+    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 the
+        // user may have scrolled since the last adjustment.

[ymalik, 2016/05/16 17:34:40]

Could you please elaborate moe on why we update m_lastAdjusted here in response
to the user scrolls?

[skobes, 2016/05/18 01:24:30]

Clarified the comment.  The issue is that the offset is relative to the visible
rect.  If the user has scrolled, the visible rect has moved.  We don't have the
same issue with m_current because it is cleared on every scroll.

+        if (!candidateMovesWithScroller(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) {

[ymalik, 2016/05/16 17:34:40]

Should we override the == operator in AnchorPoint? This is also used in ::adjust
L260

[skobes, 2016/05/18 01:24:30]

I don't think operator== should ignore m_savedRelativeOffset, which it would
have to do to be useful here.

+            m_lastAdjusted.m_savedRelativeOffset = m_current.m_savedRelativeOffset;
+        } else {
+            m_lastAdjusted.m_savedRelativeOffset = computeRelativeOffset(
+                m_lastAdjusted.m_anchorObject, m_scroller, m_lastAdjusted.m_corner);
+        }
+    }
 }
 
-void ScrollAnchor::restore()
+IntSize ScrollAnchor::computeAdjustment(const AnchorPoint& anchorPoint) const
 {
-    if (!m_anchorObject)
-        return;
-
     // 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.
-    IntSize adjustment =
-        roundedIntSize(computeRelativeOffset(m_anchorObject, m_scroller, m_corner)) -
-        roundedIntSize(m_savedRelativeOffset);
-    if (!adjustment.isZero()) {
-        DoublePoint desiredPos = m_scroller->scrollPositionDouble() + adjustment;
-        ScrollAnimatorBase* animator = m_scroller->existingScrollAnimator();
-        if (!animator || !animator->hasRunningAnimation()) {
-            m_scroller->setScrollPosition(desiredPos, AnchoringScroll);
-        } else {
-            // If in the middle of a scroll animation, stop the animation, make
-            // the adjustment, and continue the animation on the pending delta.
-            FloatSize pendingDelta = animator->desiredTargetPosition() - FloatPoint(m_scroller->scrollPositionDouble());
-            animator->cancelAnimation();
-            m_scroller->setScrollPosition(desiredPos, AnchoringScroll);
-            animator->userScroll(ScrollByPixel, pendingDelta);
-        }
-        // Update UMA metric.
-        DEFINE_STATIC_LOCAL(EnumerationHistogram, adjustedOffsetHistogram,
-            ("Layout.ScrollAnchor.AdjustedScrollOffset", 2));
-        adjustedOffsetHistogram.count(1);
-        UseCounter::count(scrollerLayoutBox(m_scroller)->document(), UseCounter::ScrollAnchored);
+    return roundedIntSize(computeRelativeOffset(
+        anchorPoint.m_anchorObject, m_scroller, anchorPoint.m_corner)) -
+        roundedIntSize(anchorPoint.m_savedRelativeOffset);
+}
+
+void ScrollAnchor::restore()
+{
+    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;
+    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;
+    }
+    adjust(adjustment);
+}
+
+void ScrollAnchor::adjust(IntSize adjustment)
+{
+    DoublePoint desiredPos = m_scroller->scrollPositionDouble() + adjustment;
+    ScrollAnimatorBase* animator = m_scroller->existingScrollAnimator();
+    if (!animator || !animator->hasRunningAnimation()) {
+        m_scroller->setScrollPosition(desiredPos, AnchoringScroll);
+    } else {
+        // If in the middle of a scroll animation, stop the animation, make
+        // the adjustment, and continue the animation on the pending delta.
+        // TODO(skobes): This is not quite right, we are starting a new curve without
+        // saving our progress on the existing curve.
+        FloatSize pendingDelta = animator->desiredTargetPosition() -
+            FloatPoint(m_scroller->scrollPositionDouble());
+        animator->cancelAnimation();
+        m_scroller->setScrollPosition(desiredPos, AnchoringScroll);
+        animator->userScroll(ScrollByPixel, pendingDelta);
+    }
+
+    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_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;
+}
+
+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