Need to roll back the multicol machinery state when re-laying out a block child.

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

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 148 matching lines @@
 // Some features, such as floats, margin collapsing and fragmentation, require some knowledge about
 // things that happened when laying out previous block child siblings. Only looking at the object
 // currently being laid out isn't always enough.
 class BlockChildrenLayoutInfo {
 public:
     BlockChildrenLayoutInfo(LayoutBlockFlow* blockFlow, LayoutUnit beforeEdge, LayoutUnit afterEdge)
         : m_marginInfo(blockFlow, beforeEdge, afterEdge)
         , m_previousBreakAfterValue(BreakAuto)
         , m_isAtFirstInFlowChild(true) { }
 
+    // Store multicol layout state before first layout of a block child. The child may contain a
+    // column spanner. If we need to re-lay out the block child because our initial logical top
+    // estimate was wrong, we need to roll back to how things were before laying out the child.
+    void storeMultiColumnLayoutState(const LayoutFlowThread& flowThread)
+    {
+        m_multiColumnLayoutState = flowThread.multiColumnLayoutState();
+    }
+    void rollBackToInitialMultiColumnLayoutState(LayoutFlowThread& flowThread)
+    {
+        flowThread.restoreMultiColumnLayoutState(m_multiColumnLayoutState);
+    }
+
     const MarginInfo& marginInfo() const { return m_marginInfo; }
     MarginInfo& marginInfo() { return m_marginInfo; }
     LayoutUnit& previousFloatLogicalBottom() { return m_previousFloatLogicalBottom; }
 
     EBreak previousBreakAfterValue() const { return m_previousBreakAfterValue; }
     void setPreviousBreakAfterValue(EBreak value) { m_previousBreakAfterValue = value; }
 
     bool isAtFirstInFlowChild() const { return m_isAtFirstInFlowChild; }
     void clearIsAtFirstInFlowChild() { m_isAtFirstInFlowChild = false; }
 
 private:
+    MultiColumnLayoutState m_multiColumnLayoutState;
     MarginInfo m_marginInfo;
     LayoutUnit m_previousFloatLogicalBottom;
     EBreak m_previousBreakAfterValue;
     bool m_isAtFirstInFlowChild;
 };
 
 LayoutBlockFlow::LayoutBlockFlow(ContainerNode* node)
     : LayoutBlock(node)
 {
     static_assert(sizeof(MarginInfo) == sizeof(SameSizeAsMarginInfo), "MarginInfo should stay small");
@@ skipping 426 matching lines @@
         if (std::max(previousFloatLogicalBottom, lowestFloatLogicalBottom()) > newLogicalTop)
             markDescendantsWithFloats = true;
     }
 
     if (markDescendantsWithFloats)
         child.markAllDescendantsWithFloatsForLayout();
 }
 
 bool LayoutBlockFlow::positionAndLayoutOnceIfNeeded(LayoutBox& child, LayoutUnit newLogicalTop, BlockChildrenLayoutInfo& layoutInfo)
 {
+    if (LayoutFlowThread* flowThread = flowThreadContainingBlock())
+        layoutInfo.rollBackToInitialMultiColumnLayoutState(*flowThread);
+
     if (child.isLayoutBlockFlow()) {
         LayoutUnit& previousFloatLogicalBottom = layoutInfo.previousFloatLogicalBottom();
         LayoutBlockFlow& childBlockFlow = toLayoutBlockFlow(child);
         if (childBlockFlow.containsFloats() || containsFloats())
             markDescendantsWithFloatsForLayoutIfNeeded(childBlockFlow, newLogicalTop, previousFloatLogicalBottom);
 
         // TODO(mstensho): A writing mode root is one thing, but we should be able to skip anything
         // that establishes a new block formatting context here. Their floats don't affect us.
         if (!childBlockFlow.isWritingModeRoot())
             previousFloatLogicalBottom = std::max(previousFloatLogicalBottom, childBlockFlow.logicalTop() + childBlockFlow.lowestFloatLogicalBottom());
@@ skipping 55 matching lines @@
 
     // Try to guess our correct logical top position. In most cases this guess will
     // be correct. Only if we're wrong (when we compute the real logical top position)
     // will we have to potentially relayout.
     LayoutUnit estimateWithoutPagination;
     LayoutUnit logicalTopEstimate = estimateLogicalTopPosition(child, layoutInfo, estimateWithoutPagination);
 
     // Cache our old rect so that we can dirty the proper paint invalidation rects if the child moves.
     LayoutRect oldRect = child.frameRect();
 
+    if (LayoutFlowThread* flowThread = flowThreadContainingBlock())
+        layoutInfo.storeMultiColumnLayoutState(*flowThread);
+
     // Use the estimated block position and lay out the child if needed. After child layout, when
     // we have enough information to perform proper margin collapsing, float clearing and
     // pagination, we may have to reposition and lay out again if the estimate was wrong.
     bool childNeededLayout = positionAndLayoutOnceIfNeeded(child, logicalTopEstimate, layoutInfo);
 
     // Cache if we are at the top of the block right now.
     bool atBeforeSideOfBlock = marginInfo.atBeforeSideOfBlock();
     bool childIsSelfCollapsing = child.isSelfCollapsingBlock();
     bool childDiscardMarginBefore = mustDiscardMarginBeforeForChild(child);
     bool childDiscardMarginAfter = mustDiscardMarginAfterForChild(child);
@@ skipping 3064 matching lines @@
             if (!rect.isEmpty())
                 rects.append(rect);
         }
     }
 
     if (inlineElementContinuation)
         inlineElementContinuation->addOutlineRects(rects, additionalOffset + (inlineElementContinuation->containingBlock()->location() - location()), includeBlockOverflows);
 }
 
 } // namespace blink