Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1355 insertions, 0 deletions

diff --git a/layout/generic/nsColumnSetFrame.cpp b/layout/generic/nsColumnSetFrame.cpp
new file mode 100644
index 0000000000..cd97519a98
--- /dev/null
+++ b/layout/generic/nsColumnSetFrame.cpp
@@ -0,0 +1,1355 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* rendering object for css3 multi-column layout */
+
+#include "nsColumnSetFrame.h"
+
+#include "mozilla/ColumnUtils.h"
+#include "mozilla/Logging.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "mozilla/ToString.h"
+#include "nsCSSRendering.h"
+#include "nsDisplayList.h"
+#include "nsIFrameInlines.h"
+#include "nsLayoutUtils.h"
+
+using namespace mozilla;
+using namespace mozilla::layout;
+
+// To see this log, use $ MOZ_LOG=ColumnSet:4 ./mach run
+static LazyLogModule sColumnSetLog("ColumnSet");
+#define COLUMN_SET_LOG(msg, ...) \
+  MOZ_LOG(sColumnSetLog, LogLevel::Debug, (msg, ##__VA_ARGS__))
+
+class nsDisplayColumnRule : public nsPaintedDisplayItem {
+ public:
+  nsDisplayColumnRule(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame)
+      : nsPaintedDisplayItem(aBuilder, aFrame) {
+    MOZ_COUNT_CTOR(nsDisplayColumnRule);
+  }
+  MOZ_COUNTED_DTOR_OVERRIDE(nsDisplayColumnRule)
+
+  nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) const override {
+    *aSnap = false;
+    // We just return the frame's ink-overflow rect, which is guaranteed to
+    // contain all the column-rule areas.  It's not worth calculating the exact
+    // union of those areas since it would only lead to performance improvements
+    // during painting in rare edge cases.
+    return mFrame->InkOverflowRect() + ToReferenceFrame();
+  }
+
+  bool CreateWebRenderCommands(
+      mozilla::wr::DisplayListBuilder& aBuilder,
+      mozilla::wr::IpcResourceUpdateQueue& aResources,
+      const StackingContextHelper& aSc,
+      mozilla::layers::RenderRootStateManager* aManager,
+      nsDisplayListBuilder* aDisplayListBuilder) override;
+  void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
+
+  NS_DISPLAY_DECL_NAME("ColumnRule", TYPE_COLUMN_RULE);
+
+ private:
+  nsTArray<nsCSSBorderRenderer> mBorderRenderers;
+};
+
+void nsDisplayColumnRule::Paint(nsDisplayListBuilder* aBuilder,
+                                gfxContext* aCtx) {
+  static_cast<nsColumnSetFrame*>(mFrame)->CreateBorderRenderers(
+      mBorderRenderers, aCtx, GetPaintRect(aBuilder, aCtx), ToReferenceFrame());
+
+  for (auto iter = mBorderRenderers.begin(); iter != mBorderRenderers.end();
+       iter++) {
+    iter->DrawBorders();
+  }
+}
+
+bool nsDisplayColumnRule::CreateWebRenderCommands(
+    mozilla::wr::DisplayListBuilder& aBuilder,
+    mozilla::wr::IpcResourceUpdateQueue& aResources,
+    const StackingContextHelper& aSc,
+    mozilla::layers::RenderRootStateManager* aManager,
+    nsDisplayListBuilder* aDisplayListBuilder) {
+  RefPtr dt = gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget();
+  if (!dt || !dt->IsValid()) {
+    return false;
+  }
+  gfxContext screenRefCtx(dt);
+
+  bool dummy;
+  static_cast<nsColumnSetFrame*>(mFrame)->CreateBorderRenderers(
+      mBorderRenderers, &screenRefCtx, GetBounds(aDisplayListBuilder, &dummy),
+      ToReferenceFrame());
+
+  if (mBorderRenderers.IsEmpty()) {
+    return true;
+  }
+
+  for (auto& renderer : mBorderRenderers) {
+    renderer.CreateWebRenderCommands(this, aBuilder, aResources, aSc);
+  }
+
+  return true;
+}
+
+/**
+ * Tracking issues:
+ *
+ * XXX cursor movement around the top and bottom of colums seems to make the
+ * editor lose the caret.
+ *
+ * XXX should we support CSS columns applied to table elements?
+ */
+nsContainerFrame* NS_NewColumnSetFrame(PresShell* aPresShell,
+                                       ComputedStyle* aStyle,
+                                       nsFrameState aStateFlags) {
+  nsColumnSetFrame* it =
+      new (aPresShell) nsColumnSetFrame(aStyle, aPresShell->GetPresContext());
+  it->AddStateBits(aStateFlags);
+  return it;
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsColumnSetFrame)
+
+nsColumnSetFrame::nsColumnSetFrame(ComputedStyle* aStyle,
+                                   nsPresContext* aPresContext)
+    : nsContainerFrame(aStyle, aPresContext, kClassID),
+      mLastBalanceBSize(NS_UNCONSTRAINEDSIZE) {}
+
+void nsColumnSetFrame::ForEachColumnRule(
+    const std::function<void(const nsRect& lineRect)>& aSetLineRect,
+    const nsPoint& aPt) const {
+  nsIFrame* child = mFrames.FirstChild();
+  if (!child) return;  // no columns
+
+  nsIFrame* nextSibling = child->GetNextSibling();
+  if (!nextSibling) return;  // 1 column only - this means no gap to draw on
+
+  const nsStyleColumn* colStyle = StyleColumn();
+  nscoord ruleWidth = colStyle->GetColumnRuleWidth();
+  if (!ruleWidth) return;
+
+  WritingMode wm = GetWritingMode();
+  bool isVertical = wm.IsVertical();
+  bool isRTL = wm.IsBidiRTL();
+
+  nsRect contentRect = GetContentRectRelativeToSelf() + aPt;
+  nsSize ruleSize = isVertical ? nsSize(contentRect.width, ruleWidth)
+                               : nsSize(ruleWidth, contentRect.height);
+
+  while (nextSibling) {
+    // The frame tree goes RTL in RTL.
+    // The |prevFrame| and |nextFrame| frames here are the visually preceding
+    // (left/above) and following (right/below) frames, not in logical writing-
+    // mode direction.
+    nsIFrame* prevFrame = isRTL ? nextSibling : child;
+    nsIFrame* nextFrame = isRTL ? child : nextSibling;
+
+    // Each child frame's position coordinates is actually relative to this
+    // nsColumnSetFrame.
+    // linePt will be at the top-left edge to paint the line.
+    nsPoint linePt;
+    if (isVertical) {
+      nscoord edgeOfPrev = prevFrame->GetRect().YMost() + aPt.y;
+      nscoord edgeOfNext = nextFrame->GetRect().Y() + aPt.y;
+      linePt = nsPoint(contentRect.x,
+                       (edgeOfPrev + edgeOfNext - ruleSize.height) / 2);
+    } else {
+      nscoord edgeOfPrev = prevFrame->GetRect().XMost() + aPt.x;
+      nscoord edgeOfNext = nextFrame->GetRect().X() + aPt.x;
+      linePt = nsPoint((edgeOfPrev + edgeOfNext - ruleSize.width) / 2,
+                       contentRect.y);
+    }
+
+    aSetLineRect(nsRect(linePt, ruleSize));
+
+    child = nextSibling;
+    nextSibling = nextSibling->GetNextSibling();
+  }
+}
+
+void nsColumnSetFrame::CreateBorderRenderers(
+    nsTArray<nsCSSBorderRenderer>& aBorderRenderers, gfxContext* aCtx,
+    const nsRect& aDirtyRect, const nsPoint& aPt) {
+  WritingMode wm = GetWritingMode();
+  bool isVertical = wm.IsVertical();
+  const nsStyleColumn* colStyle = StyleColumn();
+  StyleBorderStyle ruleStyle;
+
+  // Per spec, inset => ridge and outset => groove
+  if (colStyle->mColumnRuleStyle == StyleBorderStyle::Inset) {
+    ruleStyle = StyleBorderStyle::Ridge;
+  } else if (colStyle->mColumnRuleStyle == StyleBorderStyle::Outset) {
+    ruleStyle = StyleBorderStyle::Groove;
+  } else {
+    ruleStyle = colStyle->mColumnRuleStyle;
+  }
+
+  nscoord ruleWidth = colStyle->GetColumnRuleWidth();
+  if (!ruleWidth) {
+    return;
+  }
+
+  aBorderRenderers.Clear();
+  nscolor ruleColor =
+      GetVisitedDependentColor(&nsStyleColumn::mColumnRuleColor);
+
+  nsPresContext* pc = PresContext();
+  // In order to re-use a large amount of code, we treat the column rule as a
+  // border. We create a new border style object and fill in all the details of
+  // the column rule as the left border. PaintBorder() does all the rendering
+  // for us, so we not only save an enormous amount of code but we'll support
+  // all the line styles that we support on borders!
+  nsStyleBorder border;
+  Sides skipSides;
+  if (isVertical) {
+    border.SetBorderWidth(eSideTop, ruleWidth, pc->AppUnitsPerDevPixel());
+    border.SetBorderStyle(eSideTop, ruleStyle);
+    border.mBorderTopColor = StyleColor::FromColor(ruleColor);
+    skipSides |= mozilla::SideBits::eLeftRight;
+    skipSides |= mozilla::SideBits::eBottom;
+  } else {
+    border.SetBorderWidth(eSideLeft, ruleWidth, pc->AppUnitsPerDevPixel());
+    border.SetBorderStyle(eSideLeft, ruleStyle);
+    border.mBorderLeftColor = StyleColor::FromColor(ruleColor);
+    skipSides |= mozilla::SideBits::eTopBottom;
+    skipSides |= mozilla::SideBits::eRight;
+  }
+  // If we use box-decoration-break: slice (the default), the border
+  // renderers will require clipping if we have continuations (see the
+  // aNeedsClip parameter to ConstructBorderRenderer in nsCSSRendering).
+  //
+  // Since it doesn't matter which box-decoration-break we use since
+  // we're only drawing borders (and not border-images), use 'clone'.
+  border.mBoxDecorationBreak = StyleBoxDecorationBreak::Clone;
+
+  ForEachColumnRule(
+      [&](const nsRect& aLineRect) {
+        // Assert that we're not drawing a border-image here; if we were, we
+        // couldn't ignore the ImgDrawResult that PaintBorderWithStyleBorder
+        // returns.
+        MOZ_ASSERT(border.mBorderImageSource.IsNone());
+
+        gfx::DrawTarget* dt = aCtx ? aCtx->GetDrawTarget() : nullptr;
+        bool borderIsEmpty = false;
+        Maybe<nsCSSBorderRenderer> br =
+            nsCSSRendering::CreateBorderRendererWithStyleBorder(
+                pc, dt, this, aDirtyRect, aLineRect, border, Style(),
+                &borderIsEmpty, skipSides);
+        if (br.isSome()) {
+          MOZ_ASSERT(!borderIsEmpty);
+          aBorderRenderers.AppendElement(br.value());
+        }
+      },
+      aPt);
+}
+
+static uint32_t ColumnBalancingDepth(const ReflowInput& aReflowInput,
+                                     uint32_t aMaxDepth) {
+  uint32_t depth = 0;
+  for (const ReflowInput* ri = aReflowInput.mParentReflowInput;
+       ri && depth < aMaxDepth; ri = ri->mParentReflowInput) {
+    if (ri->mFlags.mIsColumnBalancing) {
+      ++depth;
+    }
+  }
+  return depth;
+}
+
+nsColumnSetFrame::ReflowConfig nsColumnSetFrame::ChooseColumnStrategy(
+    const ReflowInput& aReflowInput, bool aForceAuto = false) const {
+  const nsStyleColumn* colStyle = StyleColumn();
+  nscoord availContentISize = aReflowInput.AvailableISize();
+  if (aReflowInput.ComputedISize() != NS_UNCONSTRAINEDSIZE) {
+    availContentISize = aReflowInput.ComputedISize();
+  }
+
+  nscoord colBSize = aReflowInput.AvailableBSize();
+  nscoord colGap =
+      ColumnUtils::GetColumnGap(this, aReflowInput.ComputedISize());
+  int32_t numColumns = colStyle->mColumnCount;
+
+  // If column-fill is set to 'balance' or we have a column-span sibling, then
+  // we want to balance the columns.
+  bool isBalancing = (colStyle->mColumnFill == StyleColumnFill::Balance ||
+                      HasColumnSpanSiblings()) &&
+                     !aForceAuto;
+  if (isBalancing) {
+    const uint32_t kMaxNestedColumnBalancingDepth = 2;
+    const uint32_t balancingDepth =
+        ColumnBalancingDepth(aReflowInput, kMaxNestedColumnBalancingDepth);
+    if (balancingDepth == kMaxNestedColumnBalancingDepth) {
+      isBalancing = false;
+      numColumns = 1;
+    }
+  }
+
+  nscoord colISize;
+  // In vertical writing-mode, "column-width" (inline size) will actually be
+  // physical height, but its CSS name is still column-width.
+  if (colStyle->mColumnWidth.IsLength()) {
+    colISize =
+        ColumnUtils::ClampUsedColumnWidth(colStyle->mColumnWidth.AsLength());
+    NS_ASSERTION(colISize >= 0, "negative column width");
+    // Reduce column count if necessary to make columns fit in the
+    // available width. Compute max number of columns that fit in
+    // availContentISize, satisfying colGap*(maxColumns - 1) +
+    // colISize*maxColumns <= availContentISize
+    if (availContentISize != NS_UNCONSTRAINEDSIZE && colGap + colISize > 0 &&
+        numColumns > 0) {
+      // This expression uses truncated rounding, which is what we
+      // want
+      int32_t maxColumns =
+          std::min(nscoord(nsStyleColumn::kMaxColumnCount),
+                   (availContentISize + colGap) / (colGap + colISize));
+      numColumns = std::max(1, std::min(numColumns, maxColumns));
+    }
+  } else if (numColumns > 0 && availContentISize != NS_UNCONSTRAINEDSIZE) {
+    nscoord iSizeMinusGaps = availContentISize - colGap * (numColumns - 1);
+    colISize = iSizeMinusGaps / numColumns;
+  } else {
+    colISize = NS_UNCONSTRAINEDSIZE;
+  }
+  // Take care of the situation where there's only one column but it's
+  // still too wide
+  colISize = std::max(1, std::min(colISize, availContentISize));
+
+  nscoord expectedISizeLeftOver = 0;
+
+  if (colISize != NS_UNCONSTRAINEDSIZE &&
+      availContentISize != NS_UNCONSTRAINEDSIZE) {
+    // distribute leftover space
+
+    // First, determine how many columns will be showing if the column
+    // count is auto
+    if (numColumns <= 0) {
+      // choose so that colGap*(nominalColumnCount - 1) +
+      // colISize*nominalColumnCount is nearly availContentISize
+      // make sure to round down
+      if (colGap + colISize > 0) {
+        numColumns = (availContentISize + colGap) / (colGap + colISize);
+        // The number of columns should never exceed kMaxColumnCount.
+        numColumns =
+            std::min(nscoord(nsStyleColumn::kMaxColumnCount), numColumns);
+      }
+      if (numColumns <= 0) {
+        numColumns = 1;
+      }
+    }
+
+    // Compute extra space and divide it among the columns
+    nscoord extraSpace =
+        std::max(0, availContentISize -
+                        (colISize * numColumns + colGap * (numColumns - 1)));
+    nscoord extraToColumns = extraSpace / numColumns;
+    colISize += extraToColumns;
+    expectedISizeLeftOver = extraSpace - (extraToColumns * numColumns);
+  }
+
+  if (isBalancing) {
+    if (numColumns <= 0) {
+      // Hmm, auto column count, column width or available width is unknown,
+      // and balancing is required. Let's just use one column then.
+      numColumns = 1;
+    }
+    colBSize = std::min(mLastBalanceBSize, colBSize);
+  } else {
+    // CSS Fragmentation spec says, "To guarantee progress, fragmentainers are
+    // assumed to have a minimum block size of 1px regardless of their used
+    // size." https://drafts.csswg.org/css-break/#breaking-rules
+    //
+    // Note: we don't enforce the minimum block-size during balancing because
+    // this affects the result. If a balancing column container or its
+    // next-in-flows has zero block-size, it eventually gives up balancing, and
+    // ends up here.
+    colBSize = std::max(colBSize, nsPresContext::CSSPixelsToAppUnits(1));
+  }
+
+  ReflowConfig config;
+  config.mUsedColCount = numColumns;
+  config.mColISize = colISize;
+  config.mExpectedISizeLeftOver = expectedISizeLeftOver;
+  config.mColGap = colGap;
+  config.mColBSize = colBSize;
+  config.mIsBalancing = isBalancing;
+  config.mForceAuto = aForceAuto;
+  config.mKnownFeasibleBSize = NS_UNCONSTRAINEDSIZE;
+  config.mKnownInfeasibleBSize = 0;
+
+  COLUMN_SET_LOG(
+      "%s: this=%p, mUsedColCount=%d, mColISize=%d, "
+      "mExpectedISizeLeftOver=%d, mColGap=%d, mColBSize=%d, mIsBalancing=%d",
+      __func__, this, config.mUsedColCount, config.mColISize,
+      config.mExpectedISizeLeftOver, config.mColGap, config.mColBSize,
+      config.mIsBalancing);
+
+  return config;
+}
+
+static void MarkPrincipalChildrenDirty(nsIFrame* aFrame) {
+  for (nsIFrame* childFrame : aFrame->PrincipalChildList()) {
+    childFrame->MarkSubtreeDirty();
+  }
+}
+
+static void MoveChildTo(nsIFrame* aChild, LogicalPoint aOrigin, WritingMode aWM,
+                        const nsSize& aContainerSize) {
+  if (aChild->GetLogicalPosition(aWM, aContainerSize) == aOrigin) {
+    return;
+  }
+
+  aChild->SetPosition(aWM, aOrigin, aContainerSize);
+  nsContainerFrame::PlaceFrameView(aChild);
+}
+
+nscoord nsColumnSetFrame::GetMinISize(gfxContext* aRenderingContext) {
+  nscoord iSize = 0;
+  DISPLAY_MIN_INLINE_SIZE(this, iSize);
+
+  if (mFrames.FirstChild()) {
+    // We want to ignore this in the case that we're size contained
+    // because our children should not contribute to our
+    // intrinsic size.
+    iSize = mFrames.FirstChild()->GetMinISize(aRenderingContext);
+  }
+  const nsStyleColumn* colStyle = StyleColumn();
+  if (colStyle->mColumnWidth.IsLength()) {
+    nscoord colISize =
+        ColumnUtils::ClampUsedColumnWidth(colStyle->mColumnWidth.AsLength());
+    // As available width reduces to zero, we reduce our number of columns
+    // to one, and don't enforce the column width, so just return the min
+    // of the child's min-width with any specified column width.
+    iSize = std::min(iSize, colISize);
+  } else {
+    NS_ASSERTION(colStyle->mColumnCount > 0,
+                 "column-count and column-width can't both be auto");
+    // As available width reduces to zero, we still have mColumnCount columns,
+    // so compute our minimum size based on the number of columns and their gaps
+    // and minimum per-column size.
+    nscoord colGap = ColumnUtils::GetColumnGap(this, NS_UNCONSTRAINEDSIZE);
+    iSize = ColumnUtils::IntrinsicISize(colStyle->mColumnCount, colGap, iSize);
+  }
+  // XXX count forced column breaks here? Maybe we should return the child's
+  // min-width times the minimum number of columns.
+  return iSize;
+}
+
+nscoord nsColumnSetFrame::GetPrefISize(gfxContext* aRenderingContext) {
+  // Our preferred width is our desired column width, if specified, otherwise
+  // the child's preferred width, times the number of columns, plus the width
+  // of any required column gaps
+  // XXX what about forced column breaks here?
+  nscoord result = 0;
+  DISPLAY_PREF_INLINE_SIZE(this, result);
+  const nsStyleColumn* colStyle = StyleColumn();
+
+  nscoord colISize;
+  if (colStyle->mColumnWidth.IsLength()) {
+    colISize =
+        ColumnUtils::ClampUsedColumnWidth(colStyle->mColumnWidth.AsLength());
+  } else if (mFrames.FirstChild()) {
+    // We want to ignore this in the case that we're size contained
+    // because our children should not contribute to our
+    // intrinsic size.
+    colISize = mFrames.FirstChild()->GetPrefISize(aRenderingContext);
+  } else {
+    colISize = 0;
+  }
+
+  // If column-count is auto, assume one column.
+  uint32_t numColumns =
+      colStyle->mColumnCount == nsStyleColumn::kColumnCountAuto
+          ? 1
+          : colStyle->mColumnCount;
+  nscoord colGap = ColumnUtils::GetColumnGap(this, NS_UNCONSTRAINEDSIZE);
+  result = ColumnUtils::IntrinsicISize(numColumns, colGap, colISize);
+  return result;
+}
+
+nsColumnSetFrame::ColumnBalanceData nsColumnSetFrame::ReflowColumns(
+    ReflowOutput& aDesiredSize, const ReflowInput& aReflowInput,
+    nsReflowStatus& aStatus, const ReflowConfig& aConfig,
+    bool aUnboundedLastColumn) {
+  ColumnBalanceData colData;
+  bool allFit = true;
+  WritingMode wm = GetWritingMode();
+  const bool isRTL = wm.IsBidiRTL();
+  const bool shrinkingBSize = mLastBalanceBSize > aConfig.mColBSize;
+  const bool changingBSize = mLastBalanceBSize != aConfig.mColBSize;
+
+  COLUMN_SET_LOG(
+      "%s: Doing column reflow pass: mLastBalanceBSize=%d,"
+      " mColBSize=%d, RTL=%d, mUsedColCount=%d,"
+      " mColISize=%d, mColGap=%d",
+      __func__, mLastBalanceBSize, aConfig.mColBSize, isRTL,
+      aConfig.mUsedColCount, aConfig.mColISize, aConfig.mColGap);
+
+  DrainOverflowColumns();
+
+  if (changingBSize) {
+    mLastBalanceBSize = aConfig.mColBSize;
+    // XXX Seems like this could fire if incremental reflow pushed the column
+    // set down so we reflow incrementally with a different available height.
+    // We need a way to do an incremental reflow and be sure availableHeight
+    // changes are taken account of! Right now I think block frames with
+    // absolute children might exit early.
+    /*
+    NS_ASSERTION(
+        aKidReason != eReflowReason_Incremental,
+        "incremental reflow should not have changed the balance height");
+    */
+  }
+
+  nsRect contentRect(0, 0, 0, 0);
+  OverflowAreas overflowRects;
+
+  nsIFrame* child = mFrames.FirstChild();
+  LogicalPoint childOrigin(wm, 0, 0);
+
+  // In vertical-rl mode, columns will not be correctly placed if the
+  // reflowInput's ComputedWidth() is UNCONSTRAINED (in which case we'll get
+  // a containerSize.width of zero here). In that case, the column positions
+  // will be adjusted later, after our correct contentSize is known.
+  //
+  // When column-span is enabled, containerSize.width is always constrained.
+  // However, for RTL, we need to adjust the column positions as well after our
+  // correct containerSize is known.
+  nsSize containerSize = aReflowInput.ComputedSizeAsContainerIfConstrained();
+
+  const nscoord computedBSize =
+      aReflowInput.mParentReflowInput->ComputedBSize();
+  nscoord contentBEnd = 0;
+  bool reflowNext = false;
+
+  while (child) {
+    const bool reflowLastColumnWithUnconstrainedAvailBSize =
+        aUnboundedLastColumn && colData.mColCount == aConfig.mUsedColCount &&
+        aConfig.mIsBalancing;
+
+    // We need to reflow the child (column) ...
+    bool reflowChild =
+        // if we are told to do so;
+        aReflowInput.ShouldReflowAllKids() ||
+        // if the child is dirty;
+        child->IsSubtreeDirty() ||
+        // if it's the last child because we need to obtain the block-end
+        // margin;
+        !child->GetNextSibling() ||
+        // if the next column is dirty, because the next column's first line(s)
+        // might be pullable back to this column;
+        child->GetNextSibling()->IsSubtreeDirty() ||
+        // if this is the last column and we are supposed to assign unbounded
+        // block-size to it, because that could change the available block-size
+        // from the last time we reflowed it and we should try to pull all the
+        // content from its next sibling (Note that it might be the last column,
+        // but not be the last child because the desired number of columns has
+        // changed.)
+        reflowLastColumnWithUnconstrainedAvailBSize;
+
+    // If column-fill is auto (not the default), then we might need to
+    // move content between columns for any change in column block-size.
+    //
+    // The same is true if we have a non-'auto' computed block-size.
+    //
+    // FIXME: It's not clear to me why it's *ever* valid to have
+    // reflowChild be false when changingBSize is true, since it
+    // seems like a child broken over multiple columns might need to
+    // change the size of the fragment in each column.
+    if (!reflowChild && changingBSize &&
+        (StyleColumn()->mColumnFill == StyleColumnFill::Auto ||
+         computedBSize != NS_UNCONSTRAINEDSIZE)) {
+      reflowChild = true;
+    }
+    // If we need to pull up content from the prev-in-flow then this is not just
+    // a block-size shrink. The prev in flow will have set the dirty bit.
+    // Check the overflow rect YMost instead of just the child's content
+    // block-size. The child may have overflowing content that cares about the
+    // available block-size boundary. (It may also have overflowing content that
+    // doesn't care about the available block-size boundary, but if so, too bad,
+    // this optimization is defeated.) We want scrollable overflow here since
+    // this is a calculation that affects layout.
+    if (!reflowChild && shrinkingBSize) {
+      switch (wm.GetBlockDir()) {
+        case WritingMode::eBlockTB:
+          if (child->ScrollableOverflowRect().YMost() > aConfig.mColBSize) {
+            reflowChild = true;
+          }
+          break;
+        case WritingMode::eBlockLR:
+          if (child->ScrollableOverflowRect().XMost() > aConfig.mColBSize) {
+            reflowChild = true;
+          }
+          break;
+        case WritingMode::eBlockRL:
+          // XXX not sure how to handle this, so for now just don't attempt
+          // the optimization
+          reflowChild = true;
+          break;
+        default:
+          MOZ_ASSERT_UNREACHABLE("unknown block direction");
+          break;
+      }
+    }
+
+    nscoord childContentBEnd = 0;
+    if (!reflowNext && !reflowChild) {
+      // This child does not need to be reflowed, but we may need to move it
+      MoveChildTo(child, childOrigin, wm, containerSize);
+
+      // If this is the last frame then make sure we get the right status
+      nsIFrame* kidNext = child->GetNextSibling();
+      if (kidNext) {
+        aStatus.Reset();
+        if (kidNext->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) {
+          aStatus.SetOverflowIncomplete();
+        } else {
+          aStatus.SetIncomplete();
+        }
+      } else {
+        aStatus = mLastFrameStatus;
+      }
+      childContentBEnd = nsLayoutUtils::CalculateContentBEnd(wm, child);
+
+      COLUMN_SET_LOG("%s: Skipping child #%d %p: status=%s", __func__,
+                     colData.mColCount, child, ToString(aStatus).c_str());
+    } else {
+      LogicalSize availSize(wm, aConfig.mColISize, aConfig.mColBSize);
+      if (reflowLastColumnWithUnconstrainedAvailBSize) {
+        availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
+
+        COLUMN_SET_LOG(
+            "%s: Reflowing last column with unconstrained block-size. Change "
+            "available block-size from %d to %d",
+            __func__, aConfig.mColBSize, availSize.BSize(wm));
+      }
+
+      if (reflowNext) {
+        child->MarkSubtreeDirty();
+      }
+
+      LogicalSize kidCBSize(wm, availSize.ISize(wm), computedBSize);
+      ReflowInput kidReflowInput(PresContext(), aReflowInput, child, availSize,
+                                 Some(kidCBSize));
+      kidReflowInput.mFlags.mIsTopOfPage = [&]() {
+        const bool isNestedMulticolOrPaginated =
+            aReflowInput.mParentReflowInput->mFrame->HasAnyStateBits(
+                NS_FRAME_HAS_MULTI_COLUMN_ANCESTOR) ||
+            PresContext()->IsPaginated();
+        if (isNestedMulticolOrPaginated) {
+          if (aConfig.mForceAuto) {
+            // If we are forced to fill columns sequentially, force fit the
+            // content whether we are at top of page or not.
+            return true;
+          }
+          if (aReflowInput.mFlags.mIsTopOfPage) {
+            // If this is the last balancing reflow, we want to force fit
+            // content to avoid infinite loops.
+            return !aConfig.mIsBalancing || aConfig.mIsLastBalancingReflow;
+          }
+          // If we are a not at the top of page, we shouldn't force fit content.
+          // This is because our ColumnSetWrapperFrame can be pushed to the next
+          // column or page and reflowed again with a potentially larger
+          // available block-size.
+          return false;
+        }
+        // We are a top-level multicol in non-paginated context. Force fit the
+        // content only if we are not balancing columns.
+        return !aConfig.mIsBalancing;
+      }();
+      kidReflowInput.mFlags.mTableIsSplittable = false;
+      kidReflowInput.mFlags.mIsColumnBalancing = aConfig.mIsBalancing;
+      kidReflowInput.mFlags.mIsInLastColumnBalancingReflow =
+          aConfig.mIsLastBalancingReflow;
+      kidReflowInput.mBreakType = ReflowInput::BreakType::Column;
+
+      // We need to reflow any float placeholders, even if our column block-size
+      // hasn't changed.
+      kidReflowInput.mFlags.mMustReflowPlaceholders = !changingBSize;
+
+      COLUMN_SET_LOG(
+          "%s: Reflowing child #%d %p: availSize=(%d,%d), kidCBSize=(%d,%d), "
+          "child's mIsTopOfPage=%d",
+          __func__, colData.mColCount, child, availSize.ISize(wm),
+          availSize.BSize(wm), kidCBSize.ISize(wm), kidCBSize.BSize(wm),
+          kidReflowInput.mFlags.mIsTopOfPage);
+
+      // Note if the column's next in flow is not being changed by this
+      // incremental reflow. This may allow the current column to avoid trying
+      // to pull lines from the next column.
+      if (child->GetNextSibling() && !HasAnyStateBits(NS_FRAME_IS_DIRTY) &&
+          !child->GetNextSibling()->HasAnyStateBits(NS_FRAME_IS_DIRTY)) {
+        kidReflowInput.mFlags.mNextInFlowUntouched = true;
+      }
+
+      ReflowOutput kidDesiredSize(wm);
+
+      // XXX it would be cool to consult the float manager for the
+      // previous block to figure out the region of floats from the
+      // previous column that extend into this column, and subtract
+      // that region from the new float manager.  So you could stick a
+      // really big float in the first column and text in following
+      // columns would flow around it.
+
+      MOZ_ASSERT(kidReflowInput.ComputedLogicalMargin(wm).IsAllZero(),
+                 "-moz-column-content has no margin!");
+      aStatus.Reset();
+      ReflowChild(child, PresContext(), kidDesiredSize, kidReflowInput, wm,
+                  childOrigin, containerSize, ReflowChildFlags::Default,
+                  aStatus);
+
+      if (colData.mColCount == 1 && aStatus.IsInlineBreakBefore()) {
+        COLUMN_SET_LOG("%s: Content in the first column reports break-before!",
+                       __func__);
+        allFit = false;
+        break;
+      }
+
+      reflowNext = aStatus.NextInFlowNeedsReflow();
+
+      // The carried-out block-end margin of column content might be non-zero
+      // when we try to find the best column balancing block size, but it should
+      // never affect the size column set nor be further carried out. Set it to
+      // zero.
+      //
+      // FIXME: For some types of fragmentation, we should carry the margin into
+      // the next column. Also see
+      // https://drafts.csswg.org/css-break-4/#break-margins
+      //
+      // FIXME: This should never happen for the last column, since it should be
+      // a margin root; see nsBlockFrame::IsMarginRoot(). However, sometimes the
+      // last column has an empty continuation while searching for the best
+      // column balancing bsize, which prevents the last column from being a
+      // margin root.
+      kidDesiredSize.mCarriedOutBEndMargin.Zero();
+
+      NS_FRAME_TRACE_REFLOW_OUT("Column::Reflow", aStatus);
+
+      FinishReflowChild(child, PresContext(), kidDesiredSize, &kidReflowInput,
+                        wm, childOrigin, containerSize,
+                        ReflowChildFlags::Default);
+
+      childContentBEnd = nsLayoutUtils::CalculateContentBEnd(wm, child);
+      if (childContentBEnd > aConfig.mColBSize) {
+        allFit = false;
+      }
+      if (childContentBEnd > availSize.BSize(wm)) {
+        colData.mMaxOverflowingBSize =
+            std::max(childContentBEnd, colData.mMaxOverflowingBSize);
+      }
+
+      COLUMN_SET_LOG(
+          "%s: Reflowed child #%d %p: status=%s, desiredSize=(%d,%d), "
+          "childContentBEnd=%d, CarriedOutBEndMargin=%d (ignored)",
+          __func__, colData.mColCount, child, ToString(aStatus).c_str(),
+          kidDesiredSize.ISize(wm), kidDesiredSize.BSize(wm), childContentBEnd,
+          kidDesiredSize.mCarriedOutBEndMargin.get());
+    }
+
+    contentRect.UnionRect(contentRect, child->GetRect());
+
+    ConsiderChildOverflow(overflowRects, child);
+    contentBEnd = std::max(contentBEnd, childContentBEnd);
+    colData.mLastBSize = childContentBEnd;
+    colData.mSumBSize += childContentBEnd;
+
+    // Build a continuation column if necessary
+    nsIFrame* kidNextInFlow = child->GetNextInFlow();
+
+    if (aStatus.IsFullyComplete()) {
+      NS_ASSERTION(!kidNextInFlow, "next in flow should have been deleted");
+      child = nullptr;
+      break;
+    }
+
+    // Make sure that the column has a next-in-flow. If not, we must
+    // create one to hold the overflowing stuff, even if we're just
+    // going to put it on our overflow list and let *our*
+    // next in flow handle it.
+    if (!kidNextInFlow) {
+      NS_ASSERTION(aStatus.NextInFlowNeedsReflow(),
+                   "We have to create a continuation, but the block doesn't "
+                   "want us to reflow it?");
+
+      // We need to create a continuing column
+      kidNextInFlow = CreateNextInFlow(child);
+    }
+
+    // Make sure we reflow a next-in-flow when it switches between being
+    // normal or overflow container
+    if (aStatus.IsOverflowIncomplete()) {
+      if (!kidNextInFlow->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) {
+        aStatus.SetNextInFlowNeedsReflow();
+        reflowNext = true;
+        kidNextInFlow->AddStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER);
+      }
+    } else if (kidNextInFlow->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) {
+      aStatus.SetNextInFlowNeedsReflow();
+      reflowNext = true;
+      kidNextInFlow->RemoveStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER);
+    }
+
+    // We have reached the maximum number of columns. If we are balancing, stop
+    // this reflow and continue finding the optimal balancing block-size.
+    //
+    // Otherwise, i.e. we are not balancing, stop this reflow and let the parent
+    // of our multicol container create a next-in-flow if all of the following
+    // conditions are met.
+    //
+    // 1) We fill columns sequentially by the request of the style, not by our
+    // internal needs, i.e. aConfig.mForceAuto is false.
+    //
+    // We don't want to stop this reflow when we force fill the columns
+    // sequentially. We usually go into this mode when giving up balancing, and
+    // this is the last resort to fit all our children by creating overflow
+    // columns.
+    //
+    // 2) In a fragmented context, our multicol container still has block-size
+    // left for its next-in-flow, i.e.
+    // aReflowInput.mFlags.mColumnSetWrapperHasNoBSizeLeft is false.
+    //
+    // Note that in a continuous context, i.e. our multicol container's
+    // available block-size is unconstrained, if it has a fixed block-size
+    // mColumnSetWrapperHasNoBSizeLeft is always true because nothing stops it
+    // from applying all its block-size in the first-in-flow. Otherwise, i.e.
+    // our multicol container has an unconstrained block-size, we shouldn't be
+    // here because all our children should fit in the very first column even if
+    // mColumnSetWrapperHasNoBSizeLeft is false.
+    //
+    // According to the definition of mColumnSetWrapperHasNoBSizeLeft, if the
+    // bit is *not* set, either our multicol container has unconstrained
+    // block-size, or it has a constrained block-size and has block-size left
+    // for its next-in-flow. In either cases, the parent of our multicol
+    // container can create a next-in-flow for the container that guaranteed to
+    // have non-zero block-size for the container's children.
+    //
+    // Put simply, if either one of the above conditions is not met, we are
+    // going to create more overflow columns until all our children are fit.
+    if (colData.mColCount >= aConfig.mUsedColCount &&
+        (aConfig.mIsBalancing ||
+         (!aConfig.mForceAuto &&
+          !aReflowInput.mFlags.mColumnSetWrapperHasNoBSizeLeft))) {
+      NS_ASSERTION(aConfig.mIsBalancing ||
+                       aReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE,
+                   "Why are we here if we have unlimited block-size to fill "
+                   "columns sequentially.");
+
+      // No more columns allowed here. Stop.
+      aStatus.SetNextInFlowNeedsReflow();
+      kidNextInFlow->MarkSubtreeDirty();
+      // Move any of our leftover columns to our overflow list. Our
+      // next-in-flow will eventually pick them up.
+      nsFrameList continuationColumns = mFrames.TakeFramesAfter(child);
+      if (continuationColumns.NotEmpty()) {
+        SetOverflowFrames(std::move(continuationColumns));
+      }
+      child = nullptr;
+
+      COLUMN_SET_LOG("%s: We are not going to create overflow columns.",
+                     __func__);
+      break;
+    }
+
+    if (PresContext()->HasPendingInterrupt()) {
+      // Stop the loop now while |child| still points to the frame that bailed
+      // out.  We could keep going here and condition a bunch of the code in
+      // this loop on whether there's an interrupt, or even just keep going and
+      // trying to reflow the blocks (even though we know they'll interrupt
+      // right after their first line), but stopping now is conceptually the
+      // simplest (and probably fastest) thing.
+      break;
+    }
+
+    // Advance to the next column
+    child = child->GetNextSibling();
+    ++colData.mColCount;
+
+    if (child) {
+      childOrigin.I(wm) += aConfig.mColISize + aConfig.mColGap;
+
+      COLUMN_SET_LOG("%s: Next childOrigin.iCoord=%d", __func__,
+                     childOrigin.I(wm));
+    }
+  }
+
+  if (PresContext()->CheckForInterrupt(this) &&
+      HasAnyStateBits(NS_FRAME_IS_DIRTY)) {
+    // Mark all our kids starting with |child| dirty
+
+    // Note that this is a CheckForInterrupt call, not a HasPendingInterrupt,
+    // because we might have interrupted while reflowing |child|, and since
+    // we're about to add a dirty bit to |child| we need to make sure that
+    // |this| is scheduled to have dirty bits marked on it and its ancestors.
+    // Otherwise, when we go to mark dirty bits on |child|'s ancestors we'll
+    // bail out immediately, since it'll already have a dirty bit.
+    for (; child; child = child->GetNextSibling()) {
+      child->MarkSubtreeDirty();
+    }
+  }
+
+  colData.mMaxBSize = contentBEnd;
+  LogicalSize contentSize = LogicalSize(wm, contentRect.Size());
+  contentSize.BSize(wm) = std::max(contentSize.BSize(wm), contentBEnd);
+  mLastFrameStatus = aStatus;
+
+  if (computedBSize != NS_UNCONSTRAINEDSIZE && !HasColumnSpanSiblings()) {
+    NS_ASSERTION(aReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE,
+                 "Available block-size should be constrained because it's "
+                 "restricted by the computed block-size when our reflow "
+                 "input is created in nsBlockFrame::ReflowBlockFrame()!");
+
+    // If a) our parent ColumnSetWrapper has constrained block-size
+    // (nsBlockFrame::ReflowBlockFrame() applies the block-size constraint
+    // when creating a ReflowInput for ColumnSetFrame child); and b) we are the
+    // sole ColumnSet or the last ColumnSet continuation split by column-spans
+    // in a ColumnSetWrapper, extend our block-size to consume the available
+    // block-size so that the column-rules are drawn to the content block-end
+    // edge of the multicol container.
+    contentSize.BSize(wm) =
+        std::max(contentSize.BSize(wm), aReflowInput.AvailableBSize());
+  }
+
+  aDesiredSize.SetSize(wm, contentSize);
+  aDesiredSize.mOverflowAreas = overflowRects;
+  aDesiredSize.UnionOverflowAreasWithDesiredBounds();
+
+  // In vertical-rl mode, make a second pass if necessary to reposition the
+  // columns with the correct container width. (In other writing modes,
+  // correct containerSize was not required for column positioning so we don't
+  // need this fixup.)
+  //
+  // RTL column positions also depend on ColumnSet's actual contentSize. We need
+  // this fixup, too.
+  if ((wm.IsVerticalRL() || isRTL) &&
+      containerSize.width != contentSize.Width(wm)) {
+    const nsSize finalContainerSize = aDesiredSize.PhysicalSize();
+    OverflowAreas overflowRects;
+    for (nsIFrame* child : mFrames) {
+      // Get the logical position as set previously using a provisional or
+      // dummy containerSize, and reset with the correct container size.
+      child->SetPosition(wm, child->GetLogicalPosition(wm, containerSize),
+                         finalContainerSize);
+      ConsiderChildOverflow(overflowRects, child);
+    }
+    aDesiredSize.mOverflowAreas = overflowRects;
+    aDesiredSize.UnionOverflowAreasWithDesiredBounds();
+  }
+
+  colData.mFeasible = allFit && aStatus.IsFullyComplete();
+
+  COLUMN_SET_LOG(
+      "%s: Done column reflow pass: %s, mMaxBSize=%d, mSumBSize=%d, "
+      "mLastBSize=%d, mMaxOverflowingBSize=%d",
+      __func__, colData.mFeasible ? "Feasible :)" : "Infeasible :(",
+      colData.mMaxBSize, colData.mSumBSize, colData.mLastBSize,
+      colData.mMaxOverflowingBSize);
+
+  return colData;
+}
+
+void nsColumnSetFrame::DrainOverflowColumns() {
+  // First grab the prev-in-flows overflows and reparent them to this
+  // frame.
+  nsPresContext* presContext = PresContext();
+  nsColumnSetFrame* prev = static_cast<nsColumnSetFrame*>(GetPrevInFlow());
+  if (prev) {
+    AutoFrameListPtr overflows(presContext, prev->StealOverflowFrames());
+    if (overflows) {
+      nsContainerFrame::ReparentFrameViewList(*overflows, prev, this);
+
+      mFrames.InsertFrames(this, nullptr, std::move(*overflows));
+    }
+  }
+
+  // Now pull back our own overflows and append them to our children.
+  // We don't need to reparent them since we're already their parent.
+  AutoFrameListPtr overflows(presContext, StealOverflowFrames());
+  if (overflows) {
+    // We're already the parent for these frames, so no need to set
+    // their parent again.
+    mFrames.AppendFrames(nullptr, std::move(*overflows));
+  }
+}
+
+void nsColumnSetFrame::FindBestBalanceBSize(const ReflowInput& aReflowInput,
+                                            nsPresContext* aPresContext,
+                                            ReflowConfig& aConfig,
+                                            ColumnBalanceData aColData,
+                                            ReflowOutput& aDesiredSize,
+                                            bool aUnboundedLastColumn,
+                                            nsReflowStatus& aStatus) {
+  MOZ_ASSERT(aConfig.mIsBalancing,
+             "Why are we here if we are not balancing columns?");
+
+  const nscoord availableContentBSize = aReflowInput.AvailableBSize();
+
+  // Termination of the algorithm below is guaranteed because
+  // aConfig.knownFeasibleBSize - aConfig.knownInfeasibleBSize decreases in
+  // every iteration.
+  int32_t iterationCount = 1;
+
+  // We set this flag when we detect that we may contain a frame
+  // that can break anywhere (thus foiling the linear decrease-by-one
+  // search)
+  bool maybeContinuousBreakingDetected = false;
+  bool possibleOptimalBSizeDetected = false;
+
+  // This is the extra block-size added to the optimal column block-size
+  // estimation which is calculated in the while-loop by dividing
+  // aColData.mSumBSize into N columns.
+  //
+  // The constant is arbitrary. We use a half of line-height first. In case a
+  // column container uses *zero* (or a very small) line-height, use a half of
+  // default line-height 1140/2 = 570 app units as the minimum value. Otherwise
+  // we might take more than necessary iterations before finding a feasible
+  // block-size.
+  nscoord extraBlockSize = std::max(570, aReflowInput.GetLineHeight() / 2);
+
+  // We use divide-by-N to estimate the optimal column block-size only if the
+  // last column's available block-size is unbounded.
+  bool foundFeasibleBSizeCloserToBest = !aUnboundedLastColumn;
+
+  // Stop the binary search when the difference of the feasible and infeasible
+  // block-size is within this gap. Here we use one device pixel.
+  const int32_t gapToStop = aPresContext->DevPixelsToAppUnits(1);
+
+  while (!aPresContext->HasPendingInterrupt()) {
+    nscoord lastKnownFeasibleBSize = aConfig.mKnownFeasibleBSize;
+
+    // Record what we learned from the last reflow
+    if (aColData.mFeasible) {
+      // mMaxBSize is feasible. Also, mLastBalanceBSize is feasible.
+      aConfig.mKnownFeasibleBSize =
+          std::min(aConfig.mKnownFeasibleBSize, aColData.mMaxBSize);
+      aConfig.mKnownFeasibleBSize =
+          std::min(aConfig.mKnownFeasibleBSize, mLastBalanceBSize);
+
+      // Furthermore, no block-size less than the block-size of the last
+      // column can ever be feasible. (We might be able to reduce the
+      // block-size of a non-last column by moving content to a later column,
+      // but we can't do that with the last column.)
+      if (aColData.mColCount == aConfig.mUsedColCount) {
+        aConfig.mKnownInfeasibleBSize =
+            std::max(aConfig.mKnownInfeasibleBSize, aColData.mLastBSize - 1);
+      }
+    } else {
+      aConfig.mKnownInfeasibleBSize =
+          std::max(aConfig.mKnownInfeasibleBSize, mLastBalanceBSize);
+
+      // If a column didn't fit in its available block-size, then its current
+      // block-size must be the minimum block-size for unbreakable content in
+      // the column, and therefore no smaller block-size can be feasible.
+      aConfig.mKnownInfeasibleBSize = std::max(
+          aConfig.mKnownInfeasibleBSize, aColData.mMaxOverflowingBSize - 1);
+
+      if (aUnboundedLastColumn) {
+        // The last column is unbounded, so all content got reflowed, so the
+        // mMaxBSize is feasible.
+        aConfig.mKnownFeasibleBSize =
+            std::min(aConfig.mKnownFeasibleBSize, aColData.mMaxBSize);
+
+        NS_ASSERTION(mLastFrameStatus.IsComplete(),
+                     "Last column should be complete if the available "
+                     "block-size is unconstrained!");
+      }
+    }
+
+    COLUMN_SET_LOG(
+        "%s: this=%p, mKnownInfeasibleBSize=%d, mKnownFeasibleBSize=%d",
+        __func__, this, aConfig.mKnownInfeasibleBSize,
+        aConfig.mKnownFeasibleBSize);
+
+    if (aConfig.mKnownInfeasibleBSize >= aConfig.mKnownFeasibleBSize - 1) {
+      // aConfig.mKnownFeasibleBSize is where we want to be. This can happen in
+      // the very first iteration when a column container solely has a tall
+      // unbreakable child that overflows the container.
+      break;
+    }
+
+    if (aConfig.mKnownInfeasibleBSize >= availableContentBSize) {
+      // There's no feasible block-size to fit our contents. We may need to
+      // reflow one more time after this loop.
+      break;
+    }
+
+    const nscoord gap =
+        aConfig.mKnownFeasibleBSize - aConfig.mKnownInfeasibleBSize;
+    if (gap <= gapToStop && possibleOptimalBSizeDetected) {
+      // We detected a possible optimal block-size in the last iteration. If it
+      // is infeasible, we may need to reflow one more time after this loop.
+      break;
+    }
+
+    if (lastKnownFeasibleBSize - aConfig.mKnownFeasibleBSize == 1) {
+      // We decreased the feasible block-size by one twip only. This could
+      // indicate that there is a continuously breakable child frame
+      // that we are crawling through.
+      maybeContinuousBreakingDetected = true;
+    }
+
+    nscoord nextGuess = aConfig.mKnownInfeasibleBSize + gap / 2;
+    if (aConfig.mKnownFeasibleBSize - nextGuess < extraBlockSize &&
+        !maybeContinuousBreakingDetected) {
+      // We're close to our target, so just try shrinking just the
+      // minimum amount that will cause one of our columns to break
+      // differently.
+      nextGuess = aConfig.mKnownFeasibleBSize - 1;
+    } else if (!foundFeasibleBSizeCloserToBest) {
+      // Make a guess by dividing mSumBSize into N columns and adding
+      // extraBlockSize to try to make it on the feasible side.
+      nextGuess = aColData.mSumBSize / aConfig.mUsedColCount + extraBlockSize;
+      // Sanitize it
+      nextGuess = clamped(nextGuess, aConfig.mKnownInfeasibleBSize + 1,
+                          aConfig.mKnownFeasibleBSize - 1);
+      // We keep doubling extraBlockSize in every iteration until we find a
+      // feasible guess.
+      extraBlockSize *= 2;
+    } else if (aConfig.mKnownFeasibleBSize == NS_UNCONSTRAINEDSIZE) {
+      // This can happen when we had a next-in-flow so we didn't
+      // want to do an unbounded block-size measuring step. Let's just increase
+      // from the infeasible block-size by some reasonable amount.
+      nextGuess = aConfig.mKnownInfeasibleBSize * 2 + extraBlockSize;
+    } else if (gap <= gapToStop) {
+      // Floor nextGuess to the greatest multiple of gapToStop below or equal to
+      // mKnownFeasibleBSize.
+      nextGuess = aConfig.mKnownFeasibleBSize / gapToStop * gapToStop;
+      possibleOptimalBSizeDetected = true;
+    }
+
+    // Don't bother guessing more than our block-size constraint.
+    nextGuess = std::min(availableContentBSize, nextGuess);
+
+    COLUMN_SET_LOG("%s: Choosing next guess=%d, iteration=%d", __func__,
+                   nextGuess, iterationCount);
+    ++iterationCount;
+
+    aConfig.mColBSize = nextGuess;
+
+    aUnboundedLastColumn = false;
+    MarkPrincipalChildrenDirty(this);
+    aColData =
+        ReflowColumns(aDesiredSize, aReflowInput, aStatus, aConfig, false);
+
+    if (!foundFeasibleBSizeCloserToBest && aColData.mFeasible) {
+      foundFeasibleBSizeCloserToBest = true;
+    }
+  }
+
+  if (!aColData.mFeasible && !aPresContext->HasPendingInterrupt()) {
+    // We need to reflow one more time at the feasible block-size to
+    // get a valid layout.
+    if (aConfig.mKnownInfeasibleBSize >= availableContentBSize) {
+      aConfig.mColBSize = availableContentBSize;
+      if (mLastBalanceBSize == availableContentBSize) {
+        // If we end up here, we have a constrained available content
+        // block-size, and our last column's block-size exceeds it. Also, if
+        // this is the first balancing iteration, the last column is given
+        // unconstrained available block-size, so it has a fully complete
+        // reflow status. Therefore, we always want to reflow again at the
+        // available content block-size to get a valid layout and a correct
+        // reflow status (likely an *incomplete* status) so that our column
+        // container can be fragmented if needed.
+
+        if (aReflowInput.mFlags.mColumnSetWrapperHasNoBSizeLeft) {
+          // If our column container has a constrained block-size (either in a
+          // paginated context or in a nested column container), and is going
+          // to consume all its computed block-size in this fragment, then our
+          // column container has no block-size left to contain our
+          // next-in-flows. We have to give up balancing, and create our
+          // own overflow columns.
+          //
+          // We don't want to create overflow columns immediately when our
+          // content doesn't fit since this changes our reflow status from
+          // incomplete to complete. Valid reasons include 1) the outer column
+          // container might do column balancing, and it can enlarge the
+          // available content block-size so that the nested one could fit its
+          // content in next balancing iteration; or 2) the outer column
+          // container is filling columns sequentially, and may have more
+          // inline-size to create more column boxes for the nested column
+          // container's next-in-flows.
+          aConfig = ChooseColumnStrategy(aReflowInput, true);
+        }
+      }
+    } else {
+      aConfig.mColBSize = aConfig.mKnownFeasibleBSize;
+    }
+
+    // This is our last attempt to reflow. If our column container's available
+    // block-size is unconstrained, make sure that the last column is
+    // allowed to have arbitrary block-size here, even though we were
+    // balancing. Otherwise we'd have to split, and it's not clear what we'd
+    // do with that.
+    COLUMN_SET_LOG("%s: Last attempt to call ReflowColumns", __func__);
+    aConfig.mIsLastBalancingReflow = true;
+    const bool forceUnboundedLastColumn =
+        aReflowInput.mParentReflowInput->AvailableBSize() ==
+        NS_UNCONSTRAINEDSIZE;
+    MarkPrincipalChildrenDirty(this);
+    ReflowColumns(aDesiredSize, aReflowInput, aStatus, aConfig,
+                  forceUnboundedLastColumn);
+  }
+}
+
+void nsColumnSetFrame::Reflow(nsPresContext* aPresContext,
+                              ReflowOutput& aDesiredSize,
+                              const ReflowInput& aReflowInput,
+                              nsReflowStatus& aStatus) {
+  MarkInReflow();
+  // Don't support interruption in columns
+  nsPresContext::InterruptPreventer noInterrupts(aPresContext);
+
+  DO_GLOBAL_REFLOW_COUNT("nsColumnSetFrame");
+  DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
+  MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
+
+  MOZ_ASSERT(aReflowInput.mCBReflowInput->mFrame->StyleColumn()
+                 ->IsColumnContainerStyle(),
+             "The column container should have relevant column styles!");
+  MOZ_ASSERT(aReflowInput.mParentReflowInput->mFrame->IsColumnSetWrapperFrame(),
+             "The column container should be ColumnSetWrapperFrame!");
+  MOZ_ASSERT(
+      aReflowInput.ComputedLogicalBorderPadding(aReflowInput.GetWritingMode())
+          .IsAllZero(),
+      "Only the column container can have border and padding!");
+  MOZ_ASSERT(
+      GetChildList(FrameChildListID::OverflowContainers).IsEmpty() &&
+          GetChildList(FrameChildListID::ExcessOverflowContainers).IsEmpty(),
+      "ColumnSetFrame should store overflow containers in principal "
+      "child list!");
+
+  //------------ Handle Incremental Reflow -----------------
+
+  COLUMN_SET_LOG("%s: Begin Reflow: this=%p, is nested multicol=%d", __func__,
+                 this,
+                 aReflowInput.mParentReflowInput->mFrame->HasAnyStateBits(
+                     NS_FRAME_HAS_MULTI_COLUMN_ANCESTOR));
+
+  // If inline size is unconstrained, set aForceAuto to true to allow
+  // the columns to expand in the inline direction. (This typically
+  // happens in orthogonal flows where the inline direction is the
+  // container's block direction).
+  ReflowConfig config = ChooseColumnStrategy(
+      aReflowInput, aReflowInput.ComputedISize() == NS_UNCONSTRAINEDSIZE);
+
+  // If balancing, then we allow the last column to grow to unbounded
+  // block-size during the first reflow. This gives us a way to estimate
+  // what the average column block-size should be, because we can measure
+  // the block-size of all the columns and sum them up. But don't do this
+  // if we have a next in flow because we don't want to suck all its
+  // content back here and then have to push it out again!
+  nsIFrame* nextInFlow = GetNextInFlow();
+  bool unboundedLastColumn = config.mIsBalancing && !nextInFlow;
+  const ColumnBalanceData colData = ReflowColumns(
+      aDesiredSize, aReflowInput, aStatus, config, unboundedLastColumn);
+
+  // If we're not balancing, then we're already done, since we should have
+  // reflown all of our children, and there is no need for a binary search to
+  // determine proper column block-size.
+  if (config.mIsBalancing && !aPresContext->HasPendingInterrupt()) {
+    FindBestBalanceBSize(aReflowInput, aPresContext, config, colData,
+                         aDesiredSize, unboundedLastColumn, aStatus);
+  }
+
+  if (aPresContext->HasPendingInterrupt() &&
+      aReflowInput.AvailableBSize() == NS_UNCONSTRAINEDSIZE) {
+    // In this situation, we might be lying about our reflow status, because
+    // our last kid (the one that got interrupted) was incomplete.  Fix that.
+    aStatus.Reset();
+  }
+
+  NS_ASSERTION(aStatus.IsFullyComplete() ||
+                   aReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE,
+               "Column set should be complete if the available block-size is "
+               "unconstrained");
+
+  MOZ_ASSERT(!HasAbsolutelyPositionedChildren(),
+             "ColumnSetWrapperFrame should be the abs.pos container!");
+  FinishAndStoreOverflow(&aDesiredSize, aReflowInput.mStyleDisplay);
+
+  COLUMN_SET_LOG("%s: End Reflow: this=%p", __func__, this);
+}
+
+void nsColumnSetFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
+                                        const nsDisplayListSet& aLists) {
+  DisplayBorderBackgroundOutline(aBuilder, aLists);
+
+  if (IsVisibleForPainting()) {
+    aLists.BorderBackground()->AppendNewToTop<nsDisplayColumnRule>(aBuilder,
+                                                                   this);
+  }
+
+  // Our children won't have backgrounds so it doesn't matter where we put them.
+  for (nsIFrame* f : mFrames) {
+    BuildDisplayListForChild(aBuilder, f, aLists);
+  }
+}
+
+void nsColumnSetFrame::AppendDirectlyOwnedAnonBoxes(
+    nsTArray<OwnedAnonBox>& aResult) {
+  // Everything in mFrames is continuations of the first thing in mFrames.
+  nsIFrame* column = mFrames.FirstChild();
+
+  // We might not have any columns, apparently?
+  if (!column) {
+    return;
+  }
+
+  MOZ_ASSERT(column->Style()->GetPseudoType() == PseudoStyleType::columnContent,
+             "What sort of child is this?");
+  aResult.AppendElement(OwnedAnonBox(column));
+}
+
+Maybe<nscoord> nsColumnSetFrame::GetNaturalBaselineBOffset(
+    WritingMode aWM, BaselineSharingGroup aBaselineGroup,
+    BaselineExportContext aExportContext) const {
+  Maybe<nscoord> result;
+  for (const auto* kid : mFrames) {
+    auto kidBaseline =
+        kid->GetNaturalBaselineBOffset(aWM, aBaselineGroup, aExportContext);
+    if (!kidBaseline) {
+      continue;
+    }
+    // The kid frame may not necessarily be aligned with the columnset frame.
+    LogicalRect kidRect{aWM, kid->GetLogicalNormalPosition(aWM, GetSize()),
+                        kid->GetLogicalSize(aWM)};
+    if (aBaselineGroup == BaselineSharingGroup::First) {
+      *kidBaseline += kidRect.BStart(aWM);
+    } else {
+      *kidBaseline += (GetLogicalSize().BSize(aWM) - kidRect.BEnd(aWM));
+    }
+    // Take the smallest of the baselines (i.e. Closest to border-block-start
+    // for `BaselineSharingGroup::First`, border-block-end for
+    // `BaselineSharingGroup::Last`)
+    if (!result || *kidBaseline < *result) {
+      result = kidBaseline;
+    }
+  }
+  return result;
+}
+
+#ifdef DEBUG
+void nsColumnSetFrame::SetInitialChildList(ChildListID aListID,
+                                           nsFrameList&& aChildList) {
+  MOZ_ASSERT(aListID != FrameChildListID::Principal || aChildList.OnlyChild(),
+             "initial principal child list must have exactly one child");
+  nsContainerFrame::SetInitialChildList(aListID, std::move(aChildList));
+}
+
+void nsColumnSetFrame::AppendFrames(ChildListID aListID,
+                                    nsFrameList&& aFrameList) {
+  MOZ_CRASH("unsupported operation");
+}
+
+void nsColumnSetFrame::InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame,
+                                    const nsLineList::iterator* aPrevFrameLine,
+                                    nsFrameList&& aFrameList) {
+  MOZ_CRASH("unsupported operation");
+}
+
+void nsColumnSetFrame::RemoveFrame(DestroyContext&, ChildListID, nsIFrame*) {
+  MOZ_CRASH("unsupported operation");
+}
+#endif