/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */
#include "nsTableRowGroupFrame.h"

#include "mozilla/ComputedStyle.h"
#include "mozilla/PresShell.h"
#include "mozilla/StaticPrefs_layout.h"

#include "nsCOMPtr.h"
#include "nsTableRowFrame.h"
#include "nsTableFrame.h"
#include "nsTableCellFrame.h"
#include "nsPresContext.h"
#include "nsStyleConsts.h"
#include "nsIContent.h"
#include "nsIFrame.h"
#include "nsIFrameInlines.h"
#include "nsGkAtoms.h"
#include "nsCSSRendering.h"
#include "nsHTMLParts.h"
#include "nsCSSFrameConstructor.h"
#include "nsDisplayList.h"

#include "nsCellMap.h"  //table cell navigation
#include <algorithm>

using namespace mozilla;
using namespace mozilla::layout;

namespace mozilla {

struct TableRowGroupReflowInput final {
  // Our reflow input
  const ReflowInput& mReflowInput;

  // The available size (computed from the parent)
  LogicalSize mAvailSize;

  // Running block-offset
  nscoord mBCoord = 0;

  explicit TableRowGroupReflowInput(const ReflowInput& aReflowInput)
      : mReflowInput(aReflowInput), mAvailSize(aReflowInput.AvailableSize()) {}

  ~TableRowGroupReflowInput() = default;
};

}  // namespace mozilla

nsTableRowGroupFrame::nsTableRowGroupFrame(ComputedStyle* aStyle,
                                           nsPresContext* aPresContext)
    : nsContainerFrame(aStyle, aPresContext, kClassID) {
  SetRepeatable(false);
}

nsTableRowGroupFrame::~nsTableRowGroupFrame() = default;

void nsTableRowGroupFrame::Destroy(DestroyContext& aContext) {
  nsTableFrame::MaybeUnregisterPositionedTablePart(this);
  nsContainerFrame::Destroy(aContext);
}

NS_QUERYFRAME_HEAD(nsTableRowGroupFrame)
  NS_QUERYFRAME_ENTRY(nsTableRowGroupFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)

int32_t nsTableRowGroupFrame::GetRowCount() const {
#ifdef DEBUG
  for (nsIFrame* f : mFrames) {
    NS_ASSERTION(f->StyleDisplay()->mDisplay == mozilla::StyleDisplay::TableRow,
                 "Unexpected display");
    NS_ASSERTION(f->IsTableRowFrame(), "Unexpected frame type");
  }
#endif

  return mFrames.GetLength();
}

int32_t nsTableRowGroupFrame::GetStartRowIndex() const {
  int32_t result = -1;
  if (mFrames.NotEmpty()) {
    NS_ASSERTION(mFrames.FirstChild()->IsTableRowFrame(),
                 "Unexpected frame type");
    result = static_cast<nsTableRowFrame*>(mFrames.FirstChild())->GetRowIndex();
  }
  // if the row group doesn't have any children, get it the hard way
  if (-1 == result) {
    return GetTableFrame()->GetStartRowIndex(this);
  }

  return result;
}

void nsTableRowGroupFrame::AdjustRowIndices(int32_t aRowIndex,
                                            int32_t anAdjustment) {
  for (nsIFrame* rowFrame : mFrames) {
    if (mozilla::StyleDisplay::TableRow == rowFrame->StyleDisplay()->mDisplay) {
      int32_t index = ((nsTableRowFrame*)rowFrame)->GetRowIndex();
      if (index >= aRowIndex) {
        ((nsTableRowFrame*)rowFrame)->SetRowIndex(index + anAdjustment);
      }
    }
  }
}

int32_t nsTableRowGroupFrame::GetAdjustmentForStoredIndex(
    int32_t aStoredIndex) {
  nsTableFrame* tableFrame = GetTableFrame();
  return tableFrame->GetAdjustmentForStoredIndex(aStoredIndex);
}

void nsTableRowGroupFrame::MarkRowsAsDeleted(nsTableRowFrame& aStartRowFrame,
                                             int32_t aNumRowsToDelete) {
  nsTableRowFrame* currentRowFrame = &aStartRowFrame;
  for (;;) {
    // XXXneerja - Instead of calling AddDeletedRowIndex() per row frame
    // it is possible to change AddDeleteRowIndex to instead take
    // <start row index> and <num of rows to mark for deletion> as arguments.
    // The problem that emerges here is mDeletedRowIndexRanges only stores
    // disjoint index ranges and since AddDeletedRowIndex() must operate on
    // the "stored" index, in some cases it is possible that the range
    // of indices to delete becomes overlapping EG: Deleting rows 9 - 11 and
    // then from the remaining rows deleting the *new* rows 7 to 20.
    // Handling these overlapping ranges is much more complicated to
    // implement and so I opted to add the deleted row index of one row at a
    // time and maintain the invariant that the range of deleted row indices
    // is always disjoint.
    currentRowFrame->AddDeletedRowIndex();
    if (--aNumRowsToDelete == 0) {
      break;
    }
    currentRowFrame = do_QueryFrame(currentRowFrame->GetNextSibling());
    if (!currentRowFrame) {
      MOZ_ASSERT_UNREACHABLE("expected another row frame");
      break;
    }
  }
}

void nsTableRowGroupFrame::AddDeletedRowIndex(int32_t aDeletedRowStoredIndex) {
  nsTableFrame* tableFrame = GetTableFrame();
  return tableFrame->AddDeletedRowIndex(aDeletedRowStoredIndex);
}

void nsTableRowGroupFrame::InitRepeatedFrame(
    nsTableRowGroupFrame* aHeaderFooterFrame) {
  nsTableRowFrame* copyRowFrame = GetFirstRow();
  nsTableRowFrame* originalRowFrame = aHeaderFooterFrame->GetFirstRow();
  AddStateBits(NS_REPEATED_ROW_OR_ROWGROUP);
  while (copyRowFrame && originalRowFrame) {
    copyRowFrame->AddStateBits(NS_REPEATED_ROW_OR_ROWGROUP);
    int rowIndex = originalRowFrame->GetRowIndex();
    copyRowFrame->SetRowIndex(rowIndex);

    // For each table cell frame set its column index
    nsTableCellFrame* originalCellFrame = originalRowFrame->GetFirstCell();
    nsTableCellFrame* copyCellFrame = copyRowFrame->GetFirstCell();
    while (copyCellFrame && originalCellFrame) {
      NS_ASSERTION(
          originalCellFrame->GetContent() == copyCellFrame->GetContent(),
          "cell frames have different content");
      uint32_t colIndex = originalCellFrame->ColIndex();
      copyCellFrame->SetColIndex(colIndex);

      // Move to the next cell frame
      copyCellFrame = copyCellFrame->GetNextCell();
      originalCellFrame = originalCellFrame->GetNextCell();
    }

    // Move to the next row frame
    originalRowFrame = originalRowFrame->GetNextRow();
    copyRowFrame = copyRowFrame->GetNextRow();
  }
}

// Handle the child-traversal part of DisplayGenericTablePart
static void DisplayRows(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,
                        const nsDisplayListSet& aLists) {
  nscoord overflowAbove;
  nsTableRowGroupFrame* f = static_cast<nsTableRowGroupFrame*>(aFrame);
  // Don't try to use the row cursor if we have to descend into placeholders;
  // we might have rows containing placeholders, where the row's overflow
  // area doesn't intersect the dirty rect but we need to descend into the row
  // to see out of flows.
  // Note that we really want to check ShouldDescendIntoFrame for all
  // the rows in |f|, but that's exactly what we're trying to avoid, so we
  // approximate it by checking it for |f|: if it's true for any row
  // in |f| then it's true for |f| itself.
  nsIFrame* kid = aBuilder->ShouldDescendIntoFrame(f, true)
                      ? nullptr
                      : f->GetFirstRowContaining(aBuilder->GetVisibleRect().y,
                                                 &overflowAbove);

  if (kid) {
    // have a cursor, use it
    while (kid) {
      if (kid->GetRect().y - overflowAbove >=
          aBuilder->GetVisibleRect().YMost()) {
        break;
      }
      f->BuildDisplayListForChild(aBuilder, kid, aLists);
      kid = kid->GetNextSibling();
    }
    return;
  }

  // No cursor. Traverse children the hard way and build a cursor while we're at
  // it
  nsTableRowGroupFrame::FrameCursorData* cursor = f->SetupRowCursor();
  kid = f->PrincipalChildList().FirstChild();
  while (kid) {
    f->BuildDisplayListForChild(aBuilder, kid, aLists);

    if (cursor) {
      if (!cursor->AppendFrame(kid)) {
        f->ClearRowCursor();
        return;
      }
    }

    kid = kid->GetNextSibling();
  }
  if (cursor) {
    cursor->FinishBuildingCursor();
  }
}

void nsTableRowGroupFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
                                            const nsDisplayListSet& aLists) {
  DisplayOutsetBoxShadow(aBuilder, aLists.BorderBackground());

  for (nsTableRowFrame* row = GetFirstRow(); row; row = row->GetNextRow()) {
    if (!aBuilder->GetDirtyRect().Intersects(row->InkOverflowRect() +
                                             row->GetNormalPosition())) {
      continue;
    }
    row->PaintCellBackgroundsForFrame(this, aBuilder, aLists,
                                      row->GetNormalPosition());
  }

  DisplayInsetBoxShadow(aBuilder, aLists.BorderBackground());

  DisplayOutline(aBuilder, aLists);

  DisplayRows(aBuilder, this, aLists);
}

LogicalSides nsTableRowGroupFrame::GetLogicalSkipSides() const {
  LogicalSides skip(mWritingMode);
  if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak ==
                   StyleBoxDecorationBreak::Clone)) {
    return skip;
  }

  if (GetPrevInFlow()) {
    skip += LogicalSide::BStart;
  }
  if (GetNextInFlow()) {
    skip += LogicalSide::BEnd;
  }
  return skip;
}

// Position and size aKidFrame and update our reflow input.
void nsTableRowGroupFrame::PlaceChild(
    nsPresContext* aPresContext, TableRowGroupReflowInput& aReflowInput,
    nsIFrame* aKidFrame, const ReflowInput& aKidReflowInput, WritingMode aWM,
    const LogicalPoint& aKidPosition, const nsSize& aContainerSize,
    ReflowOutput& aDesiredSize, const nsRect& aOriginalKidRect,
    const nsRect& aOriginalKidInkOverflow) {
  bool isFirstReflow = aKidFrame->HasAnyStateBits(NS_FRAME_FIRST_REFLOW);

  // Place and size the child
  FinishReflowChild(aKidFrame, aPresContext, aDesiredSize, &aKidReflowInput,
                    aWM, aKidPosition, aContainerSize,
                    ReflowChildFlags::ApplyRelativePositioning);

  nsTableFrame* tableFrame = GetTableFrame();
  if (tableFrame->IsBorderCollapse()) {
    nsTableFrame::InvalidateTableFrame(aKidFrame, aOriginalKidRect,
                                       aOriginalKidInkOverflow, isFirstReflow);
  }

  // Adjust the running block-offset
  aReflowInput.mBCoord += aDesiredSize.BSize(aWM);

  // If our block-size is constrained then update the available bsize
  if (NS_UNCONSTRAINEDSIZE != aReflowInput.mAvailSize.BSize(aWM)) {
    aReflowInput.mAvailSize.BSize(aWM) -= aDesiredSize.BSize(aWM);
  }
}

void nsTableRowGroupFrame::InitChildReflowInput(nsPresContext* aPresContext,
                                                bool aBorderCollapse,
                                                ReflowInput& aReflowInput) {
  const auto childWM = aReflowInput.GetWritingMode();
  LogicalMargin border(childWM);
  if (aBorderCollapse) {
    auto* rowFrame = static_cast<nsTableRowFrame*>(aReflowInput.mFrame);
    border = rowFrame->GetBCBorderWidth(childWM);
  }
  const LogicalMargin zeroPadding(childWM);
  aReflowInput.Init(aPresContext, Nothing(), Some(border), Some(zeroPadding));
}

static void CacheRowBSizesForPrinting(nsTableRowFrame* aFirstRow,
                                      WritingMode aWM) {
  for (nsTableRowFrame* row = aFirstRow; row; row = row->GetNextRow()) {
    if (!row->GetPrevInFlow()) {
      row->SetUnpaginatedBSize(row->BSize(aWM));
    }
  }
}

void nsTableRowGroupFrame::ReflowChildren(
    nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
    TableRowGroupReflowInput& aReflowInput, nsReflowStatus& aStatus,
    bool* aPageBreakBeforeEnd) {
  if (aPageBreakBeforeEnd) {
    *aPageBreakBeforeEnd = false;
  }

  WritingMode wm = aReflowInput.mReflowInput.GetWritingMode();
  nsTableFrame* tableFrame = GetTableFrame();
  const bool borderCollapse = tableFrame->IsBorderCollapse();

  // XXXldb Should we really be checking IsPaginated(),
  // or should we *only* check available block-size?
  // (Think about multi-column layout!)
  bool isPaginated = aPresContext->IsPaginated() &&
                     NS_UNCONSTRAINEDSIZE != aReflowInput.mAvailSize.BSize(wm);

  bool reflowAllKids = aReflowInput.mReflowInput.ShouldReflowAllKids() ||
                       tableFrame->IsGeometryDirty() ||
                       tableFrame->NeedToCollapse();

  // in vertical-rl mode, we always need the row bsizes in order to
  // get the necessary containerSize for placing our kids
  bool needToCalcRowBSizes = reflowAllKids || wm.IsVerticalRL();

  nsSize containerSize =
      aReflowInput.mReflowInput.ComputedSizeAsContainerIfConstrained();

  nsIFrame* prevKidFrame = nullptr;
  for (nsTableRowFrame* kidFrame = GetFirstRow(); kidFrame;
       prevKidFrame = kidFrame, kidFrame = kidFrame->GetNextRow()) {
    const nscoord rowSpacing =
        tableFrame->GetRowSpacing(kidFrame->GetRowIndex());

    // Reflow the row frame
    if (reflowAllKids || kidFrame->IsSubtreeDirty() ||
        (aReflowInput.mReflowInput.mFlags.mSpecialBSizeReflow &&
         (isPaginated ||
          kidFrame->HasAnyStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE)))) {
      LogicalRect oldKidRect = kidFrame->GetLogicalRect(wm, containerSize);
      nsRect oldKidInkOverflow = kidFrame->InkOverflowRect();

      ReflowOutput kidDesiredSize(aReflowInput.mReflowInput);

      // Reflow the child into the available space, giving it as much bsize as
      // it wants. We'll deal with splitting later after we've computed the row
      // bsizes, taking into account cells with row spans...
      LogicalSize kidAvailSize = aReflowInput.mAvailSize;
      kidAvailSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
      ReflowInput kidReflowInput(aPresContext, aReflowInput.mReflowInput,
                                 kidFrame, kidAvailSize, Nothing(),
                                 ReflowInput::InitFlag::CallerWillInit);
      InitChildReflowInput(aPresContext, borderCollapse, kidReflowInput);

      // This can indicate that columns were resized.
      if (aReflowInput.mReflowInput.IsIResize()) {
        kidReflowInput.SetIResize(true);
      }

      NS_ASSERTION(kidFrame == mFrames.FirstChild() || prevKidFrame,
                   "If we're not on the first frame, we should have a "
                   "previous sibling...");
      // If prev row has nonzero YMost, then we can't be at the top of the page
      if (prevKidFrame && prevKidFrame->GetNormalRect().YMost() > 0) {
        kidReflowInput.mFlags.mIsTopOfPage = false;
      }

      LogicalPoint kidPosition(wm, 0, aReflowInput.mBCoord);
      ReflowChild(kidFrame, aPresContext, kidDesiredSize, kidReflowInput, wm,
                  kidPosition, containerSize, ReflowChildFlags::Default,
                  aStatus);

      // Place the child
      PlaceChild(aPresContext, aReflowInput, kidFrame, kidReflowInput, wm,
                 kidPosition, containerSize, kidDesiredSize,
                 oldKidRect.GetPhysicalRect(wm, containerSize),
                 oldKidInkOverflow);
      aReflowInput.mBCoord += rowSpacing;

      if (!reflowAllKids) {
        if (IsSimpleRowFrame(tableFrame, kidFrame)) {
          // Inform the row of its new bsize.
          kidFrame->DidResize();
          // the overflow area may have changed inflate the overflow area
          const nsStylePosition* stylePos = StylePosition();
          if (tableFrame->IsAutoBSize(wm) &&
              !stylePos->BSize(wm, StyleDisplay()->mPosition)
                   ->ConvertsToLength()) {
            // Because other cells in the row may need to be aligned
            // differently, repaint the entire row
            InvalidateFrame();
          } else if (oldKidRect.BSize(wm) != kidDesiredSize.BSize(wm)) {
            needToCalcRowBSizes = true;
          }
        } else {
          needToCalcRowBSizes = true;
        }
      }

      if (isPaginated && aPageBreakBeforeEnd && !*aPageBreakBeforeEnd) {
        nsTableRowFrame* nextRow = kidFrame->GetNextRow();
        if (nextRow) {
          *aPageBreakBeforeEnd =
              nsTableFrame::PageBreakAfter(kidFrame, nextRow);
        }
      }
    } else {
      // Move a child that was skipped during a reflow.
      const LogicalPoint oldPosition =
          kidFrame->GetLogicalNormalPosition(wm, containerSize);
      if (oldPosition.B(wm) != aReflowInput.mBCoord) {
        kidFrame->InvalidateFrameSubtree();
        const LogicalPoint offset(wm, 0,
                                  aReflowInput.mBCoord - oldPosition.B(wm));
        kidFrame->MovePositionBy(wm, offset);
        nsTableFrame::RePositionViews(kidFrame);
        kidFrame->InvalidateFrameSubtree();
      }

      // Adjust the running b-offset so we know where the next row should be
      // placed
      nscoord bSize = kidFrame->BSize(wm) + rowSpacing;
      aReflowInput.mBCoord += bSize;

      if (NS_UNCONSTRAINEDSIZE != aReflowInput.mAvailSize.BSize(wm)) {
        aReflowInput.mAvailSize.BSize(wm) -= bSize;
      }
    }
    ConsiderChildOverflow(aDesiredSize.mOverflowAreas, kidFrame);
  }

  if (GetFirstRow()) {
    aReflowInput.mBCoord -=
        tableFrame->GetRowSpacing(GetStartRowIndex() + GetRowCount());
  }

  // Return our desired rect
  aDesiredSize.ISize(wm) = aReflowInput.mReflowInput.AvailableISize();
  aDesiredSize.BSize(wm) = aReflowInput.mBCoord;

  if (aReflowInput.mReflowInput.mFlags.mSpecialBSizeReflow) {
    DidResizeRows(aDesiredSize);
    if (isPaginated) {
      CacheRowBSizesForPrinting(GetFirstRow(), wm);
    }
  } else if (needToCalcRowBSizes) {
    CalculateRowBSizes(aPresContext, aDesiredSize, aReflowInput.mReflowInput);
    if (!reflowAllKids) {
      InvalidateFrame();
    }
  }
}

nsTableRowFrame* nsTableRowGroupFrame::GetFirstRow() const {
  nsIFrame* firstChild = mFrames.FirstChild();
  MOZ_ASSERT(
      !firstChild || static_cast<nsTableRowFrame*>(do_QueryFrame(firstChild)),
      "How do we have a non-row child?");
  return static_cast<nsTableRowFrame*>(firstChild);
}

nsTableRowFrame* nsTableRowGroupFrame::GetLastRow() const {
  nsIFrame* lastChild = mFrames.LastChild();
  MOZ_ASSERT(
      !lastChild || static_cast<nsTableRowFrame*>(do_QueryFrame(lastChild)),
      "How do we have a non-row child?");
  return static_cast<nsTableRowFrame*>(lastChild);
}

struct RowInfo {
  RowInfo() { bSize = pctBSize = hasStyleBSize = hasPctBSize = isSpecial = 0; }
  unsigned bSize;          // content bsize or fixed bsize, excluding pct bsize
  unsigned pctBSize : 29;  // pct bsize
  unsigned hasStyleBSize : 1;
  unsigned hasPctBSize : 1;
  unsigned isSpecial : 1;  // there is no cell originating in the row with
                           // rowspan=1 and there are at least 2 cells spanning
                           // the row and there is no style bsize on the row
};

static void UpdateBSizes(RowInfo& aRowInfo, nscoord aAdditionalBSize,
                         nscoord& aTotal, nscoord& aUnconstrainedTotal) {
  aRowInfo.bSize += aAdditionalBSize;
  aTotal += aAdditionalBSize;
  if (!aRowInfo.hasStyleBSize) {
    aUnconstrainedTotal += aAdditionalBSize;
  }
}

void nsTableRowGroupFrame::DidResizeRows(ReflowOutput& aDesiredSize) {
  // Update the cells spanning rows with their new bsizes.
  // This is the place where all of the cells in the row get set to the bsize
  // of the row.
  // Reset the overflow area.
  aDesiredSize.mOverflowAreas.Clear();
  for (nsTableRowFrame* rowFrame = GetFirstRow(); rowFrame;
       rowFrame = rowFrame->GetNextRow()) {
    rowFrame->DidResize();
    ConsiderChildOverflow(aDesiredSize.mOverflowAreas, rowFrame);
  }
}

// This calculates the bsize of all the rows and takes into account
// style bsize on the row group, style bsizes on rows and cells, style bsizes on
// rowspans. Actual row bsizes will be adjusted later if the table has a style
// bsize. Even if rows don't change bsize, this method must be called to set the
// bsizes of each cell in the row to the bsize of its row.
void nsTableRowGroupFrame::CalculateRowBSizes(nsPresContext* aPresContext,
                                              ReflowOutput& aDesiredSize,
                                              const ReflowInput& aReflowInput) {
  nsTableFrame* tableFrame = GetTableFrame();
  const bool isPaginated = aPresContext->IsPaginated();

  int32_t numEffCols = tableFrame->GetEffectiveColCount();

  int32_t startRowIndex = GetStartRowIndex();
  // find the row corresponding to the row index we just found
  nsTableRowFrame* startRowFrame = GetFirstRow();

  if (!startRowFrame) {
    return;
  }

  // The current row group block-size is the block-origin of the 1st row
  // we are about to calculate a block-size for.
  WritingMode wm = aReflowInput.GetWritingMode();
  nsSize containerSize;  // actual value is unimportant as we're initially
                         // computing sizes, not physical positions
  nscoord startRowGroupBSize =
      startRowFrame->GetLogicalNormalPosition(wm, containerSize).B(wm);

  int32_t numRows =
      GetRowCount() - (startRowFrame->GetRowIndex() - GetStartRowIndex());
  // Collect the current bsize of each row.
  if (numRows <= 0) {
    return;
  }

  AutoTArray<RowInfo, 32> rowInfo;
  // XXX(Bug 1631371) Check if this should use a fallible operation as it
  // pretended earlier.
  rowInfo.AppendElements(numRows);

  bool hasRowSpanningCell = false;
  nscoord bSizeOfRows = 0;
  nscoord bSizeOfUnStyledRows = 0;
  // Get the bsize of each row without considering rowspans. This will be the
  // max of the largest desired bsize of each cell, the largest style bsize of
  // each cell, the style bsize of the row.
  nscoord pctBSizeBasis = GetBSizeBasis(aReflowInput);
  int32_t
      rowIndex;  // the index in rowInfo, not among the rows in the row group
  nsTableRowFrame* rowFrame;
  for (rowFrame = startRowFrame, rowIndex = 0; rowFrame;
       rowFrame = rowFrame->GetNextRow(), rowIndex++) {
    nscoord nonPctBSize = rowFrame->GetContentBSize();
    if (isPaginated) {
      nonPctBSize = std::max(nonPctBSize, rowFrame->BSize(wm));
    }
    if (!rowFrame->GetPrevInFlow()) {
      if (rowFrame->HasPctBSize()) {
        rowInfo[rowIndex].hasPctBSize = true;
        rowInfo[rowIndex].pctBSize = rowFrame->GetInitialBSize(pctBSizeBasis);
      }
      rowInfo[rowIndex].hasStyleBSize = rowFrame->HasStyleBSize();
      nonPctBSize = std::max(nonPctBSize, rowFrame->GetFixedBSize());
    }
    UpdateBSizes(rowInfo[rowIndex], nonPctBSize, bSizeOfRows,
                 bSizeOfUnStyledRows);

    if (!rowInfo[rowIndex].hasStyleBSize) {
      if (isPaginated ||
          tableFrame->HasMoreThanOneCell(rowIndex + startRowIndex)) {
        rowInfo[rowIndex].isSpecial = true;
        // iteratate the row's cell frames to see if any do not have rowspan > 1
        nsTableCellFrame* cellFrame = rowFrame->GetFirstCell();
        while (cellFrame) {
          int32_t rowSpan = tableFrame->GetEffectiveRowSpan(
              rowIndex + startRowIndex, *cellFrame);
          if (1 == rowSpan) {
            rowInfo[rowIndex].isSpecial = false;
            break;
          }
          cellFrame = cellFrame->GetNextCell();
        }
      }
    }
    // See if a cell spans into the row. If so we'll have to do the next step
    if (!hasRowSpanningCell) {
      if (tableFrame->RowIsSpannedInto(rowIndex + startRowIndex, numEffCols)) {
        hasRowSpanningCell = true;
      }
    }
  }

  if (hasRowSpanningCell) {
    // Get the bsize of cells with rowspans and allocate any extra space to the
    // rows they span iteratate the child frames and process the row frames
    // among them
    for (rowFrame = startRowFrame, rowIndex = 0; rowFrame;
         rowFrame = rowFrame->GetNextRow(), rowIndex++) {
      // See if the row has an originating cell with rowspan > 1. We cannot
      // determine this for a row in a continued row group by calling
      // RowHasSpanningCells, because the row's fif may not have any originating
      // cells yet the row may have a continued cell which originates in it.
      if (GetPrevInFlow() || tableFrame->RowHasSpanningCells(
                                 startRowIndex + rowIndex, numEffCols)) {
        nsTableCellFrame* cellFrame = rowFrame->GetFirstCell();
        // iteratate the row's cell frames
        while (cellFrame) {
          const nscoord rowSpacing =
              tableFrame->GetRowSpacing(startRowIndex + rowIndex);
          int32_t rowSpan = tableFrame->GetEffectiveRowSpan(
              rowIndex + startRowIndex, *cellFrame);
          if ((rowIndex + rowSpan) > numRows) {
            // there might be rows pushed already to the nextInFlow
            rowSpan = numRows - rowIndex;
          }
          if (rowSpan > 1) {  // a cell with rowspan > 1, determine the bsize of
                              // the rows it spans
            nscoord bsizeOfRowsSpanned = 0;
            nscoord bsizeOfUnStyledRowsSpanned = 0;
            nscoord numSpecialRowsSpanned = 0;
            nscoord cellSpacingTotal = 0;
            int32_t spanX;
            for (spanX = 0; spanX < rowSpan; spanX++) {
              bsizeOfRowsSpanned += rowInfo[rowIndex + spanX].bSize;
              if (!rowInfo[rowIndex + spanX].hasStyleBSize) {
                bsizeOfUnStyledRowsSpanned += rowInfo[rowIndex + spanX].bSize;
              }
              if (0 != spanX) {
                cellSpacingTotal += rowSpacing;
              }
              if (rowInfo[rowIndex + spanX].isSpecial) {
                numSpecialRowsSpanned++;
              }
            }
            nscoord bsizeOfAreaSpanned = bsizeOfRowsSpanned + cellSpacingTotal;
            // get the bsize of the cell
            LogicalSize cellFrameSize = cellFrame->GetLogicalSize(wm);
            LogicalSize cellDesSize = cellFrame->GetDesiredSize();
            cellDesSize.BSize(wm) = rowFrame->CalcCellActualBSize(
                cellFrame, cellDesSize.BSize(wm), wm);
            cellFrameSize.BSize(wm) = cellDesSize.BSize(wm);

            if (bsizeOfAreaSpanned < cellFrameSize.BSize(wm)) {
              // the cell's bsize is larger than the available space of the rows
              // it spans so distribute the excess bsize to the rows affected
              nscoord extra = cellFrameSize.BSize(wm) - bsizeOfAreaSpanned;
              nscoord extraUsed = 0;
              if (0 == numSpecialRowsSpanned) {
                // NS_ASSERTION(bsizeOfRowsSpanned > 0, "invalid row span
                // situation");
                bool haveUnStyledRowsSpanned = (bsizeOfUnStyledRowsSpanned > 0);
                nscoord divisor = (haveUnStyledRowsSpanned)
                                      ? bsizeOfUnStyledRowsSpanned
                                      : bsizeOfRowsSpanned;
                if (divisor > 0) {
                  for (spanX = rowSpan - 1; spanX >= 0; spanX--) {
                    if (!haveUnStyledRowsSpanned ||
                        !rowInfo[rowIndex + spanX].hasStyleBSize) {
                      // The amount of additional space each row gets is
                      // proportional to its bsize
                      float percent = ((float)rowInfo[rowIndex + spanX].bSize) /
                                      ((float)divisor);

                      // give rows their percentage, except for the first row
                      // which gets the remainder
                      nscoord extraForRow =
                          (0 == spanX)
                              ? extra - extraUsed
                              : NSToCoordRound(((float)(extra)) * percent);
                      extraForRow = std::min(extraForRow, extra - extraUsed);
                      // update the row bsize
                      UpdateBSizes(rowInfo[rowIndex + spanX], extraForRow,
                                   bSizeOfRows, bSizeOfUnStyledRows);
                      extraUsed += extraForRow;
                      if (extraUsed >= extra) {
                        NS_ASSERTION((extraUsed == extra),
                                     "invalid row bsize calculation");
                        break;
                      }
                    }
                  }
                } else {
                  // put everything in the last row
                  UpdateBSizes(rowInfo[rowIndex + rowSpan - 1], extra,
                               bSizeOfRows, bSizeOfUnStyledRows);
                }
              } else {
                // give the extra to the special rows
                nscoord numSpecialRowsAllocated = 0;
                for (spanX = rowSpan - 1; spanX >= 0; spanX--) {
                  if (rowInfo[rowIndex + spanX].isSpecial) {
                    // The amount of additional space each degenerate row gets
                    // is proportional to the number of them
                    float percent = 1.0f / ((float)numSpecialRowsSpanned);

                    // give rows their percentage, except for the first row
                    // which gets the remainder
                    nscoord extraForRow =
                        (numSpecialRowsSpanned - 1 == numSpecialRowsAllocated)
                            ? extra - extraUsed
                            : NSToCoordRound(((float)(extra)) * percent);
                    extraForRow = std::min(extraForRow, extra - extraUsed);
                    // update the row bsize
                    UpdateBSizes(rowInfo[rowIndex + spanX], extraForRow,
                                 bSizeOfRows, bSizeOfUnStyledRows);
                    extraUsed += extraForRow;
                    if (extraUsed >= extra) {
                      NS_ASSERTION((extraUsed == extra),
                                   "invalid row bsize calculation");
                      break;
                    }
                  }
                }
              }
            }
          }  // if (rowSpan > 1)
          cellFrame = cellFrame->GetNextCell();
        }  // while (cellFrame)
      }  // if (tableFrame->RowHasSpanningCells(startRowIndex + rowIndex) {
    }  // while (rowFrame)
  }

  // pct bsize rows have already got their content bsizes.
  // Give them their pct bsizes up to pctBSizeBasis
  nscoord extra = pctBSizeBasis - bSizeOfRows;
  for (rowFrame = startRowFrame, rowIndex = 0; rowFrame && (extra > 0);
       rowFrame = rowFrame->GetNextRow(), rowIndex++) {
    RowInfo& rInfo = rowInfo[rowIndex];
    if (rInfo.hasPctBSize) {
      nscoord rowExtra =
          (rInfo.pctBSize > rInfo.bSize) ? rInfo.pctBSize - rInfo.bSize : 0;
      rowExtra = std::min(rowExtra, extra);
      UpdateBSizes(rInfo, rowExtra, bSizeOfRows, bSizeOfUnStyledRows);
      extra -= rowExtra;
    }
  }

  bool styleBSizeAllocation = false;
  nscoord rowGroupBSize = startRowGroupBSize + bSizeOfRows +
                          tableFrame->GetRowSpacing(0, numRows - 1);
  // if we have a style bsize, allocate the extra bsize to unconstrained rows
  if ((aReflowInput.ComputedBSize() > rowGroupBSize) &&
      (NS_UNCONSTRAINEDSIZE != aReflowInput.ComputedBSize())) {
    nscoord extraComputedBSize = aReflowInput.ComputedBSize() - rowGroupBSize;
    nscoord extraUsed = 0;
    bool haveUnStyledRows = (bSizeOfUnStyledRows > 0);
    nscoord divisor = (haveUnStyledRows) ? bSizeOfUnStyledRows : bSizeOfRows;
    if (divisor > 0) {
      styleBSizeAllocation = true;
      for (rowIndex = 0; rowIndex < numRows; rowIndex++) {
        if (!haveUnStyledRows || !rowInfo[rowIndex].hasStyleBSize) {
          // The amount of additional space each row gets is based on the
          // percentage of space it occupies
          float percent = ((float)rowInfo[rowIndex].bSize) / ((float)divisor);
          // give rows their percentage, except for the last row which gets the
          // remainder
          nscoord extraForRow =
              (numRows - 1 == rowIndex)
                  ? extraComputedBSize - extraUsed
                  : NSToCoordRound(((float)extraComputedBSize) * percent);
          extraForRow = std::min(extraForRow, extraComputedBSize - extraUsed);
          // update the row bsize
          UpdateBSizes(rowInfo[rowIndex], extraForRow, bSizeOfRows,
                       bSizeOfUnStyledRows);
          extraUsed += extraForRow;
          if (extraUsed >= extraComputedBSize) {
            NS_ASSERTION((extraUsed == extraComputedBSize),
                         "invalid row bsize calculation");
            break;
          }
        }
      }
    }
    rowGroupBSize = aReflowInput.ComputedBSize();
  }

  if (wm.IsVertical()) {
    // we need the correct containerSize below for block positioning in
    // vertical-rl writing mode
    containerSize.width = rowGroupBSize;
  }

  nscoord bOrigin = startRowGroupBSize;
  // update the rows with their (potentially) new bsizes
  for (rowFrame = startRowFrame, rowIndex = 0; rowFrame;
       rowFrame = rowFrame->GetNextRow(), rowIndex++) {
    nsRect rowBounds = rowFrame->GetRect();
    LogicalSize rowBoundsSize(wm, rowBounds.Size());
    nsRect rowInkOverflow = rowFrame->InkOverflowRect();
    nscoord deltaB =
        bOrigin - rowFrame->GetLogicalNormalPosition(wm, containerSize).B(wm);

    nscoord rowBSize =
        (rowInfo[rowIndex].bSize > 0) ? rowInfo[rowIndex].bSize : 0;

    if (deltaB != 0 || (rowBSize != rowBoundsSize.BSize(wm))) {
      // Resize/move the row to its final size and position
      if (deltaB != 0) {
        rowFrame->InvalidateFrameSubtree();
      }

      rowFrame->MovePositionBy(wm, LogicalPoint(wm, 0, deltaB));
      rowFrame->SetSize(LogicalSize(wm, rowBoundsSize.ISize(wm), rowBSize));

      nsTableFrame::InvalidateTableFrame(rowFrame, rowBounds, rowInkOverflow,
                                         false);

      if (deltaB != 0) {
        nsTableFrame::RePositionViews(rowFrame);
        // XXXbz we don't need to update our overflow area?
      }
    }
    bOrigin += rowBSize + tableFrame->GetRowSpacing(startRowIndex + rowIndex);
  }

  if (isPaginated && styleBSizeAllocation) {
    // since the row group has a style bsize, cache the row bsizes,
    // so next in flows can honor them
    CacheRowBSizesForPrinting(GetFirstRow(), wm);
  }

  DidResizeRows(aDesiredSize);

  aDesiredSize.BSize(wm) = rowGroupBSize;  // Adjust our desired size
}

nscoord nsTableRowGroupFrame::CollapseRowGroupIfNecessary(nscoord aBTotalOffset,
                                                          nscoord aISize,
                                                          WritingMode aWM) {
  nsTableFrame* tableFrame = GetTableFrame();
  nsSize containerSize = tableFrame->GetSize();
  const nsStyleVisibility* groupVis = StyleVisibility();
  bool collapseGroup = StyleVisibility::Collapse == groupVis->mVisible;
  if (collapseGroup) {
    tableFrame->SetNeedToCollapse(true);
  }

  OverflowAreas overflow;

  nsTableRowFrame* rowFrame = GetFirstRow();
  bool didCollapse = false;
  nscoord bGroupOffset = 0;
  while (rowFrame) {
    bGroupOffset += rowFrame->CollapseRowIfNecessary(
        bGroupOffset, aISize, collapseGroup, didCollapse);
    ConsiderChildOverflow(overflow, rowFrame);
    rowFrame = rowFrame->GetNextRow();
  }

  LogicalRect groupRect = GetLogicalRect(aWM, containerSize);
  nsRect oldGroupRect = GetRect();
  nsRect oldGroupInkOverflow = InkOverflowRect();

  groupRect.BSize(aWM) -= bGroupOffset;
  if (didCollapse) {
    // add back the cellspacing between rowgroups
    groupRect.BSize(aWM) +=
        tableFrame->GetRowSpacing(GetStartRowIndex() + GetRowCount());
  }

  groupRect.BStart(aWM) -= aBTotalOffset;
  groupRect.ISize(aWM) = aISize;

  if (aBTotalOffset != 0) {
    InvalidateFrameSubtree();
  }

  SetRect(aWM, groupRect, containerSize);
  overflow.UnionAllWith(
      nsRect(0, 0, groupRect.Width(aWM), groupRect.Height(aWM)));
  FinishAndStoreOverflow(overflow, groupRect.Size(aWM).GetPhysicalSize(aWM));
  nsTableFrame::RePositionViews(this);
  nsTableFrame::InvalidateTableFrame(this, oldGroupRect, oldGroupInkOverflow,
                                     false);

  return bGroupOffset;
}

nsTableRowFrame* nsTableRowGroupFrame::CreateContinuingRowFrame(
    nsIFrame* aRowFrame) {
  // Create the continuing frame which will create continuing cell frames.
  auto* contRowFrame = static_cast<nsTableRowFrame*>(
      PresShell()->FrameConstructor()->CreateContinuingFrame(aRowFrame, this));

  // Add the continuing row frame to the child list.
  mFrames.InsertFrame(nullptr, aRowFrame, contRowFrame);

  // Push the continuing row frame and the frames that follow.
  // This needs to match `UndoContinuedRow`.
  PushChildrenToOverflow(contRowFrame, aRowFrame);

  return contRowFrame;
}

// Reflow the cells with rowspan > 1 which originate between aFirstRow
// and end on or after aLastRow. aFirstTruncatedRow is the highest row on the
// page that contains a cell which cannot split on this page
void nsTableRowGroupFrame::SplitSpanningCells(
    nsPresContext* aPresContext, const ReflowInput& aReflowInput,
    nsTableFrame* aTable, nsTableRowFrame* aFirstRow, nsTableRowFrame* aLastRow,
    bool aFirstRowIsTopOfPage, nscoord aSpanningRowBEnd,
    const nsSize& aContainerSize, nsTableRowFrame*& aContRow,
    nsTableRowFrame*& aFirstTruncatedRow, nscoord& aDesiredBSize) {
  NS_ASSERTION(aSpanningRowBEnd >= 0, "Can't split negative bsizes");
  aFirstTruncatedRow = nullptr;
  aDesiredBSize = 0;

  const WritingMode wm = aReflowInput.GetWritingMode();
  const bool borderCollapse = aTable->IsBorderCollapse();
  int32_t lastRowIndex = aLastRow->GetRowIndex();
  bool wasLast = false;
  bool haveRowSpan = false;
  // Iterate the rows between aFirstRow and aLastRow
  for (nsTableRowFrame* row = aFirstRow; !wasLast; row = row->GetNextRow()) {
    wasLast = (row == aLastRow);
    int32_t rowIndex = row->GetRowIndex();
    const LogicalRect rowRect = row->GetLogicalNormalRect(wm, aContainerSize);
    // Iterate the cells looking for those that have rowspan > 1
    for (nsTableCellFrame* cell = row->GetFirstCell(); cell;
         cell = cell->GetNextCell()) {
      int32_t rowSpan = aTable->GetEffectiveRowSpan(rowIndex, *cell);
      // Only reflow rowspan > 1 cells which span aLastRow. Those which don't
      // span aLastRow were reflowed correctly during the unconstrained bsize
      // reflow.
      if ((rowSpan > 1) && (rowIndex + rowSpan > lastRowIndex)) {
        haveRowSpan = true;
        nsReflowStatus status;
        // Ask the row to reflow the cell to the bsize of all the rows it spans
        // up through aLastRow cellAvailBSize is the space between the row group
        // start and the end of the page
        const nscoord cellAvailBSize = aSpanningRowBEnd - rowRect.BStart(wm);
        NS_ASSERTION(cellAvailBSize >= 0, "No space for cell?");
        bool isTopOfPage = (row == aFirstRow) && aFirstRowIsTopOfPage;

        LogicalSize rowAvailSize(
            wm, aReflowInput.AvailableISize(),
            std::max(aReflowInput.AvailableBSize() - rowRect.BStart(wm), 0));
        // Don't let the available block-size exceed what CalculateRowBSizes set
        // for it.
        rowAvailSize.BSize(wm) =
            std::min(rowAvailSize.BSize(wm), rowRect.BSize(wm));
        ReflowInput rowReflowInput(
            aPresContext, aReflowInput, row,
            rowAvailSize.ConvertTo(row->GetWritingMode(), wm), Nothing(),
            ReflowInput::InitFlag::CallerWillInit);
        InitChildReflowInput(aPresContext, borderCollapse, rowReflowInput);
        rowReflowInput.mFlags.mIsTopOfPage = isTopOfPage;  // set top of page

        nscoord cellBSize =
            row->ReflowCellFrame(aPresContext, rowReflowInput, isTopOfPage,
                                 cell, cellAvailBSize, status);
        aDesiredBSize = std::max(aDesiredBSize, rowRect.BStart(wm) + cellBSize);
        if (status.IsComplete()) {
          if (cellBSize > cellAvailBSize) {
            aFirstTruncatedRow = row;
            if ((row != aFirstRow) || !aFirstRowIsTopOfPage) {
              // return now, since we will be getting another reflow after
              // either (1) row is moved to the next page or (2) the row group
              // is moved to the next page
              return;
            }
          }
        } else {
          if (!aContRow) {
            aContRow = CreateContinuingRowFrame(aLastRow);
          }
          if (aContRow) {
            if (row != aLastRow) {
              // aContRow needs a continuation for cell, since cell spanned into
              // aLastRow but does not originate there
              nsTableCellFrame* contCell = static_cast<nsTableCellFrame*>(
                  PresShell()->FrameConstructor()->CreateContinuingFrame(
                      cell, aLastRow));
              uint32_t colIndex = cell->ColIndex();
              aContRow->InsertCellFrame(contCell, colIndex);
            }
          }
        }
      }
    }
  }
  if (!haveRowSpan) {
    aDesiredBSize = aLastRow->GetLogicalNormalRect(wm, aContainerSize).BEnd(wm);
  }
}

// Remove the next-in-flow of the row, its cells and their cell blocks. This
// is necessary in case the row doesn't need a continuation later on or needs
// a continuation which doesn't have the same number of cells that now exist.
void nsTableRowGroupFrame::UndoContinuedRow(nsPresContext* aPresContext,
                                            nsTableRowFrame* aRow) {
  if (!aRow) {
    return;  // allow null aRow to avoid callers doing null checks
  }

  // rowBefore was the prev-sibling of aRow's next-sibling before aRow was
  // created
  nsTableRowFrame* rowBefore = (nsTableRowFrame*)aRow->GetPrevInFlow();
  MOZ_ASSERT(mFrames.ContainsFrame(rowBefore),
             "rowBefore not in our frame list?");

  // Needs to match `CreateContinuingRowFrame` - we're assuming that continued
  // frames always go into overflow frames list.
  AutoFrameListPtr overflows(aPresContext, StealOverflowFrames());
  if (!rowBefore || !overflows || overflows->IsEmpty() ||
      overflows->FirstChild() != aRow) {
    NS_ERROR("invalid continued row");
    return;
  }

  DestroyContext context(aPresContext->PresShell());
  // Destroy aRow, its cells, and their cell blocks. Cell blocks that have split
  // will not have reflowed yet to pick up content from any overflow lines.
  overflows->DestroyFrame(context, aRow);

  // Put the overflow rows into our child list
  if (!overflows->IsEmpty()) {
    mFrames.InsertFrames(nullptr, rowBefore, std::move(*overflows));
  }
}

void nsTableRowGroupFrame::SplitRowGroup(nsPresContext* aPresContext,
                                         ReflowOutput& aDesiredSize,
                                         const ReflowInput& aReflowInput,
                                         nsTableFrame* aTableFrame,
                                         nsReflowStatus& aStatus,
                                         bool aRowForcedPageBreak) {
  MOZ_ASSERT(aPresContext->IsPaginated(),
             "SplitRowGroup currently supports only paged media");

  const WritingMode wm = aReflowInput.GetWritingMode();
  nsTableRowFrame* prevRowFrame = nullptr;
  aDesiredSize.BSize(wm) = 0;
  aDesiredSize.SetOverflowAreasToDesiredBounds();

  const nscoord availISize = aReflowInput.AvailableISize();
  const nscoord availBSize = aReflowInput.AvailableBSize();
  const nsSize containerSize =
      aReflowInput.ComputedSizeAsContainerIfConstrained();
  const bool borderCollapse = aTableFrame->IsBorderCollapse();

  const nscoord pageBSize =
      LogicalSize(wm, aPresContext->GetPageSize()).BSize(wm);
  NS_ASSERTION(pageBSize != NS_UNCONSTRAINEDSIZE,
               "The table shouldn't be split when there should be space");

  bool isTopOfPage = aReflowInput.mFlags.mIsTopOfPage;
  nsTableRowFrame* firstRowThisPage = GetFirstRow();

  // Need to dirty the table's geometry, or else the row might skip
  // reflowing its cell as an optimization.
  aTableFrame->SetGeometryDirty();

  // Walk each of the row frames looking for the first row frame that doesn't
  // fit in the available space
  for (nsTableRowFrame* rowFrame = firstRowThisPage; rowFrame;
       rowFrame = rowFrame->GetNextRow()) {
    bool rowIsOnPage = true;
    const nscoord rowSpacing =
        aTableFrame->GetRowSpacing(rowFrame->GetRowIndex());
    const LogicalRect rowRect =
        rowFrame->GetLogicalNormalRect(wm, containerSize);
    // See if the row fits on this page
    if (rowRect.BEnd(wm) > availBSize) {
      nsTableRowFrame* contRow = nullptr;
      // Reflow the row in the availabe space and have it split if it is the 1st
      // row (on the page) or there is at least 5% of the current page available
      // XXX this 5% should be made a preference
      if (!prevRowFrame ||
          (availBSize - aDesiredSize.BSize(wm) > pageBSize / 20)) {
        LogicalSize availSize(wm, availISize,
                              std::max(availBSize - rowRect.BStart(wm), 0));
        // Don't let the available block-size exceed what CalculateRowBSizes set
        // for it.
        availSize.BSize(wm) = std::min(availSize.BSize(wm), rowRect.BSize(wm));

        ReflowInput rowReflowInput(
            aPresContext, aReflowInput, rowFrame,
            availSize.ConvertTo(rowFrame->GetWritingMode(), wm), Nothing(),
            ReflowInput::InitFlag::CallerWillInit);

        InitChildReflowInput(aPresContext, borderCollapse, rowReflowInput);
        rowReflowInput.mFlags.mIsTopOfPage = isTopOfPage;  // set top of page
        ReflowOutput rowMetrics(aReflowInput);

        // Get the old size before we reflow.
        nsRect oldRowRect = rowFrame->GetRect();
        nsRect oldRowInkOverflow = rowFrame->InkOverflowRect();

        // Reflow the cell with the constrained bsize. A cell with rowspan >1
        // will get this reflow later during SplitSpanningCells.
        //
        // Note: We just pass dummy aPos and aContainerSize since we are not
        // moving the row frame.
        const LogicalPoint dummyPos(wm);
        const nsSize dummyContainerSize;
        ReflowChild(rowFrame, aPresContext, rowMetrics, rowReflowInput, wm,
                    dummyPos, dummyContainerSize, ReflowChildFlags::NoMoveFrame,
                    aStatus);
        FinishReflowChild(rowFrame, aPresContext, rowMetrics, &rowReflowInput,
                          wm, dummyPos, dummyContainerSize,
                          ReflowChildFlags::NoMoveFrame);
        rowFrame->DidResize(ForceAlignTopForTableCell::Yes);

        if (!aRowForcedPageBreak && !aStatus.IsFullyComplete() &&
            ShouldAvoidBreakInside(aReflowInput)) {
          aStatus.SetInlineLineBreakBeforeAndReset();
          break;
        }

        nsTableFrame::InvalidateTableFrame(rowFrame, oldRowRect,
                                           oldRowInkOverflow, false);

        if (aStatus.IsIncomplete()) {
          // The row frame is incomplete and all of the rowspan 1 cells' block
          // frames split
          if ((rowMetrics.BSize(wm) <= rowReflowInput.AvailableBSize()) ||
              isTopOfPage) {
            // The row stays on this page because either it split ok or we're on
            // the top of page. If top of page and the block-size exceeded the
            // avail block-size, then there will be data loss.
            NS_ASSERTION(
                rowMetrics.BSize(wm) <= rowReflowInput.AvailableBSize(),
                "Data loss - incomplete row needed more block-size than "
                "available, on top of page!");
            contRow = CreateContinuingRowFrame(rowFrame);
            aDesiredSize.BSize(wm) += rowMetrics.BSize(wm);
            if (prevRowFrame) {
              aDesiredSize.BSize(wm) += rowSpacing;
            }
          } else {
            // Put the row on the next page to give it more block-size.
            rowIsOnPage = false;
          }
        } else {
          // The row frame is complete because either (1) its minimum block-size
          // is greater than the available block-size we gave it, or (2) it may
          // have been given a larger block-size through style than its content,
          // or (3) it contains a rowspan >1 cell which hasn't been reflowed
          // with a constrained block-size yet (we will find out when
          // SplitSpanningCells is called below)
          if (rowMetrics.BSize(wm) > availSize.BSize(wm) ||
              (aStatus.IsInlineBreakBefore() && !aRowForcedPageBreak)) {
            // cases (1) and (2)
            if (isTopOfPage) {
              // We're on top of the page, so keep the row on this page. There
              // will be data loss. Push the row frame that follows
              nsTableRowFrame* nextRowFrame = rowFrame->GetNextRow();
              if (nextRowFrame) {
                aStatus.Reset();
                aStatus.SetIncomplete();
              }
              aDesiredSize.BSize(wm) += rowMetrics.BSize(wm);
              if (prevRowFrame) {
                aDesiredSize.BSize(wm) += rowSpacing;
              }
              NS_WARNING(
                  "Data loss - complete row needed more block-size than "
                  "available, on top of page");
            } else {
              // We're not on top of the page, so put the row on the next page
              // to give it more block-size.
              rowIsOnPage = false;
            }
          }
        }
      } else {
        // Put the row on the next page to give it more block-size.
        rowIsOnPage = false;
      }

      nsTableRowFrame* lastRowThisPage = rowFrame;
      nscoord spanningRowBEnd = availBSize;
      if (!rowIsOnPage) {
        NS_ASSERTION(!contRow,
                     "We should not have created a continuation if none of "
                     "this row fits");
        if (!prevRowFrame ||
            (!aRowForcedPageBreak && ShouldAvoidBreakInside(aReflowInput))) {
          aStatus.SetInlineLineBreakBeforeAndReset();
          break;
        }
        spanningRowBEnd =
            prevRowFrame->GetLogicalNormalRect(wm, containerSize).BEnd(wm);
        lastRowThisPage = prevRowFrame;
        aStatus.Reset();
        aStatus.SetIncomplete();
      }

      // reflow the cells with rowspan >1 that occur on the page
      nsTableRowFrame* firstTruncatedRow;
      nscoord bMost;
      SplitSpanningCells(aPresContext, aReflowInput, aTableFrame,
                         firstRowThisPage, lastRowThisPage,
                         aReflowInput.mFlags.mIsTopOfPage, spanningRowBEnd,
                         containerSize, contRow, firstTruncatedRow, bMost);
      if (firstTruncatedRow) {
        // A rowspan >1 cell did not fit (and could not split) in the space we
        // gave it
        if (firstTruncatedRow == firstRowThisPage) {
          if (aReflowInput.mFlags.mIsTopOfPage) {
            NS_WARNING("data loss in a row spanned cell");
          } else {
            // We can't push children, so let our parent reflow us again with
            // more space
            aDesiredSize.BSize(wm) = rowRect.BEnd(wm);
            aStatus.Reset();
            UndoContinuedRow(aPresContext, contRow);
            contRow = nullptr;
          }
        } else {
          // Try to put firstTruncateRow on the next page
          nsTableRowFrame* rowBefore = firstTruncatedRow->GetPrevRow();
          const nscoord oldSpanningRowBEnd = spanningRowBEnd;
          spanningRowBEnd =
              rowBefore->GetLogicalNormalRect(wm, containerSize).BEnd(wm);

          UndoContinuedRow(aPresContext, contRow);
          contRow = nullptr;
          nsTableRowFrame* oldLastRowThisPage = lastRowThisPage;
          lastRowThisPage = rowBefore;
          aStatus.Reset();
          aStatus.SetIncomplete();

          // Call SplitSpanningCells again with rowBefore as the last row on the
          // page
          SplitSpanningCells(aPresContext, aReflowInput, aTableFrame,
                             firstRowThisPage, rowBefore,
                             aReflowInput.mFlags.mIsTopOfPage, spanningRowBEnd,
                             containerSize, contRow, firstTruncatedRow,
                             aDesiredSize.BSize(wm));
          if (firstTruncatedRow) {
            if (aReflowInput.mFlags.mIsTopOfPage) {
              // We were better off with the 1st call to SplitSpanningCells, do
              // it again
              UndoContinuedRow(aPresContext, contRow);
              contRow = nullptr;
              lastRowThisPage = oldLastRowThisPage;
              spanningRowBEnd = oldSpanningRowBEnd;
              SplitSpanningCells(aPresContext, aReflowInput, aTableFrame,
                                 firstRowThisPage, lastRowThisPage,
                                 aReflowInput.mFlags.mIsTopOfPage,
                                 spanningRowBEnd, containerSize, contRow,
                                 firstTruncatedRow, aDesiredSize.BSize(wm));
              NS_WARNING("data loss in a row spanned cell");
            } else {
              // Let our parent reflow us again with more space
              aDesiredSize.BSize(wm) = rowRect.BEnd(wm);
              aStatus.Reset();
              UndoContinuedRow(aPresContext, contRow);
              contRow = nullptr;
            }
          }
        }
      } else {
        aDesiredSize.BSize(wm) = std::max(aDesiredSize.BSize(wm), bMost);
        if (contRow) {
          aStatus.Reset();
          aStatus.SetIncomplete();
        }
      }
      if (aStatus.IsIncomplete() && !contRow) {
        if (nsTableRowFrame* nextRow = lastRowThisPage->GetNextRow()) {
          PushChildrenToOverflow(nextRow, lastRowThisPage);
        }
      } else if (aStatus.IsComplete() && lastRowThisPage) {
        // Our size from the unconstrained reflow exceeded the constrained
        // available space but our size in the constrained reflow is Complete.
        // This can happen when a non-zero block-end margin is suppressed in
        // nsBlockFrame::ComputeFinalSize.
        if (nsTableRowFrame* nextRow = lastRowThisPage->GetNextRow()) {
          aStatus.Reset();
          aStatus.SetIncomplete();
          PushChildrenToOverflow(nextRow, lastRowThisPage);
        }
      }
      break;
    }
    aDesiredSize.BSize(wm) = rowRect.BEnd(wm);
    prevRowFrame = rowFrame;
    // see if there is a page break after the row
    nsTableRowFrame* nextRow = rowFrame->GetNextRow();
    if (nextRow && nsTableFrame::PageBreakAfter(rowFrame, nextRow)) {
      PushChildrenToOverflow(nextRow, rowFrame);
      aStatus.Reset();
      aStatus.SetIncomplete();
      break;
    }
    // After the 1st row that has a block-size, we can't be on top of the page
    // anymore.
    isTopOfPage = isTopOfPage && rowRect.BEnd(wm) == 0;
  }
}

/** Layout the entire row group.
 * This method stacks rows vertically according to HTML 4.0 rules.
 * Rows are responsible for layout of their children.
 */
void nsTableRowGroupFrame::Reflow(nsPresContext* aPresContext,
                                  ReflowOutput& aDesiredSize,
                                  const ReflowInput& aReflowInput,
                                  nsReflowStatus& aStatus) {
  MarkInReflow();
  DO_GLOBAL_REFLOW_COUNT("nsTableRowGroupFrame");
  MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");

  // Row geometry may be going to change so we need to invalidate any row
  // cursor.
  ClearRowCursor();

  // see if a special bsize reflow needs to occur due to having a pct bsize
  nsTableFrame::CheckRequestSpecialBSizeReflow(aReflowInput);

  nsTableFrame* tableFrame = GetTableFrame();
  TableRowGroupReflowInput state(aReflowInput);
  const nsStyleVisibility* groupVis = StyleVisibility();
  bool collapseGroup = StyleVisibility::Collapse == groupVis->mVisible;
  if (collapseGroup) {
    tableFrame->SetNeedToCollapse(true);
  }

  // Check for an overflow list
  MoveOverflowToChildList();

  // Reflow the existing frames.
  bool splitDueToPageBreak = false;
  ReflowChildren(aPresContext, aDesiredSize, state, aStatus,
                 &splitDueToPageBreak);

  // See if all the frames fit. Do not try to split anything if we're
  // not paginated ... we can't split across columns yet.
  WritingMode wm = aReflowInput.GetWritingMode();
  if (aReflowInput.mFlags.mTableIsSplittable &&
      aReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE &&
      (aStatus.IsIncomplete() || splitDueToPageBreak ||
       aDesiredSize.BSize(wm) > aReflowInput.AvailableBSize())) {
    // Nope, find a place to split the row group
    auto& mutableRIFlags = const_cast<ReflowInput::Flags&>(aReflowInput.mFlags);
    const bool savedSpecialBSizeReflow = mutableRIFlags.mSpecialBSizeReflow;
    mutableRIFlags.mSpecialBSizeReflow = false;

    SplitRowGroup(aPresContext, aDesiredSize, aReflowInput, tableFrame, aStatus,
                  splitDueToPageBreak);

    mutableRIFlags.mSpecialBSizeReflow = savedSpecialBSizeReflow;
  }

  // XXXmats The following is just bogus.  We leave it here for now because
  // ReflowChildren should pull up rows from our next-in-flow before returning
  // a Complete status, but doesn't (bug 804888).
  if (GetNextInFlow() && GetNextInFlow()->PrincipalChildList().FirstChild()) {
    aStatus.SetIncomplete();
  }

  SetHasStyleBSize((NS_UNCONSTRAINEDSIZE != aReflowInput.ComputedBSize()) &&
                   (aReflowInput.ComputedBSize() > 0));

  // Just set our isize to what was available.
  // The table will calculate the isize and not use our value.
  aDesiredSize.ISize(wm) = aReflowInput.AvailableISize();

  aDesiredSize.UnionOverflowAreasWithDesiredBounds();

  // If our parent is in initial reflow, it'll handle invalidating our
  // entire overflow rect.
  if (!GetParent()->HasAnyStateBits(NS_FRAME_FIRST_REFLOW) &&
      aDesiredSize.Size(wm) != GetLogicalSize(wm)) {
    InvalidateFrame();
  }

  FinishAndStoreOverflow(&aDesiredSize);

  // Any absolutely-positioned children will get reflowed in
  // nsIFrame::FixupPositionedTableParts in another pass, so propagate our
  // dirtiness to them before our parent clears our dirty bits.
  PushDirtyBitToAbsoluteFrames();
}

bool nsTableRowGroupFrame::ComputeCustomOverflow(
    OverflowAreas& aOverflowAreas) {
  // Row cursor invariants depend on the ink overflow area of the rows,
  // which may have changed, so we need to clear the cursor now.
  ClearRowCursor();
  return nsContainerFrame::ComputeCustomOverflow(aOverflowAreas);
}

/* virtual */
void nsTableRowGroupFrame::DidSetComputedStyle(
    ComputedStyle* aOldComputedStyle) {
  nsContainerFrame::DidSetComputedStyle(aOldComputedStyle);
  nsTableFrame::PositionedTablePartMaybeChanged(this, aOldComputedStyle);

  if (!aOldComputedStyle) {
    return;  // avoid the following on init
  }

  nsTableFrame* tableFrame = GetTableFrame();
  if (tableFrame->IsBorderCollapse() &&
      tableFrame->BCRecalcNeeded(aOldComputedStyle, Style())) {
    TableArea damageArea(0, GetStartRowIndex(), tableFrame->GetColCount(),
                         GetRowCount());
    tableFrame->AddBCDamageArea(damageArea);
  }
}

void nsTableRowGroupFrame::AppendFrames(ChildListID aListID,
                                        nsFrameList&& aFrameList) {
  NS_ASSERTION(aListID == FrameChildListID::Principal, "unexpected child list");

  DrainSelfOverflowList();  // ensure the last frame is in mFrames
  ClearRowCursor();

  // collect the new row frames in an array
  // XXXbz why are we doing the QI stuff?  There shouldn't be any non-rows here.
  AutoTArray<nsTableRowFrame*, 8> rows;
  for (nsIFrame* f : aFrameList) {
    nsTableRowFrame* rowFrame = do_QueryFrame(f);
    NS_ASSERTION(rowFrame, "Unexpected frame; frame constructor screwed up");
    if (rowFrame) {
      NS_ASSERTION(
          mozilla::StyleDisplay::TableRow == f->StyleDisplay()->mDisplay,
          "wrong display type on rowframe");
      rows.AppendElement(rowFrame);
    }
  }

  int32_t rowIndex = GetRowCount();
  // Append the frames to the sibling chain
  mFrames.AppendFrames(nullptr, std::move(aFrameList));

  if (rows.Length() > 0) {
    nsTableFrame* tableFrame = GetTableFrame();
    tableFrame->AppendRows(this, rowIndex, rows);
    PresShell()->FrameNeedsReflow(this, IntrinsicDirty::FrameAndAncestors,
                                  NS_FRAME_HAS_DIRTY_CHILDREN);
    tableFrame->SetGeometryDirty();
  }
}

void nsTableRowGroupFrame::InsertFrames(
    ChildListID aListID, nsIFrame* aPrevFrame,
    const nsLineList::iterator* aPrevFrameLine, nsFrameList&& aFrameList) {
  NS_ASSERTION(aListID == FrameChildListID::Principal, "unexpected child list");
  NS_ASSERTION(!aPrevFrame || aPrevFrame->GetParent() == this,
               "inserting after sibling frame with different parent");

  DrainSelfOverflowList();  // ensure aPrevFrame is in mFrames
  ClearRowCursor();

  // collect the new row frames in an array
  // XXXbz why are we doing the QI stuff?  There shouldn't be any non-rows here.
  nsTableFrame* tableFrame = GetTableFrame();
  nsTArray<nsTableRowFrame*> rows;
  bool gotFirstRow = false;
  for (nsIFrame* f : aFrameList) {
    nsTableRowFrame* rowFrame = do_QueryFrame(f);
    NS_ASSERTION(rowFrame, "Unexpected frame; frame constructor screwed up");
    if (rowFrame) {
      NS_ASSERTION(
          mozilla::StyleDisplay::TableRow == f->StyleDisplay()->mDisplay,
          "wrong display type on rowframe");
      rows.AppendElement(rowFrame);
      if (!gotFirstRow) {
        rowFrame->SetFirstInserted(true);
        gotFirstRow = true;
        tableFrame->SetRowInserted(true);
      }
    }
  }

  int32_t startRowIndex = GetStartRowIndex();
  // Insert the frames in the sibling chain
  mFrames.InsertFrames(nullptr, aPrevFrame, std::move(aFrameList));

  int32_t numRows = rows.Length();
  if (numRows > 0) {
    nsTableRowFrame* prevRow =
        (nsTableRowFrame*)nsTableFrame::GetFrameAtOrBefore(
            this, aPrevFrame, LayoutFrameType::TableRow);
    int32_t rowIndex = (prevRow) ? prevRow->GetRowIndex() + 1 : startRowIndex;
    tableFrame->InsertRows(this, rows, rowIndex, true);

    PresShell()->FrameNeedsReflow(this, IntrinsicDirty::FrameAndAncestors,
                                  NS_FRAME_HAS_DIRTY_CHILDREN);
    tableFrame->SetGeometryDirty();
  }
}

void nsTableRowGroupFrame::RemoveFrame(DestroyContext& aContext,
                                       ChildListID aListID,
                                       nsIFrame* aOldFrame) {
  NS_ASSERTION(aListID == FrameChildListID::Principal, "unexpected child list");

  ClearRowCursor();

  // XXX why are we doing the QI stuff?  There shouldn't be any non-rows here.
  nsTableRowFrame* rowFrame = do_QueryFrame(aOldFrame);
  if (rowFrame) {
    nsTableFrame* tableFrame = GetTableFrame();
    // remove the rows from the table (and flag a rebalance)
    tableFrame->RemoveRows(*rowFrame, 1, true);

    PresShell()->FrameNeedsReflow(this, IntrinsicDirty::FrameAndAncestors,
                                  NS_FRAME_HAS_DIRTY_CHILDREN);
    tableFrame->SetGeometryDirty();
  }
  mFrames.DestroyFrame(aContext, aOldFrame);
}

/* virtual */
nsMargin nsTableRowGroupFrame::GetUsedMargin() const {
  return nsMargin(0, 0, 0, 0);
}

/* virtual */
nsMargin nsTableRowGroupFrame::GetUsedBorder() const {
  return nsMargin(0, 0, 0, 0);
}

/* virtual */
nsMargin nsTableRowGroupFrame::GetUsedPadding() const {
  return nsMargin(0, 0, 0, 0);
}

nscoord nsTableRowGroupFrame::GetBSizeBasis(const ReflowInput& aReflowInput) {
  nscoord result = 0;
  nsTableFrame* tableFrame = GetTableFrame();
  int32_t startRowIndex = GetStartRowIndex();
  if ((aReflowInput.ComputedBSize() > 0) &&
      (aReflowInput.ComputedBSize() < NS_UNCONSTRAINEDSIZE)) {
    nscoord cellSpacing = tableFrame->GetRowSpacing(
        startRowIndex,
        std::max(startRowIndex, startRowIndex + GetRowCount() - 1));
    result = aReflowInput.ComputedBSize() - cellSpacing;
  } else {
    const ReflowInput* parentRI = aReflowInput.mParentReflowInput;
    if (parentRI && (tableFrame != parentRI->mFrame)) {
      parentRI = parentRI->mParentReflowInput;
    }
    if (parentRI && (tableFrame == parentRI->mFrame) &&
        (parentRI->ComputedBSize() > 0) &&
        (parentRI->ComputedBSize() < NS_UNCONSTRAINEDSIZE)) {
      nscoord cellSpacing =
          tableFrame->GetRowSpacing(-1, tableFrame->GetRowCount());
      result = parentRI->ComputedBSize() - cellSpacing;
    }
  }

  return result;
}

bool nsTableRowGroupFrame::IsSimpleRowFrame(nsTableFrame* aTableFrame,
                                            nsTableRowFrame* aRowFrame) {
  int32_t rowIndex = aRowFrame->GetRowIndex();

  // It's a simple row frame if there are no cells that span into or
  // across the row
  int32_t numEffCols = aTableFrame->GetEffectiveColCount();
  if (!aTableFrame->RowIsSpannedInto(rowIndex, numEffCols) &&
      !aTableFrame->RowHasSpanningCells(rowIndex, numEffCols)) {
    return true;
  }

  return false;
}

/** find page break before the first row **/
bool nsTableRowGroupFrame::HasInternalBreakBefore() const {
  nsIFrame* firstChild = mFrames.FirstChild();
  if (!firstChild) {
    return false;
  }
  return firstChild->StyleDisplay()->BreakBefore();
}

/** find page break after the last row **/
bool nsTableRowGroupFrame::HasInternalBreakAfter() const {
  nsIFrame* lastChild = mFrames.LastChild();
  if (!lastChild) {
    return false;
  }
  return lastChild->StyleDisplay()->BreakAfter();
}
/* ----- global methods ----- */

nsTableRowGroupFrame* NS_NewTableRowGroupFrame(PresShell* aPresShell,
                                               ComputedStyle* aStyle) {
  return new (aPresShell)
      nsTableRowGroupFrame(aStyle, aPresShell->GetPresContext());
}

NS_IMPL_FRAMEARENA_HELPERS(nsTableRowGroupFrame)

#ifdef DEBUG_FRAME_DUMP
nsresult nsTableRowGroupFrame::GetFrameName(nsAString& aResult) const {
  return MakeFrameName(u"TableRowGroup"_ns, aResult);
}
#endif

LogicalMargin nsTableRowGroupFrame::GetBCBorderWidth(WritingMode aWM) {
  LogicalMargin border(aWM);
  nsTableRowFrame* firstRowFrame = GetFirstRow();
  if (!firstRowFrame) {
    return border;
  }
  nsTableRowFrame* lastRowFrame = firstRowFrame;
  for (nsTableRowFrame* rowFrame = firstRowFrame->GetNextRow(); rowFrame;
       rowFrame = rowFrame->GetNextRow()) {
    lastRowFrame = rowFrame;
  }
  border.BStart(aWM) = firstRowFrame->GetBStartBCBorderWidth();
  border.BEnd(aWM) = lastRowFrame->GetBEndBCBorderWidth();
  return border;
}

// nsILineIterator methods
int32_t nsTableRowGroupFrame::GetNumLines() const { return GetRowCount(); }

bool nsTableRowGroupFrame::IsLineIteratorFlowRTL() {
  return StyleDirection::Rtl == GetTableFrame()->StyleVisibility()->mDirection;
}

Result<nsILineIterator::LineInfo, nsresult> nsTableRowGroupFrame::GetLine(
    int32_t aLineNumber) {
  if ((aLineNumber < 0) || (aLineNumber >= GetRowCount())) {
    return Err(NS_ERROR_FAILURE);
  }
  LineInfo structure;
  nsTableFrame* table = GetTableFrame();
  nsTableCellMap* cellMap = table->GetCellMap();
  aLineNumber += GetStartRowIndex();

  structure.mNumFramesOnLine =
      cellMap->GetNumCellsOriginatingInRow(aLineNumber);
  if (structure.mNumFramesOnLine == 0) {
    return structure;
  }
  int32_t colCount = table->GetColCount();
  for (int32_t i = 0; i < colCount; i++) {
    CellData* data = cellMap->GetDataAt(aLineNumber, i);
    if (data && data->IsOrig()) {
      structure.mFirstFrameOnLine = (nsIFrame*)data->GetCellFrame();
      nsIFrame* parent = structure.mFirstFrameOnLine->GetParent();
      structure.mLineBounds = parent->GetRect();
      return structure;
    }
  }
  MOZ_ASSERT_UNREACHABLE("cellmap is lying");
  return Err(NS_ERROR_FAILURE);
}

int32_t nsTableRowGroupFrame::FindLineContaining(nsIFrame* aFrame,
                                                 int32_t aStartLine) {
  NS_ENSURE_TRUE(aFrame, -1);

  nsTableRowFrame* rowFrame = do_QueryFrame(aFrame);
  if (MOZ_UNLIKELY(!rowFrame)) {
    // When we do not have valid table structure in the DOM tree, somebody wants
    // to check the line number with an out-of-flow child of this frame because
    // its parent frame is set to this frame.  Otherwise, the caller must have
    // a bug.
    MOZ_ASSERT(aFrame->GetParent() == this);
    MOZ_ASSERT(aFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW));
    return -1;
  }

  int32_t rowIndexInGroup = rowFrame->GetRowIndex() - GetStartRowIndex();

  return rowIndexInGroup >= aStartLine ? rowIndexInGroup : -1;
}

NS_IMETHODIMP
nsTableRowGroupFrame::CheckLineOrder(int32_t aLine, bool* aIsReordered,
                                     nsIFrame** aFirstVisual,
                                     nsIFrame** aLastVisual) {
  *aIsReordered = false;
  *aFirstVisual = nullptr;
  *aLastVisual = nullptr;
  return NS_OK;
}

NS_IMETHODIMP
nsTableRowGroupFrame::FindFrameAt(int32_t aLineNumber, nsPoint aPos,
                                  nsIFrame** aFrameFound,
                                  bool* aPosIsBeforeFirstFrame,
                                  bool* aPosIsAfterLastFrame) {
  nsTableFrame* table = GetTableFrame();
  nsTableCellMap* cellMap = table->GetCellMap();

  *aFrameFound = nullptr;
  *aPosIsBeforeFirstFrame = true;
  *aPosIsAfterLastFrame = false;

  aLineNumber += GetStartRowIndex();
  int32_t numCells = cellMap->GetNumCellsOriginatingInRow(aLineNumber);
  if (numCells == 0) {
    return NS_OK;
  }

  nsIFrame* frame = nullptr;
  int32_t colCount = table->GetColCount();
  for (int32_t i = 0; i < colCount; i++) {
    CellData* data = cellMap->GetDataAt(aLineNumber, i);
    if (data && data->IsOrig()) {
      frame = (nsIFrame*)data->GetCellFrame();
      break;
    }
  }
  NS_ASSERTION(frame, "cellmap is lying");
  bool isRTL = StyleDirection::Rtl == table->StyleVisibility()->mDirection;

  LineFrameFinder finder(aPos, table->GetSize(), table->GetWritingMode(),
                         isRTL);

  int32_t n = numCells;
  while (n--) {
    finder.Scan(frame);
    if (finder.IsDone()) {
      break;
    }
    frame = frame->GetNextSibling();
  }
  finder.Finish(aFrameFound, aPosIsBeforeFirstFrame, aPosIsAfterLastFrame);
  return NS_OK;
}

// end nsLineIterator methods

NS_DECLARE_FRAME_PROPERTY_DELETABLE(RowCursorProperty,
                                    nsTableRowGroupFrame::FrameCursorData)

void nsTableRowGroupFrame::ClearRowCursor() {
  if (!HasAnyStateBits(NS_ROWGROUP_HAS_ROW_CURSOR)) {
    return;
  }

  RemoveStateBits(NS_ROWGROUP_HAS_ROW_CURSOR);
  RemoveProperty(RowCursorProperty());
}

nsTableRowGroupFrame::FrameCursorData* nsTableRowGroupFrame::SetupRowCursor() {
  if (HasAnyStateBits(NS_ROWGROUP_HAS_ROW_CURSOR)) {
    // We already have a valid row cursor. Don't waste time rebuilding it.
    return nullptr;
  }

  nsIFrame* f = mFrames.FirstChild();
  int32_t count;
  for (count = 0; f && count < MIN_ROWS_NEEDING_CURSOR; ++count) {
    f = f->GetNextSibling();
  }
  if (!f) {
    // Less than MIN_ROWS_NEEDING_CURSOR rows, so just don't bother
    return nullptr;
  }

  FrameCursorData* data = new FrameCursorData();
  SetProperty(RowCursorProperty(), data);
  AddStateBits(NS_ROWGROUP_HAS_ROW_CURSOR);
  return data;
}

nsIFrame* nsTableRowGroupFrame::GetFirstRowContaining(nscoord aY,
                                                      nscoord* aOverflowAbove) {
  if (!HasAnyStateBits(NS_ROWGROUP_HAS_ROW_CURSOR)) {
    return nullptr;
  }

  FrameCursorData* property = GetProperty(RowCursorProperty());
  uint32_t cursorIndex = property->mCursorIndex;
  uint32_t frameCount = property->mFrames.Length();
  if (cursorIndex >= frameCount) {
    return nullptr;
  }
  nsIFrame* cursorFrame = property->mFrames[cursorIndex];

  // The cursor's frame list excludes frames with empty overflow-area, so
  // we don't need to check that here.

  // We use property->mOverflowBelow here instead of computing the frame's
  // true overflowArea.YMost(), because it is essential for the thresholds
  // to form a monotonically increasing sequence. Otherwise we would break
  // encountering a row whose overflowArea.YMost() is <= aY but which has
  // a row above it containing cell(s) that span to include aY.
  while (cursorIndex > 0 &&
         cursorFrame->GetRect().YMost() + property->mOverflowBelow > aY) {
    --cursorIndex;
    cursorFrame = property->mFrames[cursorIndex];
  }
  while (cursorIndex + 1 < frameCount &&
         cursorFrame->GetRect().YMost() + property->mOverflowBelow <= aY) {
    ++cursorIndex;
    cursorFrame = property->mFrames[cursorIndex];
  }

  property->mCursorIndex = cursorIndex;
  *aOverflowAbove = property->mOverflowAbove;
  return cursorFrame;
}

bool nsTableRowGroupFrame::FrameCursorData::AppendFrame(nsIFrame* aFrame) {
  // The cursor requires a monotonically increasing sequence in order to
  // identify which rows can be skipped, and position:relative can move
  // rows around such that the overflow areas don't provide this.
  // We take the union of the overflow rect, and the frame's 'normal' position
  // (excluding position:relative changes) and record the max difference between
  // this combined overflow and the frame's rect.
  nsRect positionedOverflowRect = aFrame->InkOverflowRect();
  nsPoint positionedToNormal =
      aFrame->GetNormalPosition() - aFrame->GetPosition();
  nsRect normalOverflowRect = positionedOverflowRect + positionedToNormal;

  nsRect overflowRect = positionedOverflowRect.Union(normalOverflowRect);
  if (overflowRect.IsEmpty()) {
    return true;
  }
  nscoord overflowAbove = -overflowRect.y;
  nscoord overflowBelow = overflowRect.YMost() - aFrame->GetSize().height;
  mOverflowAbove = std::max(mOverflowAbove, overflowAbove);
  mOverflowBelow = std::max(mOverflowBelow, overflowBelow);
  // XXX(Bug 1631371) Check if this should use a fallible operation as it
  // pretended earlier, or change the return type to void.
  mFrames.AppendElement(aFrame);
  return true;
}

void nsTableRowGroupFrame::InvalidateFrame(uint32_t aDisplayItemKey,
                                           bool aRebuildDisplayItems) {
  nsIFrame::InvalidateFrame(aDisplayItemKey, aRebuildDisplayItems);
  if (GetTableFrame()->IsBorderCollapse()) {
    const bool rebuild = StaticPrefs::layout_display_list_retain_sc();
    GetParent()->InvalidateFrameWithRect(InkOverflowRect() + GetPosition(),
                                         aDisplayItemKey, rebuild);
  }
}

void nsTableRowGroupFrame::InvalidateFrameWithRect(const nsRect& aRect,
                                                   uint32_t aDisplayItemKey,
                                                   bool aRebuildDisplayItems) {
  nsIFrame::InvalidateFrameWithRect(aRect, aDisplayItemKey,
                                    aRebuildDisplayItems);
  // If we have filters applied that would affects our bounds, then
  // we get an inactive layer created and this is computed
  // within FrameLayerBuilder
  GetParent()->InvalidateFrameWithRect(aRect + GetPosition(), aDisplayItemKey,
                                       aRebuildDisplayItems);
}