--- a/layout/tables/nsTableFrame.cpp
+++ b/layout/tables/nsTableFrame.cpp
@@ -48,42 +48,42 @@
 #include "RestyleTracker.h"
 #include <algorithm>
 
 using namespace mozilla;
 using namespace mozilla::image;
 using namespace mozilla::layout;
 
 /********************************************************************************
- ** nsTableReflowState                                                         **
+ ** TableReflowInput                                                         **
  ********************************************************************************/
 
 namespace mozilla {
 
-struct nsTableReflowState {
+struct TableReflowInput {
 
   // the real reflow state
   const ReflowInput& reflowState;
 
   // The table's available size (in reflowState's writing mode)
   LogicalSize availSize;
 
   // Stationary inline-offset
   nscoord iCoord;
 
   // Running block-offset
   nscoord bCoord;
 
-  nsTableReflowState(const ReflowInput& aReflowState,
+  TableReflowInput(const ReflowInput& aReflowState,
                      const LogicalSize& aAvailSize)
     : reflowState(aReflowState)
     , availSize(aAvailSize)
   {
     MOZ_ASSERT(reflowState.frame->GetType() == nsGkAtoms::tableFrame,
-               "nsTableReflowState should only be created for nsTableFrame");
+               "TableReflowInput should only be created for nsTableFrame");
     nsTableFrame* table =
       static_cast<nsTableFrame*>(reflowState.frame->FirstInFlow());
     WritingMode wm = aReflowState.GetWritingMode();
     LogicalMargin borderPadding = table->GetChildAreaOffset(wm, &reflowState);
 
     iCoord = borderPadding.IStart(wm) + table->GetColSpacing(-1);
     bCoord = borderPadding.BStart(wm); //cellspacing added during reflow
 
@@ -2081,17 +2081,17 @@ nsTableFrame::ReflowTable(nsHTMLReflowMe
   if (!GetPrevInFlow()) {
     mTableLayoutStrategy->ComputeColumnISizes(aReflowState);
   }
   // Constrain our reflow isize to the computed table isize (of the 1st in flow).
   // and our reflow bsize to our avail bsize minus border, padding, cellspacing
   WritingMode wm = aReflowState.GetWritingMode();
   aDesiredSize.ISize(wm) = aReflowState.ComputedISize() +
                      aReflowState.ComputedLogicalBorderPadding().IStartEnd(wm);
-  nsTableReflowState reflowState(aReflowState,
+  TableReflowInput reflowState(aReflowState,
                                  LogicalSize(wm, aDesiredSize.ISize(wm),
                                              aAvailBSize));
   ReflowChildren(reflowState, aStatus, aLastChildReflowed,
                  aDesiredSize.mOverflowAreas);
 
   ReflowColGroups(aReflowState.rendContext);
 }
 
@@ -2765,17 +2765,17 @@ nsTableFrame::InitChildReflowState(Reflo
   if (mBits.mResizedColumns) {
     aReflowState.SetIResize(true);
   }
 }
 
 // Position and size aKidFrame and update our reflow state. The origin of
 // aKidRect is relative to the upper-left origin of our frame
 void
-nsTableFrame::PlaceChild(nsTableReflowState&  aReflowState,
+nsTableFrame::PlaceChild(TableReflowInput&  aReflowState,
                          nsIFrame*            aKidFrame,
                          nsPoint              aKidPosition,
                          nsHTMLReflowMetrics& aKidDesiredSize,
                          const nsRect&        aOriginalKidRect,
                          const nsRect&        aOriginalKidVisualOverflow)
 {
   WritingMode wm = aReflowState.reflowState.GetWritingMode();
   bool isFirstReflow =
@@ -2909,17 +2909,17 @@ nsTableFrame::GetTFoot() const
 
 static bool
 IsRepeatable(nscoord aFrameHeight, nscoord aPageHeight)
 {
   return aFrameHeight < (aPageHeight / 4);
 }
 
 nsresult
-nsTableFrame::SetupHeaderFooterChild(const nsTableReflowState& aReflowState,
+nsTableFrame::SetupHeaderFooterChild(const TableReflowInput& aReflowState,
                                      nsTableRowGroupFrame* aFrame,
                                      nscoord* aDesiredHeight)
 {
   nsPresContext* presContext = PresContext();
   nscoord pageHeight = presContext->GetPageSize().height;
 
   // Reflow the child with unconstrained height
   WritingMode wm = aFrame->GetWritingMode();
@@ -2943,17 +2943,17 @@ nsTableFrame::SetupHeaderFooterChild(con
   // The child will be reflowed again "for real" so no need to place it now
 
   aFrame->SetRepeatable(IsRepeatable(desiredSize.Height(), pageHeight));
   *aDesiredHeight = desiredSize.Height();
   return NS_OK;
 }
 
 void
-nsTableFrame::PlaceRepeatedFooter(nsTableReflowState& aReflowState,
+nsTableFrame::PlaceRepeatedFooter(TableReflowInput& aReflowState,
                                   nsTableRowGroupFrame *aTfoot,
                                   nscoord aFooterHeight)
 {
   nsPresContext* presContext = PresContext();
   WritingMode wm = aTfoot->GetWritingMode();
   LogicalSize kidAvailSize = aReflowState.availSize;
 
   nsSize containerSize = kidAvailSize.GetPhysicalSize(wm);
@@ -2987,17 +2987,17 @@ nsTableFrame::PlaceRepeatedFooter(nsTabl
              kidPosition.GetPhysicalPoint(wm, containerSize -
                                               desiredSize.PhysicalSize()),
              desiredSize, origTfootRect, origTfootVisualOverflow);
 }
 
 // Reflow the children based on the avail size and reason in aReflowState
 // update aReflowMetrics a aStatus
 void
-nsTableFrame::ReflowChildren(nsTableReflowState& aReflowState,
+nsTableFrame::ReflowChildren(TableReflowInput& aReflowState,
                              nsReflowStatus&     aStatus,
                              nsIFrame*&          aLastChildReflowed,
                              nsOverflowAreas&    aOverflowAreas)
 {
   aStatus = NS_FRAME_COMPLETE;
   aLastChildReflowed = nullptr;
 
   nsIFrame* prevKidFrame = nullptr;

--- a/layout/tables/nsTableFrame.h
+++ b/layout/tables/nsTableFrame.h
@@ -23,17 +23,17 @@ class nsTableColFrame;
 class nsTableRowGroupFrame;
 class nsTableRowFrame;
 class nsTableColGroupFrame;
 class nsITableLayoutStrategy;
 class nsStyleContext;
 namespace mozilla {
 class WritingMode;
 class LogicalMargin;
-struct nsTableReflowState;
+struct TableReflowInput;
 } // namespace mozilla
 
 struct BCPropertyData;
 
 static inline bool IS_TABLE_CELL(nsIAtom* frameType) {
   return nsGkAtoms::tableCellFrame == frameType ||
     nsGkAtoms::bcTableCellFrame == frameType;
 }
@@ -127,17 +127,17 @@ enum nsTableColType {
   * The principal child list contains row group frames. There is also an
   * additional child list, kColGroupList, which contains the col group frames.
   */
 class nsTableFrame : public nsContainerFrame
 {
   typedef mozilla::image::DrawResult DrawResult;
   typedef mozilla::WritingMode WritingMode;
   typedef mozilla::LogicalMargin LogicalMargin;
-  typedef mozilla::nsTableReflowState nsTableReflowState;
+  typedef mozilla::TableReflowInput TableReflowInput;
 
 public:
   NS_DECL_QUERYFRAME_TARGET(nsTableFrame)
   NS_DECL_FRAMEARENA_HELPERS
 
   typedef nsTArray<nsIFrame*> FrameTArray;
   NS_DECLARE_FRAME_PROPERTY_DELETABLE(PositionedTablePartArray, FrameTArray)
 
@@ -622,21 +622,21 @@ public:
   bool IsRowInserted() const;
   void   SetRowInserted(bool aValue);
 
 protected:
 
   // A helper function to reflow a header or footer with unconstrained height
   // to see if it should be made repeatable and also to determine its desired
   // height.
-  nsresult SetupHeaderFooterChild(const nsTableReflowState& aReflowState,
+  nsresult SetupHeaderFooterChild(const TableReflowInput& aReflowState,
                                   nsTableRowGroupFrame* aFrame,
                                   nscoord* aDesiredHeight);
 
-  void ReflowChildren(nsTableReflowState&  aReflowState,
+  void ReflowChildren(TableReflowInput&  aReflowState,
                       nsReflowStatus&      aStatus,
                       nsIFrame*&           aLastChildReflowed,
                       nsOverflowAreas&     aOverflowAreas);
 
   // This calls the col group and column reflow methods, which do two things:
   //  (1) set all the dimensions to 0
   //  (2) notify the table about colgroups or columns with hidden visibility
   void ReflowColGroups(nsRenderingContext* aRenderingContext);
@@ -700,23 +700,23 @@ protected:
   void CalcDesiredBSize(const ReflowInput& aReflowState,
                         nsHTMLReflowMetrics& aDesiredSize);
 
   // The following is a helper for CalcDesiredBSize
 
   void DistributeBSizeToRows(const ReflowInput& aReflowState,
                              nscoord                  aAmount);
 
-  void PlaceChild(nsTableReflowState&  aReflowState,
+  void PlaceChild(TableReflowInput&  aReflowState,
                   nsIFrame*            aKidFrame,
                   nsPoint              aKidPosition,
                   nsHTMLReflowMetrics& aKidDesiredSize,
                   const nsRect&        aOriginalKidRect,
                   const nsRect&        aOriginalKidVisualOverflow);
-   void PlaceRepeatedFooter(nsTableReflowState& aReflowState,
+   void PlaceRepeatedFooter(TableReflowInput& aReflowState,
                             nsTableRowGroupFrame *aTfoot,
                             nscoord aFooterHeight);
 
   nsIFrame* GetFirstBodyRowGroupFrame();
 public:
   typedef AutoTArray<nsTableRowGroupFrame*, 8> RowGroupArray;
   /**
    * Push all our child frames from the aRowGroups array, in order, starting

--- a/layout/tables/nsTableRowFrame.cpp
+++ b/layout/tables/nsTableRowFrame.cpp
@@ -23,34 +23,34 @@
 #include "nsDisplayList.h"
 #include "nsIFrameInlines.h"
 #include <algorithm>
 
 using namespace mozilla;
 
 namespace mozilla {
 
-struct nsTableCellReflowState : public ReflowInput
+struct TableCellReflowInput : public ReflowInput
 {
-  nsTableCellReflowState(nsPresContext*           aPresContext,
+  TableCellReflowInput(nsPresContext*           aPresContext,
                          const ReflowInput& aParentReflowState,
                          nsIFrame*                aFrame,
                          const LogicalSize&       aAvailableSpace,
                          uint32_t                 aFlags = 0)
     : ReflowInput(aPresContext, aParentReflowState, aFrame,
                         aAvailableSpace, nullptr, aFlags)
   {
   }
 
   void FixUp(const LogicalSize& aAvailSpace);
 };
 
 } // namespace mozilla
 
-void nsTableCellReflowState::FixUp(const LogicalSize& aAvailSpace)
+void TableCellReflowInput::FixUp(const LogicalSize& aAvailSpace)
 {
   // fix the mComputed values during a pass 2 reflow since the cell can be a percentage base
   NS_WARN_IF_FALSE(NS_UNCONSTRAINEDSIZE != aAvailSpace.ISize(mWritingMode),
                    "have unconstrained inline-size; this should only result from "
                    "very large sizes, not attempts at intrinsic inline size "
                    "calculation");
   if (NS_UNCONSTRAINEDSIZE != ComputedISize()) {
     nscoord computedISize = aAvailSpace.ISize(mWritingMode) -
@@ -66,17 +66,17 @@ void nsTableCellReflowState::FixUp(const
     SetComputedBSize(computedBSize);
   }
 }
 
 void
 nsTableRowFrame::InitChildReflowState(nsPresContext&          aPresContext,
                                       const LogicalSize&      aAvailSize,
                                       bool                    aBorderCollapse,
-                                      nsTableCellReflowState& aReflowState)
+                                      TableCellReflowInput& aReflowState)
 {
   nsMargin collapseBorder;
   nsMargin* pCollapseBorder = nullptr;
   if (aBorderCollapse) {
     // we only reflow cells, so don't need to check frame type
     nsBCTableCellFrame* bcCellFrame = (nsBCTableCellFrame*)aReflowState.frame;
     if (bcCellFrame) {
       WritingMode wm = GetWritingMode();
@@ -812,17 +812,17 @@ nsTableRowFrame::ReflowChildren(nsPresCo
 
   for (nsIFrame* kidFrame : mFrames) {
     nsTableCellFrame *cellFrame = do_QueryFrame(kidFrame);
     if (!cellFrame) {
       // XXXldb nsCSSFrameConstructor needs to enforce this!
       NS_NOTREACHED("yikes, a non-row child");
 
       // it's an unknown frame type, give it a generic reflow and ignore the results
-      nsTableCellReflowState
+      TableCellReflowInput
         kidReflowState(aPresContext, aReflowState, kidFrame,
                        LogicalSize(kidFrame->GetWritingMode(), 0, 0),
                        ReflowInput::CALLER_WILL_INIT);
       InitChildReflowState(*aPresContext, LogicalSize(wm), false, kidReflowState);
       nsHTMLReflowMetrics desiredSize(aReflowState);
       nsReflowStatus  status;
       ReflowChild(kidFrame, aPresContext, desiredSize, kidReflowState, 0, 0, 0, status);
       kidFrame->DidReflow(aPresContext, nullptr, nsDidReflowStatus::FINISHED);
@@ -881,17 +881,17 @@ nsTableRowFrame::ReflowChildren(nsPresCo
     LogicalPoint kidPosition(wm, iCoord, 0);
     bool firstReflow = kidFrame->HasAnyStateBits(NS_FRAME_FIRST_REFLOW);
 
     if (doReflowChild) {
       // Calculate the available isize for the table cell using the known
       // column isizes
       nscoord availCellISize = CalcAvailISize(aTableFrame, *cellFrame);
 
-      Maybe<nsTableCellReflowState> kidReflowState;
+      Maybe<TableCellReflowInput> kidReflowState;
       nsHTMLReflowMetrics desiredSize(aReflowState);
 
       // If the avail isize is not the same as last time we reflowed the cell or
       // the cell wants to be bigger than what was available last time or
       // it is a style change reflow or we are printing, then we must reflow the
       // cell. Otherwise we can skip the reflow.
       // XXXldb Why is this condition distinct from doReflowChild above?
       WritingMode wm = aReflowState.GetWritingMode();
@@ -1149,17 +1149,17 @@ nsTableRowFrame::ReflowCellFrame(nsPresC
   LogicalRect cellRect = aCellFrame->GetLogicalRect(wm, containerSize);
   nsRect cellVisualOverflow = aCellFrame->GetVisualOverflowRect();
 
   LogicalSize cellSize = cellRect.Size(wm);
   LogicalSize availSize(wm, cellRect.ISize(wm), aAvailableBSize);
   bool borderCollapse = GetTableFrame()->IsBorderCollapse();
   NS_ASSERTION(aCellFrame->GetWritingMode() == wm,
                "expected consistent writing-mode within table");
-  nsTableCellReflowState
+  TableCellReflowInput
     cellReflowState(aPresContext, aReflowState, aCellFrame, availSize,
                     ReflowInput::CALLER_WILL_INIT);
   InitChildReflowState(*aPresContext, availSize, borderCollapse, cellReflowState);
   cellReflowState.mFlags.mIsTopOfPage = aIsTopOfPage;
 
   nsHTMLReflowMetrics desiredSize(aReflowState);
 
   ReflowChild(aCellFrame, aPresContext, desiredSize, cellReflowState,

--- a/layout/tables/nsTableRowFrame.h
+++ b/layout/tables/nsTableRowFrame.h
@@ -9,32 +9,32 @@
 #include "nscore.h"
 #include "nsContainerFrame.h"
 #include "nsTablePainter.h"
 #include "nsTableRowGroupFrame.h"
 #include "mozilla/WritingModes.h"
 
 class  nsTableCellFrame;
 namespace mozilla {
-struct nsTableCellReflowState;
+struct TableCellReflowInput;
 } // namespace mozilla
 
 /**
  * nsTableRowFrame is the frame that maps table rows 
  * (HTML tag TR). This class cannot be reused
  * outside of an nsTableRowGroupFrame.  It assumes that its parent is an nsTableRowGroupFrame,  
  * and its children are nsTableCellFrames.
  * 
  * @see nsTableFrame
  * @see nsTableRowGroupFrame
  * @see nsTableCellFrame
  */
 class nsTableRowFrame : public nsContainerFrame
 {
-  using nsTableCellReflowState = mozilla::nsTableCellReflowState;
+  using TableCellReflowInput = mozilla::TableCellReflowInput;
 
 public:
   NS_DECL_QUERYFRAME_TARGET(nsTableRowFrame)
   NS_DECL_QUERYFRAME
   NS_DECL_FRAMEARENA_HELPERS
 
   virtual ~nsTableRowFrame();
 
@@ -260,17 +260,17 @@ protected:
   /** protected constructor.
     * @see NewFrame
     */
   explicit nsTableRowFrame(nsStyleContext *aContext);
 
   void InitChildReflowState(nsPresContext&              aPresContext,
                             const mozilla::LogicalSize& aAvailSize,
                             bool                        aBorderCollapse,
-                            nsTableCellReflowState&     aReflowState);
+                            TableCellReflowInput&     aReflowState);
   
   virtual LogicalSides GetLogicalSkipSides(const ReflowInput* aReflowState = nullptr) const override;
 
   // row-specific methods
 
   nscoord ComputeCellXOffset(const ReflowInput& aState,
                              nsIFrame*                aKidFrame,
                              const nsMargin&          aKidMargin) const;

--- a/layout/tables/nsTableRowGroupFrame.cpp
+++ b/layout/tables/nsTableRowGroupFrame.cpp
@@ -21,39 +21,39 @@
 #include "nsCellMap.h"//table cell navigation
 #include <algorithm>
 
 using namespace mozilla;
 using namespace mozilla::layout;
 
 namespace mozilla {
 
-struct nsRowGroupReflowState {
+struct TableRowGroupReflowInput {
   const ReflowInput& reflowState;  // Our reflow state
 
   nsTableFrame* tableFrame;
 
   // The available size (computed from the parent)
   mozilla::LogicalSize availSize;
 
   // Running block-offset
   nscoord bCoord;
 
-  nsRowGroupReflowState(const ReflowInput& aReflowState,
+  TableRowGroupReflowInput(const ReflowInput& aReflowState,
                         nsTableFrame*            aTableFrame)
       : reflowState(aReflowState)
       , tableFrame(aTableFrame)
       , availSize(aReflowState.GetWritingMode(),
                   aReflowState.AvailableISize(),
                   aReflowState.AvailableBSize())
       , bCoord(0)
   {
   }
 
-  ~nsRowGroupReflowState() {}
+  ~TableRowGroupReflowInput() {}
 };
 
 } // namespace mozilla
 
 nsTableRowGroupFrame::nsTableRowGroupFrame(nsStyleContext* aContext):
   nsContainerFrame(aContext)
 {
   SetRepeatable(false);
@@ -280,17 +280,17 @@ nsTableRowGroupFrame::GetLogicalSkipSide
     skip |= eLogicalSideBitsBEnd;
   }
   return skip;
 }
 
 // Position and size aKidFrame and update our reflow state.
 void
 nsTableRowGroupFrame::PlaceChild(nsPresContext*         aPresContext,
-                                 nsRowGroupReflowState& aReflowState,
+                                 TableRowGroupReflowInput& aReflowState,
                                  nsIFrame*              aKidFrame,
                                  WritingMode            aWM,
                                  const LogicalPoint&    aKidPosition,
                                  const nsSize&          aContainerSize,
                                  nsHTMLReflowMetrics&   aDesiredSize,
                                  const nsRect&          aOriginalKidRect,
                                  const nsRect&          aOriginalKidVisualOverflow)
 {
@@ -343,17 +343,17 @@ CacheRowBSizesForPrinting(nsPresContext*
       row->SetUnpaginatedBSize(aPresContext, row->BSize(aWM));
     }
   }
 }
 
 void
 nsTableRowGroupFrame::ReflowChildren(nsPresContext*         aPresContext,
                                      nsHTMLReflowMetrics&   aDesiredSize,
-                                     nsRowGroupReflowState& aReflowState,
+                                     TableRowGroupReflowInput& aReflowState,
                                      nsReflowStatus&        aStatus,
                                      bool*                aPageBreakBeforeEnd)
 {
   if (aPageBreakBeforeEnd) {
     *aPageBreakBeforeEnd = false;
   }
 
   WritingMode wm = aReflowState.reflowState.GetWritingMode();
@@ -909,17 +909,17 @@ nsTableRowGroupFrame::CollapseRowGroupIf
   nsTableFrame::InvalidateTableFrame(this, oldGroupRect, oldGroupVisualOverflow,
                                      false);
 
   return bGroupOffset;
 }
 
 // Move a child that was skipped during a reflow.
 void
-nsTableRowGroupFrame::SlideChild(nsRowGroupReflowState& aReflowState,
+nsTableRowGroupFrame::SlideChild(TableRowGroupReflowInput& aReflowState,
                                  nsIFrame*              aKidFrame)
 {
   // Move the frame if we need to.
   WritingMode wm = aReflowState.reflowState.GetWritingMode();
   const nsSize containerSize =
     aReflowState.reflowState.ComputedSizeAsContainerIfConstrained();
   LogicalPoint oldPosition =
     aKidFrame->GetLogicalNormalPosition(wm, containerSize);
@@ -1355,17 +1355,17 @@ nsTableRowGroupFrame::Reflow(nsPresConte
 
   // 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(aReflowState);
 
   nsTableFrame* tableFrame = GetTableFrame();
-  nsRowGroupReflowState state(aReflowState, tableFrame);
+  TableRowGroupReflowInput state(aReflowState, tableFrame);
   const nsStyleVisibility* groupVis = StyleVisibility();
   bool collapseGroup = (NS_STYLE_VISIBILITY_COLLAPSE == groupVis->mVisible);
   if (collapseGroup) {
     tableFrame->SetNeedToCollapse(true);
   }
 
   // Check for an overflow list
   MoveOverflowToChildList();

--- a/layout/tables/nsTableRowGroupFrame.h
+++ b/layout/tables/nsTableRowGroupFrame.h
@@ -12,17 +12,17 @@
 #include "nsILineIterator.h"
 #include "nsTablePainter.h"
 #include "nsTArray.h"
 #include "nsTableFrame.h"
 #include "mozilla/WritingModes.h"
 
 class nsTableRowFrame;
 namespace mozilla {
-struct nsRowGroupReflowState;
+struct TableRowGroupReflowInput;
 } // namespace mozilla
 
 #define MIN_ROWS_NEEDING_CURSOR 20
 
 /**
  * nsTableRowGroupFrame is the frame that maps row groups
  * (HTML tags THEAD, TFOOT, and TBODY). This class cannot be reused
  * outside of an nsTableFrame.  It assumes that its parent is an nsTableFrame, and
@@ -30,17 +30,17 @@ struct nsRowGroupReflowState;
  *
  * @see nsTableFrame
  * @see nsTableRowFrame
  */
 class nsTableRowGroupFrame final
   : public nsContainerFrame
   , public nsILineIterator
 {
-  using nsRowGroupReflowState = mozilla::nsRowGroupReflowState;
+  using TableRowGroupReflowInput = mozilla::TableRowGroupReflowInput;
 
 public:
   NS_DECL_QUERYFRAME_TARGET(nsTableRowGroupFrame)
   NS_DECL_QUERYFRAME
   NS_DECL_FRAMEARENA_HELPERS
 
   /** instantiate a new instance of nsTableRowFrame.
     * @param aPresShell the pres shell for this frame
@@ -325,43 +325,43 @@ protected:
 
   void InitChildReflowState(nsPresContext&     aPresContext,
                             bool               aBorderCollapse,
                             ReflowInput& aReflowState);
 
   virtual LogicalSides GetLogicalSkipSides(const ReflowInput* aReflowState = nullptr) const override;
 
   void PlaceChild(nsPresContext*         aPresContext,
-                  nsRowGroupReflowState& aReflowState,
+                  TableRowGroupReflowInput& aReflowState,
                   nsIFrame*              aKidFrame,
                   mozilla::WritingMode   aWM,
                   const mozilla::LogicalPoint& aKidPosition,
                   const nsSize&          aContainerSize,
                   nsHTMLReflowMetrics&   aDesiredSize,
                   const nsRect&          aOriginalKidRect,
                   const nsRect&          aOriginalKidVisualOverflow);
 
   void CalculateRowBSizes(nsPresContext*           aPresContext,
                           nsHTMLReflowMetrics&     aDesiredSize,
                           const ReflowInput& aReflowState);
 
   void DidResizeRows(nsHTMLReflowMetrics& aDesiredSize);
 
-  void SlideChild(nsRowGroupReflowState& aReflowState,
+  void SlideChild(TableRowGroupReflowInput& aReflowState,
                   nsIFrame*              aKidFrame);
 
   /**
    * Reflow the frames we've already created
    *
    * @param   aPresContext presentation context to use
    * @param   aReflowState current inline state
    */
   void ReflowChildren(nsPresContext*         aPresContext,
                       nsHTMLReflowMetrics&   aDesiredSize,
-                      nsRowGroupReflowState& aReflowState,
+                      TableRowGroupReflowInput& aReflowState,
                       nsReflowStatus&        aStatus,
                       bool*                aPageBreakBeforeEnd = nullptr);
 
   nsresult SplitRowGroup(nsPresContext*           aPresContext,
                          nsHTMLReflowMetrics&     aDesiredSize,
                          const ReflowInput& aReflowState,
                          nsTableFrame*            aTableFrame,
                          nsReflowStatus&          aStatus,