Refactor scroll updates during flexbox layout.

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 65 matching lines @@
 // the middle of recomputing the style so we can't rely on any of its
 // information), which is why it's easier to just update it for every layout.
 static TrackedDescendantsMap* gPositionedDescendantsMap = nullptr;
 static TrackedContainerMap* gPositionedContainerMap = nullptr;
 
 // This map keeps track of the descendants whose 'height' is percentage associated
 // with a containing block. Like |gPositionedDescendantsMap|, it is also recomputed
 // for every layout (see the comment above about why).
 static TrackedDescendantsMap* gPercentHeightDescendantsMap = nullptr;
 
-typedef WTF::HashSet<LayoutBlock*> DelayedUpdateScrollInfoSet;
-static int gDelayUpdateScrollInfo = 0;
-static DelayedUpdateScrollInfoSet* gDelayedUpdateScrollInfoSet = nullptr;
-
 LayoutBlock::LayoutBlock(ContainerNode* node)
     : LayoutBox(node)
     , m_hasMarginBeforeQuirk(false)
     , m_hasMarginAfterQuirk(false)
     , m_beingDestroyed(false)
     , m_hasMarkupTruncation(false)
     , m_widthAvailableToChildrenChanged(false)
     , m_heightAvailableToChildrenChanged(false)
     , m_isSelfCollapsing(false)
     , m_descendantsWithFloatsMarkedForLayout(false)
@@ skipping 27 matching lines @@
 LayoutBlock::~LayoutBlock()
 {
     removeFromGlobalMaps();
 }
 
 void LayoutBlock::willBeDestroyed()
 {
     if (!documentBeingDestroyed() && parent())
         parent()->dirtyLinesFromChangedChild(this);
 
-    if (UNLIKELY(gDelayedUpdateScrollInfoSet != 0))
-        gDelayedUpdateScrollInfoSet->remove(this);
-
     if (TextAutosizer* textAutosizer = document().textAutosizer())
         textAutosizer->destroy(this);
 
     LayoutBox::willBeDestroyed();
 }
 
 void LayoutBlock::styleWillChange(StyleDifference diff, const ComputedStyle& newStyle)
 {
     const ComputedStyle* oldStyle = style();
 
@@ skipping 186 matching lines @@
     if (child->parent()->isLayoutGrid())
         toLayoutGrid(child->parent())->dirtyGrid();
 
     // Now remove the leftover anonymous block from the tree, and destroy it. We'll rip it out
     // manually from the tree before destroying it, because we don't want to trigger any tree
     // adjustments with regards to anonymous blocks (or any other kind of undesired chain-reaction).
     children()->removeChildNode(this, child, false);
     child->destroy();
 }
 
-void LayoutBlock::startDelayUpdateScrollInfo()
-{
-    if (gDelayUpdateScrollInfo == 0) {
-        ASSERT(!gDelayedUpdateScrollInfoSet);
-        gDelayedUpdateScrollInfoSet = new DelayedUpdateScrollInfoSet;
-    }
-    ASSERT(gDelayedUpdateScrollInfoSet);
-    ++gDelayUpdateScrollInfo;
-}
-
-bool LayoutBlock::finishDelayUpdateScrollInfo(SubtreeLayoutScope* layoutScope, ScrollPositionMap* scrollMap)
-{
-    bool childrenMarkedForRelayout = false;
-
-    --gDelayUpdateScrollInfo;
-    ASSERT(gDelayUpdateScrollInfo >= 0);
-    if (gDelayUpdateScrollInfo == 0) {
-        ASSERT(gDelayedUpdateScrollInfoSet);
-
-        OwnPtr<DelayedUpdateScrollInfoSet> infoSet(adoptPtr(gDelayedUpdateScrollInfoSet));
-        gDelayedUpdateScrollInfoSet = nullptr;
-
-        for (auto* block : *infoSet) {
-            if (block->hasOverflowClip()) {
-                PaintLayerScrollableArea* scrollableArea = block->layer()->getScrollableArea();
-                if (scrollMap)
-                    scrollMap->add(scrollableArea, scrollableArea->scrollPositionDouble());
-                childrenMarkedForRelayout |= scrollableArea->updateAfterLayout(layoutScope);
-            }
-        }
-    }
-    return childrenMarkedForRelayout;
-}
-
 void LayoutBlock::updateAfterLayout()
 {
     invalidateStickyConstraints();
 
     // Update our scroll information if we're overflow:auto/scroll/hidden now that we know if
     // we overflow or not.
-    if (hasOverflowClip()) {
-        if (style()->isFlippedBlocksWritingMode()) {
-            // FIXME: https://bugs.webkit.org/show_bug.cgi?id=97937
-            // Workaround for now. We cannot delay the scroll info for overflow
-            // for items with opposite writing directions, as the contents needs
-            // to overflow in that direction
-            layer()->getScrollableArea()->updateAfterLayout();
-            return;
-        }
-
-        if (gDelayUpdateScrollInfo)
-            gDelayedUpdateScrollInfoSet->add(this);
-        else
-            layer()->getScrollableArea()->updateAfterLayout();
-    }
+    if (hasOverflowClip())
+        layer()->getScrollableArea()->updateAfterLayout();
 }
 
 void LayoutBlock::layout()
 {
     LayoutAnalyzer::Scope analyzer(*this);
 
     bool needsScrollAnchoring = RuntimeEnabledFeatures::scrollAnchoringEnabled() && hasOverflowClip();
     if (needsScrollAnchoring)
         getScrollableArea()->scrollAnchor().save();
 
@@ skipping 1484 matching lines @@
         for (TrackedLayoutBoxListHashSet::const_iterator it = positionedDescendantSet->begin(); it != end; ++it) {
             LayoutBox* currBox = *it;
             ASSERT(!currBox->needsLayout());
         }
     }
 }
 
 #endif
 
 } // namespace blink