Clear scroll anchor on all parent scrollers from ScrollAnchor::clear

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) {}
 
 ScrollAnchor::ScrollAnchor(ScrollableArea* scroller) : ScrollAnchor() {
   setScroller(scroller);
 }
 
 ScrollAnchor::~ScrollAnchor() {}
 
 void ScrollAnchor::setScroller(ScrollableArea* scroller) {
   DCHECK(m_scroller != scroller);
   DCHECK(scroller);
   DCHECK(scroller->isRootFrameViewport() || scroller->isFrameView() ||
          scroller->isPaintLayerScrollableArea());
   m_scroller = scroller;
-  clear();
+  clearSelf();
 }
 
 // TODO(pilgrim): Replace all instances of scrollerLayoutBox with
 // scrollerLayoutBoxItem, https://crbug.com/499321
 static LayoutBox* scrollerLayoutBox(const ScrollableArea* scroller) {
   LayoutBox* box = scroller->layoutBox();
   DCHECK(box);
   return box;
 }
 
@@ skipping 167 matching lines @@
   if (m_saved)
     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) {
-    clear();
+    clearSelf();
     return;
   }
 
   if (!m_anchorObject) {
     findAnchor();
     if (!m_anchorObject)
       return;
 
     m_anchorObject->setIsScrollAnchorObject();
     m_savedRelativeOffset =
@@ skipping 35 matching lines @@
   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.
     // TODO(skobes): add UMA metric for this.
-    clear();
+    clearSelf();
 
     DEFINE_STATIC_LOCAL(EnumerationHistogram, suppressedBySanaclapHistogram,
                         ("Layout.ScrollAnchor.SuppressedBySanaclap", 2));
     suppressedBySanaclapHistogram.count(1);
 
     return;
   }
 
   m_scroller->setScrollOffset(
       m_scroller->scrollOffset() + FloatSize(adjustment), AnchoringScroll);
 
   // 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() {
+void ScrollAnchor::clearSelf(bool unconditionally) {
   LayoutObject* anchorObject = m_anchorObject;
   m_anchorObject = nullptr;
 
   if (anchorObject)
-    anchorObject->maybeClearIsScrollAnchorObject();
+    anchorObject->clearIsScrollAnchorObject(unconditionally);
+}
+
+void ScrollAnchor::clear() {
+  LayoutObject* layoutObject =
+      m_anchorObject ? m_anchorObject : scrollerLayoutBox(m_scroller);
+  PaintLayer* layer = nullptr;
+  if (LayoutObject* parent = layoutObject->parent())
+    layer = parent->enclosingLayer();
+
+  // Walk up the layer tree to clear any scroll anchors.
+  while (layer) {
+    if (PaintLayerScrollableArea* scrollableArea = layer->getScrollableArea()) {
+      ScrollAnchor* anchor = scrollableArea->scrollAnchor();
+      DCHECK(anchor);
+      anchor->clearSelf(true);
+    }
+    layer = layer->parent();
+  }
+
+  if (FrameView* view = layoutObject->frameView()) {
+    ScrollAnchor* anchor = view->scrollAnchor();
+    DCHECK(anchor);
+    anchor->clearSelf(true);
+  }
 }
 
 bool ScrollAnchor::refersTo(const LayoutObject* layoutObject) const {
   return m_anchorObject == layoutObject;
 }
 
 void ScrollAnchor::notifyRemoved(LayoutObject* layoutObject) {
   if (m_anchorObject == layoutObject)
-    clear();
+    clearSelf();
 }
 
 }  // namespace blink