Bug 1277129 Part 3b - Rename nsTableReflowState, nsRowGroupReflowState, and nsTableCellReflowState. r=dbaron
authorTing-Yu Lin <tlin@mozilla.com>
Thu, 21 Jul 2016 18:36:36 +0800
changeset 346099 63e083e58002523052fb230dfe974ed8689cc73d
parent 346098 64eb9c0b65c78c59609f6aaffb0f02148ff6b037
child 346100 5264e630fc3f0839182ec4e56d318750cec011e2
push id6389
push userraliiev@mozilla.com
push dateMon, 19 Sep 2016 13:38:22 +0000
treeherdermozilla-beta@01d67bfe6c81 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersdbaron
bugs1277129
milestone50.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1277129 Part 3b - Rename nsTableReflowState, nsRowGroupReflowState, and nsTableCellReflowState. r=dbaron This patch is generated by the following script: function rename() { find .\ -type f\ ! -path "./obj*"\ ! -path "./.git"\ ! -path "./.hg"\ \( -name "*.cpp" -or\ -name "*.h" \)\ -exec sed -i -e "s/$1/$2/g" "{}" \; } rename nsTableReflowState TableReflowInput rename nsRowGroupReflowState TableRowGroupReflowInput rename nsTableCellReflowState TableCellReflowInput MozReview-Commit-ID: HN2E6utaxL8
layout/tables/nsTableFrame.cpp
layout/tables/nsTableFrame.h
layout/tables/nsTableRowFrame.cpp
layout/tables/nsTableRowFrame.h
layout/tables/nsTableRowGroupFrame.cpp
layout/tables/nsTableRowGroupFrame.h
--- 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,