Refactor scroll updates during flexbox layout.

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

 /*
  * Copyright (C) 2003, 2009, 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@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 118 matching lines @@
 
         // ScrollbarManager allows a ScrollableArea to delay the destruction of a scrollbar that
         // is no longer needed, until the end of multi-pass layout.  If the scrollbar is then
         // re-added before multi-pass layout finishes, the previously "deleted" scrollbar will
         // be restored, rather than constructing a new one.
     public:
         ScrollbarManager(PaintLayerScrollableArea&);
 
         void dispose();
 
-        // When canDetachScrollbars is true, calls to setHas*Scrollbar(false) will NOT destroy
-        // an existing scrollbar, but instead detach it without destroying it.  If, subsequently,
-        // setHas*Scrollbar(true) is called, the existing scrollbar will be reattached.  When
-        // setCanDetachScrollbars(false) is called, any detached scrollbars will be destructed.
-        bool canDetachScrollbars() const { return m_canDetachScrollbars; }
-        void setCanDetachScrollbars(bool);
-
         Scrollbar* horizontalScrollbar() const { return m_hBarIsAttached ? m_hBar.get(): nullptr; }
         Scrollbar* verticalScrollbar() const { return m_vBarIsAttached ? m_vBar.get() : nullptr; }
         bool hasHorizontalScrollbar() const { return horizontalScrollbar(); }
         bool hasVerticalScrollbar() const { return verticalScrollbar(); }
 
         void setHasHorizontalScrollbar(bool hasScrollbar);
         void setHasVerticalScrollbar(bool hasScrollbar);
+        void destroyDetachedScrollbars();
 
         DECLARE_TRACE();
 
     private:
         Scrollbar* createScrollbar(ScrollbarOrientation);
         void destroyScrollbar(ScrollbarOrientation);
 
     private:
         Member<PaintLayerScrollableArea> m_scrollableArea;
 
         // The scrollbars associated with m_scrollableArea. Both can nullptr.
         Member<Scrollbar> m_hBar;
         Member<Scrollbar> m_vBar;
 
-        unsigned m_canDetachScrollbars: 1;
         unsigned m_hBarIsAttached: 1;
         unsigned m_vBarIsAttached: 1;
     };
 
 public:
+
+    // If a PreventRelayoutScope object is alive, updateAfterLayout() will not
+    // re-run box layout as a result of adding or removing scrollbars.
+    class PreventRelayoutScope {
+    public:
+        PreventRelayoutScope(SubtreeLayoutScope&);
+        ~PreventRelayoutScope();
+
+        static bool relayoutIsPrevented() { return s_count; }
+        static void setNeedsLayout(LayoutObject&);
+        static bool relayoutNeeded() { return s_count == 0 && s_relayoutNeeded; }
+        static void resetRelayoutNeeded();
+
+    private:
+        static int s_count;
+        static SubtreeLayoutScope* s_layoutScope;
+        static bool s_relayoutNeeded;
+        static WTF::Vector<LayoutObject*>* s_needsRelayout;
+    };
+
+    // If a FreezeScrollbarScope object is alive, updateAfterLayout() will not
+    // recompute the existence of overflow:auto scrollbars.
+    class FreezeScrollbarsScope {
+    public:
+        FreezeScrollbarsScope() { s_count++; }

[eae, 2016/06/02 22:57:25]

Could we add a test or assert or something to guard against pathological growth
as that would indicate a failure in the logic. Perhaps an ASSERT if it's more
than the max DOM depth?

[szager1, 2016/06/03 22:33:11]

I made these classes STACK_ALLOCATED, is that good enough?

+        ~FreezeScrollbarsScope() { s_count--; }
+
+        static bool scrollbarsAreFrozen() { return s_count; }
+
+    private:
+        static int s_count;
+    };
+
+    // If a DelayScrollPositionClampScope object is alive, updateAfterLayout() will not
+    // clamp scroll positions to ensure they are in the valid range.  When
+    // the last DelayScrollPositionClampScope object is destructed, all PaintLayerScrollableArea's
+    // that delayed clamping their positions will immediately clamp them.
+    class DelayScrollPositionClampScope {
+    public:
+        DelayScrollPositionClampScope();
+        ~DelayScrollPositionClampScope();
+
+        static bool clampingIsDelayed() { return s_count; }
+        static void setNeedsClamp(PaintLayerScrollableArea*);
+
+    private:
+        static void clampScrollableAreas();
+
+        static int s_count;
+        static PersistentHeapVector<Member<PaintLayerScrollableArea>>* s_needsClamp;
+    };
+
     // FIXME: We should pass in the LayoutBox but this opens a window
     // for crashers during PaintLayer setup (see crbug.com/368062).
     static PaintLayerScrollableArea* create(PaintLayer& layer)
     {
         return new PaintLayerScrollableArea(layer);
     }
 
     ~PaintLayerScrollableArea() override;
     void dispose();
 
@@ skipping 78 matching lines @@
     void scrollToYOffset(double y, ScrollOffsetClamping clamp = ScrollOffsetUnclamped, ScrollBehavior scrollBehavior = ScrollBehaviorInstant)
     {
         scrollToOffset(DoubleSize(scrollXOffset(), y), clamp, scrollBehavior);
     }
 
     void setScrollPosition(const DoublePoint& position, ScrollType scrollType, ScrollBehavior scrollBehavior = ScrollBehaviorInstant) override
     {
         scrollToOffset(toDoubleSize(position), ScrollOffsetClamped, scrollBehavior, scrollType);
     }
 
-    // Returns true if a layout object was marked for layout. In such a case, the layout scope's root
-    // should be laid out again.
-    bool updateAfterLayout(SubtreeLayoutScope* = nullptr);
+    // TODO(szager): Actually run these after all of layout is finished.  Currently, they
+    // run at the end of box()'es layout (or after all flexbox layout has finished) but while
+    // document layout is still happening.
+    void updateAfterLayout();
+    void clampScrollPositionsAfterLayout();
+
     void updateAfterStyleChange(const ComputedStyle*);
     void updateAfterOverflowRecalc();
 
     bool updateAfterCompositingChange() override;
 
     bool hasScrollbar() const { return hasHorizontalScrollbar() || hasVerticalScrollbar(); }
     bool hasOverflowControls() const { return hasScrollbar() || scrollCorner() || resizer(); }
 
     LayoutScrollbarPart* scrollCorner() const override { return m_scrollCorner; }
 
@@ skipping 64 matching lines @@
     IntRect rectForVerticalScrollbar(const IntRect& borderBoxRect) const;
 
     Widget* getWidget() override;
     ScrollAnchor& scrollAnchor() { return m_scrollAnchor; }
     bool isPaintLayerScrollableArea() const override { return true; }
 
     bool shouldRebuildHorizontalScrollbarLayer() const { return m_rebuildHorizontalScrollbarLayer; }
     bool shouldRebuildVerticalScrollbarLayer() const { return m_rebuildVerticalScrollbarLayer; }
     void resetRebuildScrollbarLayerFlags();
 
+    bool needsScrollPositionClamp() const { return m_needsScrollPositionClamp; }
+    void setNeedsScrollPositionClamp(bool val) { m_needsScrollPositionClamp = val; }
+
     StickyConstraintsMap& stickyConstraintsMap() { return ensureRareData().m_stickyConstraintsMap; }
     void invalidateAllStickyConstraints();
     void invalidateStickyConstraintsFor(PaintLayer*, bool needsCompositingUpdate = true);
 
     DECLARE_VIRTUAL_TRACE();
 
 private:
     explicit PaintLayerScrollableArea(PaintLayer&);
 
     bool hasHorizontalOverflow() const;
     bool hasVerticalOverflow() const;
     bool hasScrollableHorizontalOverflow() const;
     bool hasScrollableVerticalOverflow() const;
     bool visualViewportSuppliesScrollbars() const;
 
     bool needsScrollbarReconstruction() const;
 
-    void computeScrollDimensions();
+    void updateScrollOrigin();
+    void updateScrollDimensions();
 
     void setScrollOffset(const DoublePoint&, ScrollType) override;
 
     int verticalScrollbarStart(int minX, int maxX) const;
     int horizontalScrollbarStart(int minX) const;
     IntSize scrollbarOffset(const Scrollbar&) const;
 
     void setHasHorizontalScrollbar(bool hasScrollbar);
     void setHasVerticalScrollbar(bool hasScrollbar);
 
@@ skipping 37 matching lines @@
     // FIXME: once cc can handle composited scrolling with clip paths, we will
     // no longer need this bit.
     unsigned m_needsCompositedScrolling : 1;
 
     // Set to indicate that a scrollbar layer, if present, needs to be rebuilt
     // in the next compositing update because the underlying blink::Scrollbar
     // instance has been reconstructed.
     unsigned m_rebuildHorizontalScrollbarLayer : 1;
     unsigned m_rebuildVerticalScrollbarLayer : 1;
 
+    unsigned m_needsScrollPositionClamp : 1;
+
     // The width/height of our scrolled area.
     // This is OverflowModel's layout overflow translated to physical
     // coordinates. See OverflowModel for the different overflow and
     // LayoutBoxModelObject for the coordinate systems.
     LayoutRect m_overflowRect;
 
     // ScrollbarManager holds the Scrollbar instances.
     ScrollbarManager m_scrollbarManager;
 
     // This is the (scroll) offset from scrollOrigin().
@@ skipping 16 matching lines @@
 #endif
 };
 
 DEFINE_TYPE_CASTS(PaintLayerScrollableArea, ScrollableArea, scrollableArea,
     scrollableArea->isPaintLayerScrollableArea(),
     scrollableArea.isPaintLayerScrollableArea());
 
 } // namespace blink
 
 #endif // LayerScrollableArea_h