Tie scroll anchoring adjustments to frame lifecycle instead of layout.

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/LayoutBlockFlow.h"
 #include "core/layout/api/LayoutBoxItem.h"
 #include "core/layout/line/InlineTextBox.h"
 #include "core/paint/PaintLayer.h"
 #include "core/paint/PaintLayerScrollableArea.h"
 #include "platform/Histogram.h"
 
 namespace blink {
 
 using Corner = ScrollAnchor::Corner;
 
 ScrollAnchor::ScrollAnchor()
     : m_anchorObject(nullptr),
       m_corner(Corner::TopLeft),
       m_scrollAnchorDisablingStyleChanged(false),
-      m_saved(false) {}
+      m_queued(false) {}
 
 ScrollAnchor::ScrollAnchor(ScrollableArea* scroller) : ScrollAnchor() {
   setScroller(scroller);
 }
 
 ScrollAnchor::~ScrollAnchor() {}
 
 void ScrollAnchor::setScroller(ScrollableArea* scroller) {
   DCHECK(m_scroller != scroller);
   DCHECK(scroller);
@@ skipping 65 matching lines @@
   }
   LayoutBox* scrollerBox = scrollerLayoutBox(scroller);
 
   LayoutRect relativeBounds = LayoutRect(
       layoutObject->localToAncestorQuad(FloatRect(localBounds), scrollerBox)
           .boundingBox());
   // When root layer scrolling is off, the LayoutView will have no scroll
   // offset (since scrolling is handled by the FrameView) so
   // localToAncestorQuad returns document coords, so we must subtract scroll
   // offset to get viewport coords. We discard the fractional part of the
-  // scroll offset so that the rounding in restore() matches the snapping of
+  // scroll offset so that the rounding in adjust() matches the snapping of
   // the anchor node to the pixel grid of the layer it paints into. For
   // non-FrameView scrollers, we rely on the flooring behavior of
   // LayoutBox::scrolledContentOffset.
   if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled() &&
       scrollerBox->isLayoutView())
     relativeBounds.moveBy(IntPoint(-scroller->scrollOffsetInt()));
   return relativeBounds;
 }
 
 static LayoutPoint computeRelativeOffset(const LayoutObject* layoutObject,
@@ skipping 84 matching lines @@
   while (true) {
     DCHECK(current);
     if (current->scrollAnchorDisablingStyleChanged())
       return true;
     if (current == scrollerBox)
       return false;
     current = current->parent();
   }
 }
 
-void ScrollAnchor::save() {
-  if (m_saved)
+void ScrollAnchor::notifyBeforeLayout() {
+  if (m_queued) {
+    m_scrollAnchorDisablingStyleChanged |=
+        computeScrollAnchorDisablingStyleChanged();
     return;
-  m_saved = true;
+  }
   DCHECK(m_scroller);
   ScrollOffset scrollOffset = m_scroller->scrollOffset();
   float blockDirectionScrollOffset =
       scrollerLayoutBox(m_scroller)->isHorizontalWritingMode()
           ? scrollOffset.height()
           : scrollOffset.width();
   if (blockDirectionScrollOffset == 0) {
     clearSelf();
     return;
   }
 
   if (!m_anchorObject) {
     findAnchor();
     if (!m_anchorObject)
       return;
 
     m_anchorObject->setIsScrollAnchorObject();
     m_savedRelativeOffset =
         computeRelativeOffset(m_anchorObject, m_scroller, 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();
+
+  FrameView* frameView = scrollerLayoutBox(m_scroller)->frameView();
+  ScrollableArea* owningScroller =
+      m_scroller->isRootFrameViewport()
+          ? &toRootFrameViewport(m_scroller)->layoutViewport()
+          : m_scroller.get();
+  frameView->enqueueScrollAnchoringAdjustment(owningScroller);

[ymalik, 2016/10/13 13:05:39]

I wonder if we should just enqueue m_scroller here and in
FrameView::performScrollAnchoringAdjustments, get RootFrameViewport to return
layoutViewport()->scrollAnchor().

[skobes, 2016/10/13 17:21:37]

I thought about this but it seemed a bit cleaner for
ScrollableArea::scrollAnchor to reflect ownership.

+  m_queued = true;
 }
 
 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.
   IntSize delta = roundedIntSize(computeRelativeOffset(m_anchorObject,
                                                        m_scroller, m_corner)) -
                   roundedIntSize(m_savedRelativeOffset);
 
   // Only adjust on the block layout axis.
   if (scrollerLayoutBox(m_scroller)->isHorizontalWritingMode())
     delta.setWidth(0);
   else
     delta.setHeight(0);
   return delta;
 }
 
-void ScrollAnchor::restore() {
-  if (!m_saved)
+void ScrollAnchor::adjust() {
+  if (!m_queued)
     return;
-  m_saved = false;
+  m_queued = false;
   DCHECK(m_scroller);
   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.
@@ skipping 53 matching lines @@
 bool ScrollAnchor::refersTo(const LayoutObject* layoutObject) const {
   return m_anchorObject == layoutObject;
 }
 
 void ScrollAnchor::notifyRemoved(LayoutObject* layoutObject) {
   if (m_anchorObject == layoutObject)
     clearSelf();
 }
 
 }  // namespace blink