Refactor scroll updates during flexbox layout.

third_party/WebKit/Source/core/paint/PaintLayerScrollableArea.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@gmail.com>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 605 matching lines @@
     } else if (box().isFlexibleBox()) {
         EFlexDirection flexDirection = box().style()->flexDirection();
         if (flexDirection == FlowColumnReverse)
             size.expand(verticalScrollbarWidth, 0);
         else if (flexDirection == FlowRowReverse)
             size.expand(0, horizontalScrollbarHeight);
     }
     return size;
 }
 
-void PaintLayerScrollableArea::computeScrollDimensions()
+void PaintLayerScrollableArea::updateScrollOrigin()
+{
+    if (!overflowRect().size().isZero()) {

[cbiesinger, 2016/04/29 20:02:50]

  if (!overflowRect().isEmpty()) ?

But can you explain / add a comment why this check is necessary?

[szager1, 2016/05/12 20:44:50]

This is a hack to prevent this from running before first layout (which will
crash for some reason I can't remember).  I searched for a more idiomatic way to
figure out that this is first layout, but couldn't find anything.  Added a
comment.

+        LayoutPoint scrollableOverflow = m_overflowRect.location() - LayoutSize(box().borderLeft(), box().borderTop());
+        setScrollOrigin(flooredIntPoint(-scrollableOverflow) + originAdjustmentForScrollbars());
+    }
+}
+
+void PaintLayerScrollableArea::updateScrollDimensions()
 {
     m_overflowRect = box().layoutOverflowRect();
     box().flipForWritingMode(m_overflowRect);
-
-    LayoutPoint scrollableOverflow = m_overflowRect.location() - LayoutSize(box().borderLeft(), box().borderTop());
-    setScrollOrigin(flooredIntPoint(-scrollableOverflow) + originAdjustmentForScrollbars());
+    updateScrollOrigin();
 }
 
 void PaintLayerScrollableArea::scrollToPosition(const DoublePoint& scrollPosition, ScrollOffsetClamping clamp, ScrollBehavior scrollBehavior, ScrollType scrollType)
 {
-    cancelProgrammaticScrollAnimation();

[cbiesinger, 2016/04/29 20:02:50]

BTW, why did you remove this? Just because it's not necessary because
setScrollPosition does this anyway?

[szager1, 2016/05/12 20:44:51]

It already gets called further down the call stack, I'm just eliminating a
redundant call.

-
     DoublePoint newScrollPosition = clamp == ScrollOffsetClamped ? clampScrollPosition(scrollPosition) : scrollPosition;
     if (newScrollPosition != scrollPositionDouble())
         ScrollableArea::setScrollPosition(newScrollPosition, scrollType, scrollBehavior);
 }
 
-bool PaintLayerScrollableArea::updateAfterLayout(SubtreeLayoutScope* delayedLayoutScope)
+void PaintLayerScrollableArea::updateAfterLayout()
 {
     ASSERT(box().hasOverflowClip());
 
-    bool didMarkForDelayedLayout = false;
+    bool relayoutIsPrevented = PreventRelayoutScope::relayoutIsPrevented();
+    bool scrollbarsAreFrozen = FreezeScrollbarsScope::scrollbarsAreFrozen();
 
     if (needsScrollbarReconstruction()) {
-        m_scrollbarManager.setCanDetachScrollbars(false);
         setHasHorizontalScrollbar(false);
         setHasVerticalScrollbar(false);
     }
 
-    m_scrollbarManager.setCanDetachScrollbars(true);
-
-    IntPoint originalOrigin = scrollOrigin();
-    computeScrollDimensions();
-
-    // Layout may cause us to be at an invalid scroll position. In this case we need
-    // to pull our scroll offsets back to the max (or push them up to the min).
-    DoublePoint clampedScrollPosition = clampScrollPosition(scrollPositionDouble());
-    if (clampedScrollPosition != scrollPositionDouble()) {
-        scrollToPosition(clampedScrollPosition);
-    } else if (originalOrigin != scrollOrigin()) {
-        // TODO: We should be able to use scrollOriginChanged() here, but we can't because
-        // PaintLayerScrollableArea does not maintain that flag: it gets set, but it never
-        // gets unset.  We should unset the flag after layout.
-        scrollPositionChanged(scrollPositionDouble(), ProgrammaticScroll);
-    }
-
-    m_scrollbarManager.setCanDetachScrollbars(false);
+    updateScrollDimensions();
 
     bool hasHorizontalOverflow = this->hasHorizontalOverflow();
     bool hasVerticalOverflow = this->hasVerticalOverflow();
 
     {
         // Hits in compositing/overflow/automatically-opt-into-composited-scrolling-after-style-change.html.
         DisableCompositingQueryAsserts disabler;
 
         // overflow:scroll should just enable/disable.
         if (box().style()->overflowX() == OverflowScroll && horizontalScrollbar())
             horizontalScrollbar()->setEnabled(hasHorizontalOverflow);
         if (box().style()->overflowY() == OverflowScroll && verticalScrollbar())
             verticalScrollbar()->setEnabled(hasVerticalOverflow);
     }
 
     // We need to layout again if scrollbars are added or removed by overflow:auto,
     // or by changing between native and custom.
     bool horizontalScrollBarChanged = (box().hasAutoHorizontalScrollbar() && (hasHorizontalScrollbar() != hasHorizontalOverflow))
         || (box().style()->overflowX() == OverflowScroll && !horizontalScrollbar());
     bool verticalScrollBarChanged = (box().hasAutoVerticalScrollbar() && (hasVerticalScrollbar() != hasVerticalOverflow))
         || (box().style()->overflowY() == OverflowScroll && !verticalScrollbar());
-    if (!visualViewportSuppliesScrollbars() && (horizontalScrollBarChanged || verticalScrollBarChanged)) {
+    if (!scrollbarsAreFrozen && !visualViewportSuppliesScrollbars() && (horizontalScrollBarChanged || verticalScrollBarChanged)) {
         if (box().hasAutoHorizontalScrollbar())
             setHasHorizontalScrollbar(hasHorizontalOverflow);
         else if (box().style()->overflowX() == OverflowScroll)
             setHasHorizontalScrollbar(true);
         if (box().hasAutoVerticalScrollbar())
             setHasVerticalScrollbar(hasVerticalOverflow);
         else if (box().style()->overflowY() == OverflowScroll)
             setHasVerticalScrollbar(true);
 
         if (hasVerticalOverflow || hasHorizontalOverflow)
             updateScrollCornerStyle();
 
         layer()->updateSelfPaintingLayer();
 
         // Force an update since we know the scrollbars have changed things.
         if (box().document().hasAnnotatedRegions())
             box().document().setAnnotatedRegionsDirty(true);
 
         // Our proprietary overflow: overlay value doesn't trigger a layout.
         if ((horizontalScrollBarChanged && box().style()->overflowX() != OverflowOverlay) || (verticalScrollBarChanged && box().style()->overflowY() != OverflowOverlay)) {
             if (!m_inOverflowRelayout) {
-                m_inOverflowRelayout = true;
-                if (delayedLayoutScope) {
+                if (relayoutIsPrevented) {
                     if (box().isLayoutBlock())
                         toLayoutBlock(box()).scrollbarsChanged(horizontalScrollBarChanged, verticalScrollBarChanged);
-                    delayedLayoutScope->setNeedsLayout(&box(), LayoutInvalidationReason::ScrollbarChanged);
-                    didMarkForDelayedLayout = true;
+                    PreventRelayoutScope::setNeedsLayout(box());
                 } else {
+                    m_inOverflowRelayout = true;
                     SubtreeLayoutScope layoutScope(box());
                     layoutScope.setNeedsLayout(&box(), LayoutInvalidationReason::ScrollbarChanged);
                     if (box().isLayoutBlock()) {
                         LayoutBlock& block = toLayoutBlock(box());
                         block.scrollbarsChanged(horizontalScrollBarChanged, verticalScrollBarChanged);
                         block.layoutBlock(true);
                     } else {
                         box().layout();
                     }
+                    m_inOverflowRelayout = false;
+                    m_scrollbarManager.destroyDetachedScrollbars();
                 }
                 LayoutObject* parent = box().parent();
                 if (parent && parent->isFlexibleBox())
                     toLayoutFlexibleBox(parent)->clearCachedMainSizeForChild(box());
-                m_inOverflowRelayout = false;
             }
         }
     }
 
     {
         // Hits in compositing/overflow/automatically-opt-into-composited-scrolling-after-style-change.html.
         DisableCompositingQueryAsserts disabler;
 
         // Set up the range (and page step/line step).
         if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar()) {
             int clientWidth = box().pixelSnappedClientWidth();
             horizontalScrollbar->setProportion(clientWidth, overflowRect().width());
         }
         if (Scrollbar* verticalScrollbar = this->verticalScrollbar()) {
             int clientHeight = box().pixelSnappedClientHeight();
             verticalScrollbar->setProportion(clientHeight, overflowRect().height());
         }
     }
 
-    if (hasOverlayScrollbars()) {
+    if (!scrollbarsAreFrozen && hasOverlayScrollbars()) {
         if (!scrollSize(HorizontalScrollbar))
             setHasHorizontalScrollbar(false);
         if (!scrollSize(VerticalScrollbar))
             setHasVerticalScrollbar(false);
     }
 
-    bool hasOverflow = hasScrollableHorizontalOverflow() || hasScrollableVerticalOverflow();
-    updateScrollableAreaSet(hasOverflow);
+    clampScrollPositionsAfterLayout();
+
+    if (!scrollbarsAreFrozen) {
+        bool hasOverflow = hasScrollableHorizontalOverflow() || hasScrollableVerticalOverflow();
+        updateScrollableAreaSet(hasOverflow);
+    }
 
     DisableCompositingQueryAsserts disabler;
     positionOverflowControls();
+}
 
-    return didMarkForDelayedLayout;
+
+void PaintLayerScrollableArea::clampScrollPositionsAfterLayout()
+{
+    // If a vertical scrollbar was removed, the min/max scroll positions may have changed,
+    // so the scroll positions needs to be clamped.  If the scroll position did not change,
+    // but the scroll origin *did* change, we still need to notify the scrollbars to
+    // update their dimensions.
+
+    if (DelayScrollPositionClampScope::clampingIsDelayed()) {
+        DelayScrollPositionClampScope::setNeedsClamp(this);
+        return;
+    }
+
+    DoublePoint newScrollPosition = clampScrollPosition(scrollPositionDouble());
+    if (newScrollPosition != scrollPositionDouble())
+        ScrollableArea::setScrollPosition(newScrollPosition, ProgrammaticScroll);
+    else if (scrollOriginChanged())
+        scrollPositionChanged(newScrollPosition, ProgrammaticScroll);
+
+    setNeedsScrollPositionClamp(false);
+    resetScrollOriginChanged();
 }
 
 ScrollBehavior PaintLayerScrollableArea::scrollBehaviorStyle() const
 {
     return box().style()->getScrollBehavior();
 }
 
 bool PaintLayerScrollableArea::hasHorizontalOverflow() const
 {
     return pixelSnappedScrollWidth() > box().pixelSnappedClientWidth();
@@ skipping 47 matching lines @@
     // Avoid drawing two sets of scrollbars when one is provided by the visual viewport.
     if (visualViewportSuppliesScrollbars()) {
         setHasHorizontalScrollbar(false);
         setHasVerticalScrollbar(false);
         return;
     }
 
     EOverflow overflowX = box().style()->overflowX();
     EOverflow overflowY = box().style()->overflowY();
 
-    // To avoid doing a relayout in updateScrollbarsAfterLayout, we try to keep any automatic scrollbar that was already present.
     bool needsHorizontalScrollbar = (hasHorizontalScrollbar() && overflowDefinesAutomaticScrollbar(overflowX)) || overflowRequiresScrollbar(overflowX);
     bool needsVerticalScrollbar = (hasVerticalScrollbar() && overflowDefinesAutomaticScrollbar(overflowY)) || overflowRequiresScrollbar(overflowY);
 
     // Look for the scrollbarModes and reset the needs Horizontal & vertical Scrollbar values based on scrollbarModes, as during force style change
     // StyleResolver::styleForDocument returns documentStyle with  no overflow values, due to which we are destorying the scrollbars that was
     // already present.
     if (box().isLayoutView()) {
         if (LocalFrame* frame = box().frame()) {
             if (FrameView* frameView = frame->view()) {
                 ScrollbarMode hMode;
@@ skipping 50 matching lines @@
 {
     layer()->updateScrollingStateAfterCompositingChange();
     const bool layersChanged = m_topmostScrollChild != m_nextTopmostScrollChild;
     m_topmostScrollChild = m_nextTopmostScrollChild;
     m_nextTopmostScrollChild = nullptr;
     return layersChanged;
 }
 
 void PaintLayerScrollableArea::updateAfterOverflowRecalc()
 {
-    computeScrollDimensions();
+    updateScrollDimensions();
     if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar()) {
         int clientWidth = box().pixelSnappedClientWidth();
         horizontalScrollbar->setProportion(clientWidth, overflowRect().width());
     }
     if (Scrollbar* verticalScrollbar = this->verticalScrollbar()) {
         int clientHeight = box().pixelSnappedClientHeight();
         verticalScrollbar->setProportion(clientHeight, overflowRect().height());
     }
 
     bool hasHorizontalOverflow = this->hasHorizontalOverflow();
@@ skipping 111 matching lines @@
     if (hasVerticalScrollbar() && verticalScrollbar()->isCustomScrollbar()) {
         if (actualLayoutObject != toLayoutScrollbar(verticalScrollbar())->owningLayoutObject())
             didCustomScrollbarOwnerChanged = true;
     }
 
     return hasAnyScrollbar && ((shouldUseCustom != hasCustom) || (shouldUseCustom && didCustomScrollbarOwnerChanged));
 }
 
 void PaintLayerScrollableArea::setHasHorizontalScrollbar(bool hasScrollbar)
 {
+    if (FreezeScrollbarsScope::scrollbarsAreFrozen())
+        return;
+
     if (hasScrollbar == hasHorizontalScrollbar())
         return;
 
     setScrollbarNeedsPaintInvalidation(HorizontalScrollbar);
 
-    m_scrollbarManager.setHasHorizontalScrollbar(hasScrollbar);
+    m_scrollbarManager.setHasHorizontalScrollbar(hasScrollbar, !m_inOverflowRelayout);
+
+    updateScrollOrigin();
 
     // Destroying or creating one bar can cause our scrollbar corner to come and go. We need to update the opposite scrollbar's style.
     if (hasHorizontalScrollbar())
         horizontalScrollbar()->styleChanged();
     if (hasVerticalScrollbar())
         verticalScrollbar()->styleChanged();
 
     setScrollCornerNeedsPaintInvalidation();
 
     // Force an update since we know the scrollbars have changed things.
     if (box().document().hasAnnotatedRegions())
         box().document().setAnnotatedRegionsDirty(true);
 }
 
 void PaintLayerScrollableArea::setHasVerticalScrollbar(bool hasScrollbar)
 {
+    if (FreezeScrollbarsScope::scrollbarsAreFrozen())
+        return;
+
     if (hasScrollbar == hasVerticalScrollbar())
         return;
 
     setScrollbarNeedsPaintInvalidation(VerticalScrollbar);
 
-    m_scrollbarManager.setHasVerticalScrollbar(hasScrollbar);
+    m_scrollbarManager.setHasVerticalScrollbar(hasScrollbar, !m_inOverflowRelayout);
+
+    updateScrollOrigin();
 
     // Destroying or creating one bar can cause our scrollbar corner to come and go. We need to update the opposite scrollbar's style.
     if (hasHorizontalScrollbar())
         horizontalScrollbar()->styleChanged();
     if (hasVerticalScrollbar())
         verticalScrollbar()->styleChanged();
 
     setScrollCornerNeedsPaintInvalidation();
 
     // Force an update since we know the scrollbars have changed things.
@@ skipping 450 matching lines @@
 {
     if (LocalFrame* frame = box().frame()) {
         if (Page* page = frame->page())
             return page->scrollingCoordinator() ? page->scrollingCoordinator()->compositorAnimationTimeline() : nullptr;
     }
     return nullptr;
 }
 
 PaintLayerScrollableArea::ScrollbarManager::ScrollbarManager(PaintLayerScrollableArea& scrollableArea)
     : m_scrollableArea(&scrollableArea)
-    , m_canDetachScrollbars(0)
     , m_hBarIsAttached(0)
     , m_vBarIsAttached(0)
 {
 }
 
 void PaintLayerScrollableArea::ScrollbarManager::dispose()
 {
-    m_canDetachScrollbars = m_hBarIsAttached = m_vBarIsAttached = 0;
+    m_hBarIsAttached = m_vBarIsAttached = 0;
     destroyScrollbar(HorizontalScrollbar);
     destroyScrollbar(VerticalScrollbar);
 }
 
-void PaintLayerScrollableArea::ScrollbarManager::setCanDetachScrollbars(bool detach)
+void PaintLayerScrollableArea::ScrollbarManager::destroyDetachedScrollbars()
 {
     ASSERT(!m_hBarIsAttached || m_hBar);
     ASSERT(!m_vBarIsAttached || m_vBar);
-    m_canDetachScrollbars = detach ? 1 : 0;
-    if (!detach) {
-        if (m_hBar && !m_hBarIsAttached)
-            destroyScrollbar(HorizontalScrollbar);
-        if (m_vBar && !m_vBarIsAttached)
-            destroyScrollbar(VerticalScrollbar);
-    }
+    if (m_hBar && !m_hBarIsAttached)
+        destroyScrollbar(HorizontalScrollbar);
+    if (m_vBar && !m_vBarIsAttached)
+        destroyScrollbar(VerticalScrollbar);
 }
 
-void PaintLayerScrollableArea::ScrollbarManager::setHasHorizontalScrollbar(bool hasScrollbar)
+void PaintLayerScrollableArea::ScrollbarManager::setHasHorizontalScrollbar(bool hasScrollbar, bool canDetach)
 {
     if (hasScrollbar) {
         // This doesn't hit in any tests, but since the equivalent code in setHasVerticalScrollbar
         // does, presumably this code does as well.
         DisableCompositingQueryAsserts disabler;
         if (!m_hBar) {
             m_hBar = createScrollbar(HorizontalScrollbar);
             m_hBarIsAttached = 1;
             if (!m_hBar->isCustomScrollbar())
                 m_scrollableArea->didAddScrollbar(*m_hBar, HorizontalScrollbar);
         } else {
             m_hBarIsAttached = 1;
         }
-
     } else {
         m_hBarIsAttached = 0;
-        if (!m_canDetachScrollbars)
+        if (!canDetach)
             destroyScrollbar(HorizontalScrollbar);
     }
 }
 
-void PaintLayerScrollableArea::ScrollbarManager::setHasVerticalScrollbar(bool hasScrollbar)
+void PaintLayerScrollableArea::ScrollbarManager::setHasVerticalScrollbar(bool hasScrollbar, bool canDetach)
 {
     if (hasScrollbar) {
         DisableCompositingQueryAsserts disabler;
         if (!m_vBar) {
             m_vBar = createScrollbar(VerticalScrollbar);
             m_vBarIsAttached = 1;
             if (!m_vBar->isCustomScrollbar())
                 m_scrollableArea->didAddScrollbar(*m_vBar, VerticalScrollbar);
         } else {
             m_vBarIsAttached = 1;
         }
-
     } else {
         m_vBarIsAttached = 0;
-        if (!m_canDetachScrollbars)
+        if (!canDetach)
             destroyScrollbar(VerticalScrollbar);
     }
 }
 
 Scrollbar* PaintLayerScrollableArea::ScrollbarManager::createScrollbar(ScrollbarOrientation orientation)
 {
     ASSERT(orientation == HorizontalScrollbar ? !m_hBarIsAttached : !m_vBarIsAttached);
     Scrollbar* scrollbar = nullptr;
     const LayoutObject& actualLayoutObject = layoutObjectForScrollbar(m_scrollableArea->box());
     bool hasCustomScrollbarStyle = actualLayoutObject.isBox() && actualLayoutObject.styleRef().hasPseudoStyle(PseudoIdScrollbar);
@@ skipping 30 matching lines @@
     scrollbar = nullptr;
 }
 
 DEFINE_TRACE(PaintLayerScrollableArea::ScrollbarManager)
 {
     visitor->trace(m_scrollableArea);
     visitor->trace(m_hBar);
     visitor->trace(m_vBar);
 }
 
+int PaintLayerScrollableArea::PreventRelayoutScope::m_count = 0;
+SubtreeLayoutScope* PaintLayerScrollableArea::PreventRelayoutScope::m_layoutScope = nullptr;
+bool PaintLayerScrollableArea::PreventRelayoutScope::m_relayoutNeeded = false;
+WTF::Vector<LayoutObject*>* PaintLayerScrollableArea::PreventRelayoutScope::m_needsRelayout = nullptr;
+
+PaintLayerScrollableArea::PreventRelayoutScope::PreventRelayoutScope(SubtreeLayoutScope& layoutScope)
+{
+    if (!m_count) {
+        ASSERT(!m_layoutScope);
+        ASSERT(!m_needsRelayout || m_needsRelayout->isEmpty());
+        m_layoutScope = &layoutScope;
+    }
+    PreventRelayoutScope::increment();

[cbiesinger, 2016/04/29 20:02:50]

Why not just increment()?

Also, why do increment() and decrement() even exist? Why not just move that code
to the constructor/destructor? I don't see any other callers, and
FreezeScrollbarsScope doesn't have them...

[szager1, 2016/05/12 20:44:51]

Yeah, I had other callers before, but they're gone.  Got rid of
increment/decrement.

+}
+
+PaintLayerScrollableArea::PreventRelayoutScope::~PreventRelayoutScope()
+{
+    PreventRelayoutScope::decrement();

[cbiesinger, 2016/04/29 20:02:50]

same here

[szager1, 2016/05/12 20:44:51]

Done.

+}
+
+void PaintLayerScrollableArea::PreventRelayoutScope::increment()
+{
+    ASSERT(m_count == 0 || m_layoutScope);
+    m_count++;
+}
+
+void PaintLayerScrollableArea::PreventRelayoutScope::decrement()
+{
+    if (--m_count == 0) {
+        if (m_relayoutNeeded) {
+            for (auto layoutObject : *m_needsRelayout)
+                m_layoutScope->setNeedsLayout(layoutObject, LayoutInvalidationReason::ScrollbarChanged);
+            m_needsRelayout->clear();
+        }
+        m_layoutScope = nullptr;
+    }
+}
+
+void PaintLayerScrollableArea::PreventRelayoutScope::setNeedsLayout(LayoutObject& layoutObject)
+{
+    ASSERT(m_count);
+    ASSERT(m_layoutScope);
+    m_relayoutNeeded = true;
+    if (!m_needsRelayout)
+        m_needsRelayout = new WTF::Vector<LayoutObject*>();
+    m_needsRelayout->append(&layoutObject);
+}
+
+void PaintLayerScrollableArea::PreventRelayoutScope::resetRelayoutNeeded()
+{
+    ASSERT(m_count == 0);
+    if (m_needsRelayout)
+        m_needsRelayout->clear();

[cbiesinger, 2016/04/29 20:02:50]

This is for the case that the second pass may have added more objects to this
vector? Seems worth adding a comment for that -- at first sight, it looks like
::decrement() should have cleared the vector already in this case.

[szager1, 2016/05/12 20:44:51]

Actually, no, this should ASSERT(!m_needsRelayout ||
m_needsRelayout->isEmpty()).  Added that.

+    m_relayoutNeeded = false;
+}
+
+int PaintLayerScrollableArea::FreezeScrollbarsScope::m_count = 0;
+
+int PaintLayerScrollableArea::DelayScrollPositionClampScope::m_count = 0;
+PersistentHeapVector<Member<PaintLayerScrollableArea>>* PaintLayerScrollableArea::DelayScrollPositionClampScope::m_needsClamp = nullptr;
+
+PaintLayerScrollableArea::DelayScrollPositionClampScope::DelayScrollPositionClampScope()
+{
+    if (!m_needsClamp)
+        m_needsClamp = new PersistentHeapVector<Member<PaintLayerScrollableArea>>();

[cbiesinger, 2016/04/29 20:02:50]

Oilpan confuses me, I trust that this is the right type to use...

In PreventRelayoutScope, you lazily create the vector when first calling
setNeedsLayout. Why create this one immediately?

[szager1, 2016/05/12 20:44:51]

These are basically static vectors that never get deleted, but oilpan complains
if I actually make them non-pointer static.  The vector is going to get
allocated eventually, it's not really important where it happens.  This was just
convenient. 

+    ASSERT(m_count > 0 || m_needsClamp->isEmpty());

[cbiesinger, 2016/04/29 20:02:50]

By the way, please name all static members as s_foo per the style guide:
https://www.chromium.org/blink/coding-style#TOC-Right:18

[szager1, 2016/05/12 20:44:51]

Done.

+    DelayScrollPositionClampScope::increment();

[cbiesinger, 2016/04/29 20:02:50]

Again, why have these increment/decrement methods instead of doing the work
directly in the ctor/dtor?

[szager1, 2016/05/12 20:44:51]

Got rid of these.

+}
+
+PaintLayerScrollableArea::DelayScrollPositionClampScope::~DelayScrollPositionClampScope()
+{
+    DelayScrollPositionClampScope::decrement();
+}
+
+void PaintLayerScrollableArea::DelayScrollPositionClampScope::increment()
+{
+    m_count++;
+}
+
+void PaintLayerScrollableArea::DelayScrollPositionClampScope::decrement()
+{
+    if (--m_count == 0)
+        DelayScrollPositionClampScope::clampScrollableAreas();
+}
+
+void PaintLayerScrollableArea::DelayScrollPositionClampScope::setNeedsClamp(PaintLayerScrollableArea* scrollableArea)
+{
+    if (!scrollableArea->needsScrollPositionClamp()) {
+        scrollableArea->setNeedsScrollPositionClamp(true);
+        m_needsClamp->append(scrollableArea);
+    }
+}
+
+void PaintLayerScrollableArea::DelayScrollPositionClampScope::clampScrollableAreas()
+{
+    for (auto& scrollableArea : *m_needsClamp)
+        scrollableArea->clampScrollPositionsAfterLayout();
+    delete m_needsClamp;
+    m_needsClamp = nullptr;
+}
+
 } // namespace blink