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

third_party/WebKit/Source/core/layout/LayoutObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 24 matching lines @@
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/TextAffinity.h"
 #include "core/frame/DeprecatedScheduleStyleRecalcDuringLayout.h"
 #include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLElement.h"
+#include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/HTMLHtmlElement.h"
 #include "core/html/HTMLTableCellElement.h"
 #include "core/html/HTMLTableElement.h"
 #include "core/input/EventHandler.h"
 #include "core/inspector/InstanceCounters.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutCounter.h"
 #include "core/layout/LayoutDeprecatedFlexibleBox.h"
 #include "core/layout/LayoutFlexibleBox.h"
 #include "core/layout/LayoutFlowThread.h"
@@ skipping 2513 matching lines @@
       layer->dirtyVisibleContentStatus();
   }
 
   if (parent()->childrenInline())
     parent()->dirtyLinesFromChangedChild(this);
 
   if (LayoutFlowThread* flowThread = flowThreadContainingBlock())
     flowThread->flowThreadDescendantWasInserted(this);
 }
 
-enum FindReferencingScrollAnchorsBehavior { DontClear, Clear };
+enum FindScrollAnchorsBehavior { FindReferencing, ClearReferencing, ClearAll };
 
-static bool findReferencingScrollAnchors(
-    LayoutObject* layoutObject,
-    FindReferencingScrollAnchorsBehavior behavior) {
+// Returns true if scroller has layoutObject as its anchor.
+static bool clearScrollAnchorForScroller(ScrollableArea* scroller,
+                                         LayoutObject* layoutObject,
+                                         FindScrollAnchorsBehavior behavior) {
+  DCHECK(scroller);
+  ScrollAnchor* anchor = scroller->scrollAnchor();
+  DCHECK(anchor);
+  bool refersTo = false;
+  if (anchor->refersTo(layoutObject)) {
+    refersTo = true;
+    if (behavior == FindReferencing)
+      return refersTo;
+    layoutObject->setIsScrollAnchorObject(false);
+    anchor->releaseAnchor();
+  } else if (behavior == ClearAll && anchor->anchorObject()) {
+    anchor->anchorObject()->setIsScrollAnchorObject(false);
+    anchor->releaseAnchor();
+  }
+  return refersTo;
+}
+
+// Returns true if any of scroller in the parent chain of layoutObject has
+// layoutObject as its anchor. If FindScrollAnchorsBehavior is ClearAll, all
+// the scrollers in the parent chain of layoutObject will have their scroll
+// anchor cleared. If FindScrollAnchorsBehavior is ClearReferencing, all the
+// scrollers in the parent chain of layoutObject that have layoutObject as their
+// anchor will have their scroll anchor cleared.
+static bool findScrollAnchors(LayoutObject* layoutObject,
+                              FindScrollAnchorsBehavior behavior) {
   PaintLayer* layer = nullptr;
   if (LayoutObject* parent = layoutObject->parent())
     layer = parent->enclosingLayer();
   bool found = false;
 
-  // Walk up the layer tree to clear any scroll anchors that reference us.
+  // Walk up the layer tree to clear scroll anchors if required.
   while (layer) {
-    if (PaintLayerScrollableArea* scrollableArea = layer->getScrollableArea()) {
-      ScrollAnchor* anchor = scrollableArea->scrollAnchor();
-      DCHECK(anchor);
-      if (anchor->refersTo(layoutObject)) {
-        found = true;
-        if (behavior == Clear)
-          anchor->notifyRemoved(layoutObject);
-        else
-          return true;
-      }
+    if (PaintLayerScrollableArea* scroller = layer->getScrollableArea()) {
+      found = clearScrollAnchorForScroller(scroller, layoutObject, behavior) ||
+              found;
+      if (found && behavior == FindReferencing)
+        return found;
     }
     layer = layer->parent();
   }
+
   if (FrameView* view = layoutObject->frameView()) {
-    ScrollAnchor* anchor = view->scrollAnchor();
-    DCHECK(anchor);
-    if (anchor->refersTo(layoutObject)) {
-      found = true;
-      if (behavior == Clear)
-        anchor->notifyRemoved(layoutObject);
-    }
+    found = clearScrollAnchorForScroller(view, layoutObject, behavior) || found;
+    if (found && behavior == FindReferencing)
+      return found;
+  }
+
+  // Continue walk past frame boundary.

[skobes, 2016/10/10 21:34:35]

Hmm, do we actually want this behavior?  We don't descend into iframes in
findAnchor, so I don't think iframe scrolls need to clear anchors in parent
frames.

[ymalik, 2016/10/11 19:54:22]

hmm you're right. I was under the impression that we do actually descend into
iframes. But we don't so you're right that we don't need this.

+  if (layoutObject->document().localOwner()) {
+    found =
+        findScrollAnchors(layoutObject->document().localOwner()->layoutObject(),
+                          behavior) ||
+        found;
   }
   return found;
 }
 
 void LayoutObject::willBeRemovedFromTree() {
   // FIXME: We should ASSERT(isRooted()) but we have some out-of-order removals which would need to be fixed first.
 
   // If we remove a visible child from an invisible parent, we don't know the layer visibility any more.
   PaintLayer* layer = nullptr;
   if (parent()->style()->visibility() != EVisibility::Visible &&
@@ skipping 13 matching lines @@
   if (isOutOfFlowPositioned() && parent()->childrenInline())
     parent()->dirtyLinesFromChangedChild(this);
 
   removeFromLayoutFlowThread();
 
   // Update cached boundaries in SVG layoutObjects if a child is removed.
   if (parent()->isSVG())
     parent()->setNeedsBoundariesUpdate();
 
   if (RuntimeEnabledFeatures::scrollAnchoringEnabled() &&
-      m_bitfields.isScrollAnchorObject()) {
-    // Clear the bit first so that anchor.clear() doesn't recurse into findReferencingScrollAnchors.
-    m_bitfields.setIsScrollAnchorObject(false);
-    findReferencingScrollAnchors(this, Clear);
+      m_bitfields.isScrollAnchorObject())
+    findScrollAnchors(this, ClearReferencing);
+}
+
+void LayoutObject::maybeClearIsScrollAnchorObject() {
+  if (m_bitfields.isScrollAnchorObject()) {
+    m_bitfields.setIsScrollAnchorObject(
+        findScrollAnchors(this, FindReferencing));
   }
 }
 
-void LayoutObject::maybeClearIsScrollAnchorObject() {
-  if (m_bitfields.isScrollAnchorObject())
-    m_bitfields.setIsScrollAnchorObject(
-        findReferencingScrollAnchors(this, DontClear));
+void LayoutObject::clearScrollAnchors() {
+  findScrollAnchors(this, ClearAll);
 }
 
 void LayoutObject::removeFromLayoutFlowThread() {
   if (!isInsideFlowThread())
     return;
 
   // Sometimes we remove the element from the flow, but it's not destroyed at that time.
   // It's only until later when we actually destroy it and remove all the children from it.
   // Currently, that happens for firstLetter elements and list markers.
   // Pass in the flow thread so that we don't have to look it up for all the children.
@@ skipping 789 matching lines @@
     const blink::LayoutObject* root = object1;
     while (root->parent())
       root = root->parent();
     root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
   } else {
     WTFLogAlways("%s", "Cannot showLayoutTree. Root is (nil)");
   }
 }
 
 #endif