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 it is
+        // relative to the visible rect and the user may have scrolled since the
+        // last adjustment.
+        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) {
+            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