--- a/layout/generic/ReflowInput.cpp
+++ b/layout/generic/ReflowInput.cpp
@@ -1870,18 +1870,18 @@ GetBlockMarginBorderPadding(const Reflow
  * When we encounter scrolledContent block frames, we skip over them,
  * since they are guaranteed to not be useful for computing the containing block.
  *
  * See also IsQuirkContainingBlockHeight.
  */
 static nscoord
 CalcQuirkContainingBlockHeight(const ReflowInput* aCBReflowInput)
 {
-  const ReflowInput* firstAncestorRS = nullptr; // a candidate for html frame
-  const ReflowInput* secondAncestorRS = nullptr; // a candidate for body frame
+  const ReflowInput* firstAncestorRI = nullptr; // a candidate for html frame
+  const ReflowInput* secondAncestorRI = nullptr; // a candidate for body frame
   
   // initialize the default to NS_AUTOHEIGHT as this is the containings block
   // computed height when this function is called. It is possible that we 
   // don't alter this height especially if we are restricted to one level
   nscoord result = NS_AUTOHEIGHT; 
                              
   const ReflowInput* rs = aCBReflowInput;
   for (; rs; rs = rs->mParentReflowInput) {
@@ -1889,18 +1889,18 @@ CalcQuirkContainingBlockHeight(const Ref
     // if the ancestor is auto height then skip it and continue up if it 
     // is the first block frame and possibly the body/html
     if (nsGkAtoms::blockFrame == frameType ||
 #ifdef MOZ_XUL
         nsGkAtoms::XULLabelFrame == frameType ||
 #endif
         nsGkAtoms::scrollFrame == frameType) {
 
-      secondAncestorRS = firstAncestorRS;
-      firstAncestorRS = rs;
+      secondAncestorRI = firstAncestorRI;
+      firstAncestorRI = rs;
 
       // If the current frame we're looking at is positioned, we don't want to
       // go any further (see bug 221784).  The behavior we want here is: 1) If
       // not auto-height, use this as the percentage base.  2) If auto-height,
       // keep looking, unless the frame is positioned.
       if (NS_AUTOHEIGHT == rs->ComputedHeight()) {
         if (rs->mFrame->IsAbsolutelyPositioned()) {
           break;
@@ -1929,110 +1929,110 @@ CalcQuirkContainingBlockHeight(const Ref
     // if unconstrained - don't sutract borders - would result in huge height
     if (NS_AUTOHEIGHT == result) return result;
 
     // if we got to the canvas or page content frame, then subtract out 
     // margin/border/padding for the BODY and HTML elements
     if ((nsGkAtoms::canvasFrame == frameType) || 
         (nsGkAtoms::pageContentFrame == frameType)) {
 
-      result -= GetBlockMarginBorderPadding(firstAncestorRS);
-      result -= GetBlockMarginBorderPadding(secondAncestorRS);
+      result -= GetBlockMarginBorderPadding(firstAncestorRI);
+      result -= GetBlockMarginBorderPadding(secondAncestorRI);
 
 #ifdef DEBUG
       // make sure the first ancestor is the HTML and the second is the BODY
-      if (firstAncestorRS) {
-        nsIContent* frameContent = firstAncestorRS->mFrame->GetContent();
+      if (firstAncestorRI) {
+        nsIContent* frameContent = firstAncestorRI->mFrame->GetContent();
         if (frameContent) {
           NS_ASSERTION(frameContent->IsHTMLElement(nsGkAtoms::html),
                        "First ancestor is not HTML");
         }
       }
-      if (secondAncestorRS) {
-        nsIContent* frameContent = secondAncestorRS->mFrame->GetContent();
+      if (secondAncestorRI) {
+        nsIContent* frameContent = secondAncestorRI->mFrame->GetContent();
         if (frameContent) {
           NS_ASSERTION(frameContent->IsHTMLElement(nsGkAtoms::body),
                        "Second ancestor is not BODY");
         }
       }
 #endif
       
     }
     // if we got to the html frame (a block child of the canvas) ...
     else if (nsGkAtoms::blockFrame == frameType &&
              rs->mParentReflowInput &&
              nsGkAtoms::canvasFrame ==
                rs->mParentReflowInput->mFrame->GetType()) {
       // ... then subtract out margin/border/padding for the BODY element
-      result -= GetBlockMarginBorderPadding(secondAncestorRS);
+      result -= GetBlockMarginBorderPadding(secondAncestorRI);
     }
     break;
   }
 
   // Make sure not to return a negative height here!
   return std::max(result, 0);
 }
 
 // Called by InitConstraints() to compute the containing block rectangle for
 // the element. Handles the special logic for absolutely positioned elements
 LogicalSize
 ReflowInput::ComputeContainingBlockRectangle(
                      nsPresContext*           aPresContext,
-                     const ReflowInput* aContainingBlockRS) const
+                     const ReflowInput* aContainingBlockRI) const
 {
   // Unless the element is absolutely positioned, the containing block is
   // formed by the content edge of the nearest block-level ancestor
-  LogicalSize cbSize = aContainingBlockRS->ComputedSize();
+  LogicalSize cbSize = aContainingBlockRI->ComputedSize();
 
-  WritingMode wm = aContainingBlockRS->GetWritingMode();
+  WritingMode wm = aContainingBlockRI->GetWritingMode();
 
   // mFrameType for abs-pos tables is NS_CSS_FRAME_TYPE_BLOCK, so we need to
   // special case them here.
   if (NS_FRAME_GET_TYPE(mFrameType) == NS_CSS_FRAME_TYPE_ABSOLUTE ||
       (mFrame->GetType() == nsGkAtoms::tableFrame &&
        mFrame->IsAbsolutelyPositioned() &&
        (mFrame->GetParent()->GetStateBits() & NS_FRAME_OUT_OF_FLOW))) {
     // See if the ancestor is block-level or inline-level
-    if (NS_FRAME_GET_TYPE(aContainingBlockRS->mFrameType) == NS_CSS_FRAME_TYPE_INLINE) {
+    if (NS_FRAME_GET_TYPE(aContainingBlockRI->mFrameType) == NS_CSS_FRAME_TYPE_INLINE) {
       // Base our size on the actual size of the frame.  In cases when this is
       // completely bogus (eg initial reflow), this code shouldn't even be
       // called, since the code in nsInlineFrame::Reflow will pass in
       // the containing block dimensions to our constructor.
       // XXXbz we should be taking the in-flows into account too, but
       // that's very hard.
 
       LogicalMargin computedBorder =
-        aContainingBlockRS->ComputedLogicalBorderPadding() -
-        aContainingBlockRS->ComputedLogicalPadding();
-      cbSize.ISize(wm) = aContainingBlockRS->mFrame->ISize(wm) -
+        aContainingBlockRI->ComputedLogicalBorderPadding() -
+        aContainingBlockRI->ComputedLogicalPadding();
+      cbSize.ISize(wm) = aContainingBlockRI->mFrame->ISize(wm) -
                          computedBorder.IStartEnd(wm);
       NS_ASSERTION(cbSize.ISize(wm) >= 0,
                    "Negative containing block isize!");
-      cbSize.BSize(wm) = aContainingBlockRS->mFrame->BSize(wm) -
+      cbSize.BSize(wm) = aContainingBlockRI->mFrame->BSize(wm) -
                          computedBorder.BStartEnd(wm);
       NS_ASSERTION(cbSize.BSize(wm) >= 0,
                    "Negative containing block bsize!");
     } else {
       // If the ancestor is block-level, the containing block is formed by the
       // padding edge of the ancestor
       cbSize.ISize(wm) +=
-        aContainingBlockRS->ComputedLogicalPadding().IStartEnd(wm);
+        aContainingBlockRI->ComputedLogicalPadding().IStartEnd(wm);
       cbSize.BSize(wm) +=
-        aContainingBlockRS->ComputedLogicalPadding().BStartEnd(wm);
+        aContainingBlockRI->ComputedLogicalPadding().BStartEnd(wm);
     }
   } else {
     // an element in quirks mode gets a containing block based on looking for a
     // parent with a non-auto height if the element has a percent height
     // Note: We don't emulate this quirk for percents in calc() or in
     // vertical writing modes.
     if (!wm.IsVertical() &&
         NS_AUTOHEIGHT == cbSize.BSize(wm)) {
       if (eCompatibility_NavQuirks == aPresContext->CompatibilityMode() &&
           mStylePosition->mHeight.GetUnit() == eStyleUnit_Percent) {
-        cbSize.BSize(wm) = CalcQuirkContainingBlockHeight(aContainingBlockRS);
+        cbSize.BSize(wm) = CalcQuirkContainingBlockHeight(aContainingBlockRI);
       }
     }
   }
 
   return cbSize.ConvertTo(GetWritingMode(), wm);
 }
 
 static eNormalLineHeightControl GetNormalLineHeightCalcControl(void)

--- a/layout/generic/ReflowInput.h
+++ b/layout/generic/ReflowInput.h
@@ -734,17 +734,17 @@ public:
   static nscoord CalcLineHeight(nsIContent* aContent,
                                 nsStyleContext* aStyleContext,
                                 nscoord aBlockBSize,
                                 float aFontSizeInflation);
 
 
   mozilla::LogicalSize ComputeContainingBlockRectangle(
          nsPresContext*           aPresContext,
-         const ReflowInput* aContainingBlockRS) const;
+         const ReflowInput* aContainingBlockRI) const;
 
   /**
    * Apply the mComputed(Min/Max)Width constraints to the content
    * size computed so far.
    */
   nscoord ApplyMinMaxWidth(nscoord aWidth) const {
     if (NS_UNCONSTRAINEDSIZE != ComputedMaxWidth()) {
       aWidth = std::min(aWidth, ComputedMaxWidth());

--- a/layout/generic/nsBlockFrame.cpp
+++ b/layout/generic/nsBlockFrame.cpp
@@ -963,58 +963,58 @@ CalculateContainingBlockSizeForAbsolutes
     // frame is fully reflowed and using the resulting dimensions, even
     // if they're intrinsic.
     // In fact we should be attaching absolute children to the outermost
     // frame and not always sticking them in block frames.
 
     // First, find the reflow state for the outermost frame for this
     // content, except for fieldsets where the inner anonymous frame has
     // the correct padding area with the legend taken into account.
-    const ReflowInput* aLastRS = &aReflowInput;
-    const ReflowInput* lastButOneRS = &aReflowInput;
-    while (aLastRS->mParentReflowInput &&
-           aLastRS->mParentReflowInput->mFrame->GetContent() == frame->GetContent() &&
-           aLastRS->mParentReflowInput->mFrame->GetType() != nsGkAtoms::fieldSetFrame) {
-      lastButOneRS = aLastRS;
-      aLastRS = aLastRS->mParentReflowInput;
-    }
-    if (aLastRS != &aReflowInput) {
+    const ReflowInput* aLastRI = &aReflowInput;
+    const ReflowInput* lastButOneRI = &aReflowInput;
+    while (aLastRI->mParentReflowInput &&
+           aLastRI->mParentReflowInput->mFrame->GetContent() == frame->GetContent() &&
+           aLastRI->mParentReflowInput->mFrame->GetType() != nsGkAtoms::fieldSetFrame) {
+      lastButOneRI = aLastRI;
+      aLastRI = aLastRI->mParentReflowInput;
+    }
+    if (aLastRI != &aReflowInput) {
       // Scrollbars need to be specifically excluded, if present, because they are outside the
       // padding-edge. We need better APIs for getting the various boxes from a frame.
-      nsIScrollableFrame* scrollFrame = do_QueryFrame(aLastRS->mFrame);
+      nsIScrollableFrame* scrollFrame = do_QueryFrame(aLastRI->mFrame);
       nsMargin scrollbars(0,0,0,0);
       if (scrollFrame) {
         scrollbars =
-          scrollFrame->GetDesiredScrollbarSizes(aLastRS->mFrame->PresContext(),
-                                                aLastRS->mRenderingContext);
-        if (!lastButOneRS->mFlags.mAssumingHScrollbar) {
+          scrollFrame->GetDesiredScrollbarSizes(aLastRI->mFrame->PresContext(),
+                                                aLastRI->mRenderingContext);
+        if (!lastButOneRI->mFlags.mAssumingHScrollbar) {
           scrollbars.top = scrollbars.bottom = 0;
         }
-        if (!lastButOneRS->mFlags.mAssumingVScrollbar) {
+        if (!lastButOneRI->mFlags.mAssumingVScrollbar) {
           scrollbars.left = scrollbars.right = 0;
         }
       }
       // We found a reflow state for the outermost wrapping frame, so use
       // its computed metrics if available, converted to our writing mode
-      WritingMode lastWM = aLastRS->GetWritingMode();
-      LogicalSize lastRSSize =
+      WritingMode lastWM = aLastRI->GetWritingMode();
+      LogicalSize lastRISize =
         LogicalSize(lastWM,
-                    aLastRS->ComputedISize(),
-                    aLastRS->ComputedBSize()).ConvertTo(aWM, lastWM);
-      LogicalMargin lastRSPadding =
-        aLastRS->ComputedLogicalPadding().ConvertTo(aWM, lastWM);
+                    aLastRI->ComputedISize(),
+                    aLastRI->ComputedBSize()).ConvertTo(aWM, lastWM);
+      LogicalMargin lastRIPadding =
+        aLastRI->ComputedLogicalPadding().ConvertTo(aWM, lastWM);
       LogicalMargin logicalScrollbars(aWM, scrollbars);
-      if (lastRSSize.ISize(aWM) != NS_UNCONSTRAINEDSIZE) {
-        cbSize.ISize(aWM) = std::max(0, lastRSSize.ISize(aWM) +
-                                        lastRSPadding.IStartEnd(aWM) -
+      if (lastRISize.ISize(aWM) != NS_UNCONSTRAINEDSIZE) {
+        cbSize.ISize(aWM) = std::max(0, lastRISize.ISize(aWM) +
+                                        lastRIPadding.IStartEnd(aWM) -
                                         logicalScrollbars.IStartEnd(aWM));
       }
-      if (lastRSSize.BSize(aWM) != NS_UNCONSTRAINEDSIZE) {
-        cbSize.BSize(aWM) = std::max(0, lastRSSize.BSize(aWM) +
-                                        lastRSPadding.BStartEnd(aWM) -
+      if (lastRISize.BSize(aWM) != NS_UNCONSTRAINEDSIZE) {
+        cbSize.BSize(aWM) = std::max(0, lastRISize.BSize(aWM) +
+                                        lastRIPadding.BStartEnd(aWM) -
                                         logicalScrollbars.BStartEnd(aWM));
       }
     }
   }
 
   return cbSize;
 }
 
@@ -3350,18 +3350,18 @@ nsBlockFrame::ReflowBlockFrame(BlockRefl
     aState.mBCoord -= bStartMargin;
     availSpace.BStart(wm) -= bStartMargin;
     if (NS_UNCONSTRAINEDSIZE != availSpace.BSize(wm)) {
       availSpace.BSize(wm) += bStartMargin;
     }
 
     // construct the html reflow state for the block. ReflowBlock
     // will initialize it.
-    Maybe<ReflowInput> blockHtmlRS;
-    blockHtmlRS.emplace(
+    Maybe<ReflowInput> blockHtmlRI;
+    blockHtmlRI.emplace(
       aState.mPresContext, aState.mReflowInput, frame,
       availSpace.Size(wm).ConvertTo(frame->GetWritingMode(), wm));
 
     nsFloatManager::SavedState floatManagerState;
     nsReflowStatus frameReflowStatus;
     do {
       if (floatAvailableSpace.mHasFloats) {
         // Set if floatAvailableSpace.mHasFloats is true for any
@@ -3378,26 +3378,26 @@ nsBlockFrame::ReflowBlockFrame(BlockRefl
         !*aState.mReflowInput.mDiscoveredClearance;
 
       // Reflow the block into the available space
       if (mayNeedRetry || replacedBlock) {
         aState.mFloatManager->PushState(&floatManagerState);
       }
 
       if (mayNeedRetry) {
-        blockHtmlRS->mDiscoveredClearance = &clearanceFrame;
+        blockHtmlRI->mDiscoveredClearance = &clearanceFrame;
       } else if (!applyBStartMargin) {
-        blockHtmlRS->mDiscoveredClearance =
+        blockHtmlRI->mDiscoveredClearance =
           aState.mReflowInput.mDiscoveredClearance;
       }
 
       frameReflowStatus = NS_FRAME_COMPLETE;
       brc.ReflowBlock(availSpace, applyBStartMargin, aState.mPrevBEndMargin,
                       clearance, aState.IsAdjacentWithTop(),
-                      aLine.get(), *blockHtmlRS, frameReflowStatus, aState);
+                      aLine.get(), *blockHtmlRI, frameReflowStatus, aState);
 
       // Now the block has a height.  Using that height, get the
       // available space again and call ComputeBlockAvailSpace again.
       // If ComputeBlockAvailSpace gives a different result, we need to
       // reflow again.
       if (!replacedBlock) {
         break;
       }
@@ -3474,32 +3474,32 @@ nsBlockFrame::ReflowBlockFrame(BlockRefl
         // This should never cause us to move up since the call to
         // GetFloatAvailableSpaceForBSize above included the margin.
         applyBStartMargin = false;
         bStartMargin = 0;
         treatWithClearance = true; // avoid hitting test above
         clearance = 0;
       }
 
-      blockHtmlRS.reset();
-      blockHtmlRS.emplace(
+      blockHtmlRI.reset();
+      blockHtmlRI.emplace(
         aState.mPresContext, aState.mReflowInput, frame,
         availSpace.Size(wm).ConvertTo(frame->GetWritingMode(), wm));
     } while (true);
 
     if (mayNeedRetry && clearanceFrame) {
       aState.mFloatManager->PopState(&floatManagerState);
       aState.mBCoord = startingBCoord;
       aState.mPrevBEndMargin = incomingMargin;
       continue;
     }
 
     aState.mPrevChild = frame;
 
-    if (blockHtmlRS->WillReflowAgainForClearance()) {
+    if (blockHtmlRI->WillReflowAgainForClearance()) {
       // If an ancestor of ours is going to reflow for clearance, we
       // need to avoid calling PlaceBlock, because it unsets dirty bits
       // on the child block (both itself, and through its call to
       // nsFrame::DidReflow), and those dirty bits imply dirtiness for
       // all of the child block, including the lines it didn't reflow.
       NS_ASSERTION(originalPosition == frame->GetPosition(),
                    "we need to call PositionChildViews");
       return;
@@ -3527,17 +3527,17 @@ nsBlockFrame::ReflowBlockFrame(BlockRefl
       // pushing it to the next page would give it more room.
       // Don't force the block to fit if it's impacted by a float. If it is,
       // then pushing it to the next page would give it more room. Note that
       // isImpacted doesn't include impact from the block's own floats.
       bool forceFit = aState.IsAdjacentWithTop() && clearance <= 0 &&
         !floatAvailableSpace.mHasFloats;
       nsCollapsingMargin collapsedBEndMargin;
       nsOverflowAreas overflowAreas;
-      *aKeepReflowGoing = brc.PlaceBlock(*blockHtmlRS, forceFit, aLine.get(),
+      *aKeepReflowGoing = brc.PlaceBlock(*blockHtmlRI, forceFit, aLine.get(),
                                          collapsedBEndMargin,
                                          overflowAreas,
                                          frameReflowStatus);
       if (!NS_FRAME_IS_FULLY_COMPLETE(frameReflowStatus) &&
           ShouldAvoidBreakInside(aState.mReflowInput)) {
         *aKeepReflowGoing = false;
       }
 

--- a/layout/generic/nsBlockReflowContext.cpp
+++ b/layout/generic/nsBlockReflowContext.cpp
@@ -45,49 +45,49 @@ static nsIFrame* DescendIntoBlockLevelFr
     if (child) {
       return DescendIntoBlockLevelFrame(child);
     }
   }
   return aFrame;
 }
 
 bool
-nsBlockReflowContext::ComputeCollapsedBStartMargin(const ReflowInput& aRS,
+nsBlockReflowContext::ComputeCollapsedBStartMargin(const ReflowInput& aRI,
                                                    nsCollapsingMargin* aMargin,
                                                    nsIFrame* aClearanceFrame,
                                                    bool* aMayNeedRetry,
                                                    bool* aBlockIsEmpty)
 {
-  WritingMode wm = aRS.GetWritingMode();
+  WritingMode wm = aRI.GetWritingMode();
   WritingMode parentWM = mMetrics.GetWritingMode();
 
   // Include block-start element of frame's margin
-  aMargin->Include(aRS.ComputedLogicalMargin().ConvertTo(parentWM, wm).BStart(parentWM));
+  aMargin->Include(aRI.ComputedLogicalMargin().ConvertTo(parentWM, wm).BStart(parentWM));
 
   // The inclusion of the block-end margin when empty is done by the caller
   // since it doesn't need to be done by the top-level (non-recursive)
   // caller.
 
 #ifdef NOISY_BLOCKDIR_MARGINS
-  nsFrame::ListTag(stdout, aRS.mFrame);
-  printf(": %d => %d\n", aRS.ComputedLogicalMargin().BStart(wm), aMargin->get());
+  nsFrame::ListTag(stdout, aRI.mFrame);
+  printf(": %d => %d\n", aRI.ComputedLogicalMargin().BStart(wm), aMargin->get());
 #endif
 
   bool dirtiedLine = false;
   bool setBlockIsEmpty = false;
 
   // Calculate the frame's generational block-start-margin from its child
   // blocks. Note that if the frame has a non-zero block-start-border or
   // block-start-padding then this step is skipped because it will be a margin
   // root.  It is also skipped if the frame is a margin root for other
   // reasons.
-  nsIFrame* frame = DescendIntoBlockLevelFrame(aRS.mFrame);
+  nsIFrame* frame = DescendIntoBlockLevelFrame(aRI.mFrame);
   nsPresContext* prescontext = frame->PresContext();
   nsBlockFrame* block = nullptr;
-  if (0 == aRS.ComputedLogicalBorderPadding().BStart(wm)) {
+  if (0 == aRI.ComputedLogicalBorderPadding().BStart(wm)) {
     block = nsLayoutUtils::GetAsBlock(frame);
     if (block) {
       bool bStartMarginRoot, unused;
       block->IsMarginRoot(&bStartMarginRoot, &unused);
       if (bStartMarginRoot) {
         block = nullptr;
       }
     }
@@ -147,23 +147,23 @@ nsBlockReflowContext::ComputeCollapsedBS
           // child blocks margin and so in so that we can look into
           // it. For its margins to be computed we need to have a reflow
           // state for it.
 
           // We may have to construct an extra reflow state here if
           // we drilled down through a block wrapper. At the moment
           // we can only drill down one level so we only have to support
           // one extra reflow state.
-          const ReflowInput* outerReflowInput = &aRS;
-          if (frame != aRS.mFrame) {
-            NS_ASSERTION(frame->GetParent() == aRS.mFrame,
+          const ReflowInput* outerReflowInput = &aRI;
+          if (frame != aRI.mFrame) {
+            NS_ASSERTION(frame->GetParent() == aRI.mFrame,
                          "Can only drill through one level of block wrapper");
-            LogicalSize availSpace = aRS.ComputedSize(frame->GetWritingMode());
+            LogicalSize availSpace = aRI.ComputedSize(frame->GetWritingMode());
             outerReflowInput = new ReflowInput(prescontext,
-                                                     aRS, frame, availSpace);
+                                                     aRI, frame, availSpace);
           }
           {
             LogicalSize availSpace =
               outerReflowInput->ComputedSize(kid->GetWritingMode());
             ReflowInput innerReflowInput(prescontext,
                                                *outerReflowInput, kid,
                                                availSpace);
             // Record that we're being optimistic by assuming the kid
@@ -180,90 +180,90 @@ nsBlockReflowContext::ComputeCollapsedBS
             }
             if (isEmpty) {
               WritingMode innerWM = innerReflowInput.GetWritingMode();
               LogicalMargin innerMargin =
                 innerReflowInput.ComputedLogicalMargin().ConvertTo(parentWM, innerWM);
               aMargin->Include(innerMargin.BEnd(parentWM));
             }
           }
-          if (outerReflowInput != &aRS) {
+          if (outerReflowInput != &aRI) {
             delete const_cast<ReflowInput*>(outerReflowInput);
           }
         }
         if (!isEmpty) {
           if (!setBlockIsEmpty && aBlockIsEmpty) {
             setBlockIsEmpty = true;
             *aBlockIsEmpty = false;
           }
           goto done;
         }
       }
       if (!setBlockIsEmpty && aBlockIsEmpty) {
         // The first time we reach here is when this is the first block
         // and we have processed all its normal lines.
         setBlockIsEmpty = true;
         // All lines are empty, or we wouldn't be here!
-        *aBlockIsEmpty = aRS.mFrame->IsSelfEmpty();
+        *aBlockIsEmpty = aRI.mFrame->IsSelfEmpty();
       }
     }
   }
   done:
 
   if (!setBlockIsEmpty && aBlockIsEmpty) {
-    *aBlockIsEmpty = aRS.mFrame->IsEmpty();
+    *aBlockIsEmpty = aRI.mFrame->IsEmpty();
   }
   
 #ifdef NOISY_BLOCKDIR_MARGINS
-  nsFrame::ListTag(stdout, aRS.mFrame);
+  nsFrame::ListTag(stdout, aRI.mFrame);
   printf(": => %d\n", aMargin->get());
 #endif
 
   return dirtiedLine;
 }
 
 void
 nsBlockReflowContext::ReflowBlock(const LogicalRect&  aSpace,
                                   bool                aApplyBStartMargin,
                                   nsCollapsingMargin& aPrevMargin,
                                   nscoord             aClearance,
                                   bool                aIsAdjacentWithBStart,
                                   nsLineBox*          aLine,
-                                  ReflowInput&  aFrameRS,
+                                  ReflowInput&  aFrameRI,
                                   nsReflowStatus&     aFrameReflowStatus,
                                   BlockReflowInput& aState)
 {
-  mFrame = aFrameRS.mFrame;
+  mFrame = aFrameRI.mFrame;
   mWritingMode = aState.mReflowInput.GetWritingMode();
   mContainerSize = aState.ContainerSize();
   mSpace = aSpace;
 
   if (!aIsAdjacentWithBStart) {
-    aFrameRS.mFlags.mIsTopOfPage = false;  // make sure this is cleared
+    aFrameRI.mFlags.mIsTopOfPage = false;  // make sure this is cleared
   }
 
   if (aApplyBStartMargin) {
     mBStartMargin = aPrevMargin;
 
 #ifdef NOISY_BLOCKDIR_MARGINS
     nsFrame::ListTag(stdout, mOuterReflowInput.mFrame);
     printf(": reflowing ");
     nsFrame::ListTag(stdout, mFrame);
     printf(" margin => %d, clearance => %d\n", mBStartMargin.get(), aClearance);
 #endif
 
     // Adjust the available size if it's constrained so that the
     // child frame doesn't think it can reflow into its margin area.
     if (mWritingMode.IsOrthogonalTo(mFrame->GetWritingMode())) {
-      if (NS_UNCONSTRAINEDSIZE != aFrameRS.AvailableISize()) {
-        aFrameRS.AvailableISize() -= mBStartMargin.get() + aClearance;
+      if (NS_UNCONSTRAINEDSIZE != aFrameRI.AvailableISize()) {
+        aFrameRI.AvailableISize() -= mBStartMargin.get() + aClearance;
       }
     } else {
-      if (NS_UNCONSTRAINEDSIZE != aFrameRS.AvailableBSize()) {
-        aFrameRS.AvailableBSize() -= mBStartMargin.get() + aClearance;
+      if (NS_UNCONSTRAINEDSIZE != aFrameRI.AvailableBSize()) {
+        aFrameRI.AvailableBSize() -= mBStartMargin.get() + aClearance;
       }
     }
   } else {
     // nsBlockFrame::ReflowBlock might call us multiple times with
     // *different* values of aApplyBStartMargin.
     mBStartMargin.Zero();
   }
 
@@ -273,42 +273,42 @@ nsBlockReflowContext::ReflowBlock(const 
   // manager, so tI and tB don't matter.  mICoord and mBCoord don't
   // matter becacuse they are only used in PlaceBlock, which is not used
   // for floats.
   if (aLine) {
     // Compute inline/block coordinate where reflow will begin. Use the
     // rules from 10.3.3 to determine what to apply. At this point in the
     // reflow auto inline-start/end margins will have a zero value.
 
-    WritingMode frameWM = aFrameRS.GetWritingMode();
+    WritingMode frameWM = aFrameRI.GetWritingMode();
     LogicalMargin usedMargin =
-      aFrameRS.ComputedLogicalMargin().ConvertTo(mWritingMode, frameWM);
+      aFrameRI.ComputedLogicalMargin().ConvertTo(mWritingMode, frameWM);
     mICoord = mSpace.IStart(mWritingMode) + usedMargin.IStart(mWritingMode);
     mBCoord = mSpace.BStart(mWritingMode) + mBStartMargin.get() + aClearance;
 
     LogicalRect space(mWritingMode, mICoord, mBCoord,
                       mSpace.ISize(mWritingMode) -
                       usedMargin.IStartEnd(mWritingMode),
                       mSpace.BSize(mWritingMode) -
                       usedMargin.BStartEnd(mWritingMode));
     tI = space.LineLeft(mWritingMode, mContainerSize);
     tB = mBCoord;
 
     if ((mFrame->GetStateBits() & NS_BLOCK_FLOAT_MGR) == 0)
-      aFrameRS.mBlockDelta =
+      aFrameRI.mBlockDelta =
         mOuterReflowInput.mBlockDelta + mBCoord - aLine->BStart();
   }
 
 #ifdef DEBUG
   mMetrics.ISize(mWritingMode) = nscoord(0xdeadbeef);
   mMetrics.BSize(mWritingMode) = nscoord(0xdeadbeef);
 #endif
 
   mOuterReflowInput.mFloatManager->Translate(tI, tB);
-  mFrame->Reflow(mPresContext, mMetrics, aFrameRS, aFrameReflowStatus);
+  mFrame->Reflow(mPresContext, mMetrics, aFrameRI, aFrameReflowStatus);
   mOuterReflowInput.mFloatManager->Translate(-tI, -tB);
 
 #ifdef DEBUG
   if (!NS_INLINE_IS_BREAK_BEFORE(aFrameReflowStatus)) {
     if ((CRAZY_SIZE(mMetrics.ISize(mWritingMode)) ||
          CRAZY_SIZE(mMetrics.BSize(mWritingMode))) &&
         !mFrame->GetParent()->IsCrazySizeAssertSuppressed()) {
       printf("nsBlockReflowContext: ");

--- a/layout/generic/nsBlockReflowContext.h
+++ b/layout/generic/nsBlockReflowContext.h
@@ -53,34 +53,34 @@ public:
   }
 
   const ReflowOutput& GetMetrics() const {
     return mMetrics;
   }
 
   /**
    * Computes the collapsed block-start margin (in the context's parent's
-   * writing mode) for a block whose reflow state is in aRS.
+   * writing mode) for a block whose reflow state is in aRI.
    * The computed margin is added into aMargin, whose writing mode is the
    * parent's mode as found in mMetrics.GetWritingMode(); note this may not be
-   * the block's own writing mode as found in aRS.
+   * the block's own writing mode as found in aRI.
    * If aClearanceFrame is null then this is the first optimistic pass which
    * shall assume that no frames have clearance, and we clear the HasClearance
    * on all frames encountered.
    * If non-null, this is the second pass and the caller has decided
    * aClearanceFrame needs clearance (and we will therefore stop collapsing
    * there); also, this function is responsible for marking it with
    * SetHasClearance.
    * If in the optimistic pass any frame is encountered that might possibly
    * need clearance (i.e., if we really needed the optimism assumption) then
    * we set aMayNeedRetry to true.
    * We return true if we changed the clearance state of any line and marked it
    * dirty.
    */
-  bool ComputeCollapsedBStartMargin(const ReflowInput& aRS,
+  bool ComputeCollapsedBStartMargin(const ReflowInput& aRI,
                                     nsCollapsingMargin* aMargin,
                                     nsIFrame* aClearanceFrame,
                                     bool* aMayNeedRetry,
                                     bool* aIsEmpty = nullptr);
 
 protected:
   nsPresContext* mPresContext;
   const ReflowInput& mOuterReflowInput;

--- a/layout/generic/nsFlexContainerFrame.cpp
+++ b/layout/generic/nsFlexContainerFrame.cpp
@@ -1183,63 +1183,63 @@ nsFlexContainerFrame::GenerateFlexItemFo
   nsIFrame*      aChildFrame,
   const ReflowInput& aParentReflowInput,
   const FlexboxAxisTracker& aAxisTracker)
 {
   // Create temporary reflow state just for sizing -- to get hypothetical
   // main-size and the computed values of min / max main-size property.
   // (This reflow state will _not_ be used for reflow.)
   ReflowInput
-    childRS(aPresContext, aParentReflowInput, aChildFrame,
+    childRI(aPresContext, aParentReflowInput, aChildFrame,
             aParentReflowInput.ComputedSize(aChildFrame->GetWritingMode()));
 
   // FLEX GROW & SHRINK WEIGHTS
   // --------------------------
   float flexGrow, flexShrink;
   if (IsLegacyBox(aParentReflowInput.mStyleDisplay, mStyleContext)) {
     flexGrow = flexShrink = aChildFrame->StyleXUL()->mBoxFlex;
   } else {
     const nsStylePosition* stylePos = aChildFrame->StylePosition();
     flexGrow   = stylePos->mFlexGrow;
     flexShrink = stylePos->mFlexShrink;
   }
 
-  WritingMode childWM = childRS.GetWritingMode();
+  WritingMode childWM = childRI.GetWritingMode();
 
   // MAIN SIZES (flex base size, min/max size)
   // -----------------------------------------
   nscoord flexBaseSize = GET_MAIN_COMPONENT_LOGICAL(aAxisTracker, childWM,
-                                                    childRS.ComputedISize(),
-                                                    childRS.ComputedBSize());
+                                                    childRI.ComputedISize(),
+                                                    childRI.ComputedBSize());
   nscoord mainMinSize = GET_MAIN_COMPONENT_LOGICAL(aAxisTracker, childWM,
-                                                   childRS.ComputedMinISize(),
-                                                   childRS.ComputedMinBSize());
+                                                   childRI.ComputedMinISize(),
+                                                   childRI.ComputedMinBSize());
   nscoord mainMaxSize = GET_MAIN_COMPONENT_LOGICAL(aAxisTracker, childWM,
-                                                   childRS.ComputedMaxISize(),
-                                                   childRS.ComputedMaxBSize());
+                                                   childRI.ComputedMaxISize(),
+                                                   childRI.ComputedMaxBSize());
   // This is enforced by the ReflowInput where these values come from:
   MOZ_ASSERT(mainMinSize <= mainMaxSize, "min size is larger than max size");
 
   // CROSS SIZES (tentative cross size, min/max cross size)
   // ------------------------------------------------------
   // Grab the cross size from the reflow state. This might be the right value,
   // or we might resolve it to something else in SizeItemInCrossAxis(); hence,
   // it's tentative. See comment under "Cross Size Determination" for more.
   nscoord tentativeCrossSize =
     GET_CROSS_COMPONENT_LOGICAL(aAxisTracker, childWM,
-                                childRS.ComputedISize(),
-                                childRS.ComputedBSize());
+                                childRI.ComputedISize(),
+                                childRI.ComputedBSize());
   nscoord crossMinSize =
     GET_CROSS_COMPONENT_LOGICAL(aAxisTracker, childWM,
-                                childRS.ComputedMinISize(),
-                                childRS.ComputedMinBSize());
+                                childRI.ComputedMinISize(),
+                                childRI.ComputedMinBSize());
   nscoord crossMaxSize =
     GET_CROSS_COMPONENT_LOGICAL(aAxisTracker, childWM,
-                                childRS.ComputedMaxISize(),
-                                childRS.ComputedMaxBSize());
+                                childRI.ComputedMaxISize(),
+                                childRI.ComputedMaxBSize());
 
   // SPECIAL-CASE FOR WIDGET-IMPOSED SIZES
   // Check if we're a themed widget, in which case we might have a minimum
   // main & cross size imposed by our widget (which we can't go below), or
   // (more severe) our widget might have only a single valid size.
   bool isFixedSizeWidget = false;
   const nsStyleDisplay* disp = aChildFrame->StyleDisplay();
   if (aChildFrame->IsThemed(disp)) {
@@ -1254,17 +1254,17 @@ nsFlexContainerFrame::GenerateFlexItemFo
       aPresContext->DevPixelsToAppUnits(
         aAxisTracker.GetMainComponent(widgetMinSize));
     nscoord widgetCrossMinSize =
       aPresContext->DevPixelsToAppUnits(
         aAxisTracker.GetCrossComponent(widgetMinSize));
 
     // GMWS() returns border-box. We need content-box, so subtract
     // borderPadding (but don't let that push our min sizes below 0).
-    nsMargin& bp = childRS.ComputedPhysicalBorderPadding();
+    nsMargin& bp = childRI.ComputedPhysicalBorderPadding();
     widgetMainMinSize = std::max(widgetMainMinSize -
                                  aAxisTracker.GetMarginSizeInMainAxis(bp), 0);
     widgetCrossMinSize = std::max(widgetCrossMinSize -
                                   aAxisTracker.GetMarginSizeInCrossAxis(bp), 0);
 
     if (!canOverride) {
       // Fixed-size widget: freeze our main-size at the widget's mandated size.
       // (Set min and max main-sizes to that size, too, to keep us from
@@ -1282,34 +1282,34 @@ nsFlexContainerFrame::GenerateFlexItemFo
         tentativeCrossSize = std::max(tentativeCrossSize, widgetCrossMinSize);
       }
       crossMinSize = std::max(crossMinSize, widgetCrossMinSize);
       crossMaxSize = std::max(crossMaxSize, widgetCrossMinSize);
     }
   }
 
   // Construct the flex item!
-  auto item = MakeUnique<FlexItem>(childRS,
+  auto item = MakeUnique<FlexItem>(childRI,
                                    flexGrow, flexShrink, flexBaseSize,
                                    mainMinSize, mainMaxSize,
                                    tentativeCrossSize,
                                    crossMinSize, crossMaxSize,
                                    aAxisTracker);
 
   // If we're inflexible, we can just freeze to our hypothetical main-size
   // up-front. Similarly, if we're a fixed-size widget, we only have one
   // valid size, so we freeze to keep ourselves from flexing.
   if (isFixedSizeWidget || (flexGrow == 0.0f && flexShrink == 0.0f)) {
     item->Freeze();
   }
 
   // Resolve "flex-basis:auto" and/or "min-[width|height]:auto" (which might
   // require us to reflow the item to measure content height)
   ResolveAutoFlexBasisAndMinSize(aPresContext, *item,
-                                 childRS, aAxisTracker);
+                                 childRI, aAxisTracker);
   return item;
 }
 
 // Static helper-functions for ResolveAutoFlexBasisAndMinSize():
 // -------------------------------------------------------------
 // Indicates whether the cross-size property is set to something definite.
 // The logic here should be similar to the logic for isAutoWidth/isAutoHeight
 // in nsLayoutUtils::ComputeSizeWithIntrinsicDimensions().
@@ -1513,26 +1513,26 @@ nsFlexContainerFrame::
   // (e.g. using it as a contstraint when measuring our content in the
   // main axis, or using it with the intrinsic ratio to obtain a main size).
   // BEFORE WE DO THAT, we need let the item "pre-stretch" its cross size (if
   // it's got 'align-self:stretch'), for a certain case where the spec says
   // the stretched cross size is considered "definite". That case is if we
   // have a single-line (nowrap) flex container which itself has a definite
   // cross-size.  Otherwise, we'll wait to do stretching, since (in other
   // cases) we don't know how much the item should stretch yet.
-  const ReflowInput* flexContainerRS = aItemReflowInput.mParentReflowInput;
-  MOZ_ASSERT(flexContainerRS,
+  const ReflowInput* flexContainerRI = aItemReflowInput.mParentReflowInput;
+  MOZ_ASSERT(flexContainerRI,
              "flex item's reflow state should have ptr to container's state");
-  if (NS_STYLE_FLEX_WRAP_NOWRAP == flexContainerRS->mStylePosition->mFlexWrap) {
+  if (NS_STYLE_FLEX_WRAP_NOWRAP == flexContainerRI->mStylePosition->mFlexWrap) {
     // XXXdholbert Maybe this should share logic with ComputeCrossSize()...
     // Alternately, maybe tentative container cross size should be passed down.
     nscoord containerCrossSize =
       GET_CROSS_COMPONENT_LOGICAL(aAxisTracker, aAxisTracker.GetWritingMode(),
-                                  flexContainerRS->ComputedISize(),
-                                  flexContainerRS->ComputedBSize());
+                                  flexContainerRI->ComputedISize(),
+                                  flexContainerRI->ComputedBSize());
     // Is container's cross size "definite"?
     // (Container's cross size is definite if cross-axis is horizontal, or if
     // cross-axis is vertical and the cross-size is not NS_AUTOHEIGHT.)
     if (aAxisTracker.IsCrossAxisHorizontal() ||
         containerCrossSize != NS_AUTOHEIGHT) {
       aFlexItem.ResolveStretchedCrossSize(containerCrossSize, aAxisTracker);
     }
   }
@@ -1589,17 +1589,17 @@ nsFlexContainerFrame::
       bool forceVerticalResizeForMeasuringReflow =
         !aFlexItem.IsFrozen() ||         // Is the item flexible?
         !flexBasisNeedsToMeasureContent; // Are we *only* measuring it for
                                          // 'min-height:auto'?
 
       nscoord contentHeight =
         MeasureFlexItemContentHeight(aPresContext, aFlexItem,
                                      forceVerticalResizeForMeasuringReflow,
-                                     *flexContainerRS);
+                                     *flexContainerRI);
       if (minSizeNeedsToMeasureContent) {
         resolvedMinSize = std::min(resolvedMinSize, contentHeight);
       }
       if (flexBasisNeedsToMeasureContent) {
         aFlexItem.SetFlexBaseSizeAndMainSize(contentHeight);
       }
     }
   }
@@ -1616,60 +1616,60 @@ nsFlexContainerFrame::
                                bool aForceVerticalResizeForMeasuringReflow,
                                const ReflowInput& aParentReflowInput)
 {
   // Set up a reflow state for measuring the flex item's auto-height:
   WritingMode wm = aFlexItem.Frame()->GetWritingMode();
   LogicalSize availSize = aParentReflowInput.ComputedSize(wm);
   availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
   ReflowInput
-    childRSForMeasuringHeight(aPresContext, aParentReflowInput,
+    childRIForMeasuringHeight(aPresContext, aParentReflowInput,
                               aFlexItem.Frame(), availSize,
                               nullptr, ReflowInput::CALLER_WILL_INIT);
-  childRSForMeasuringHeight.mFlags.mIsFlexContainerMeasuringHeight = true;
-  childRSForMeasuringHeight.Init(aPresContext);
+  childRIForMeasuringHeight.mFlags.mIsFlexContainerMeasuringHeight = true;
+  childRIForMeasuringHeight.Init(aPresContext);
 
   if (aFlexItem.IsStretched()) {
-    childRSForMeasuringHeight.SetComputedWidth(aFlexItem.GetCrossSize());
-    childRSForMeasuringHeight.SetHResize(true);
+    childRIForMeasuringHeight.SetComputedWidth(aFlexItem.GetCrossSize());
+    childRIForMeasuringHeight.SetHResize(true);
   }
 
   if (aForceVerticalResizeForMeasuringReflow) {
-    childRSForMeasuringHeight.SetVResize(true);
+    childRIForMeasuringHeight.SetVResize(true);
   }
 
-  ReflowOutput childDesiredSize(childRSForMeasuringHeight);
+  ReflowOutput childDesiredSize(childRIForMeasuringHeight);
   nsReflowStatus childReflowStatus;
   const uint32_t flags = NS_FRAME_NO_MOVE_FRAME;
   ReflowChild(aFlexItem.Frame(), aPresContext,
-              childDesiredSize, childRSForMeasuringHeight,
+              childDesiredSize, childRIForMeasuringHeight,
               0, 0, flags, childReflowStatus);
 
   MOZ_ASSERT(NS_FRAME_IS_COMPLETE(childReflowStatus),
              "We gave flex item unconstrained available height, so it "
              "should be complete");
 
   FinishReflowChild(aFlexItem.Frame(), aPresContext,
-                    childDesiredSize, &childRSForMeasuringHeight,
+                    childDesiredSize, &childRIForMeasuringHeight,
                     0, 0, flags);
 
   aFlexItem.SetHadMeasuringReflow();
 
   // If this is the first child, save its ascent, since it may be what
   // establishes the container's baseline. Also save the ascent if this child
   // needs to be baseline-aligned. (Else, we don't care about ascent/baseline.)
   if (aFlexItem.Frame() == mFrames.FirstChild() ||
       aFlexItem.GetAlignSelf() == NS_STYLE_ALIGN_BASELINE) {
     aFlexItem.SetAscent(childDesiredSize.BlockStartAscent());
   }
 
   // Subtract border/padding in vertical axis, to get _just_
   // the effective computed value of the "height" property.
   nscoord childDesiredHeight = childDesiredSize.Height() -
-    childRSForMeasuringHeight.ComputedPhysicalBorderPadding().TopBottom();
+    childRIForMeasuringHeight.ComputedPhysicalBorderPadding().TopBottom();
 
   return std::max(0, childDesiredHeight);
 }
 
 FlexItem::FlexItem(ReflowInput& aFlexItemReflowInput,
                    float aFlexGrow, float aFlexShrink, nscoord aFlexBaseSize,
                    nscoord aMainMinSize,  nscoord aMainMaxSize,
                    nscoord aTentativeCrossSize,

--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -9080,41 +9080,41 @@ nsFrame::BoxReflow(nsBoxLayoutState&    
     parentReflowInput.ComputedPhysicalBorderPadding() +=
       parentReflowInput.ComputedPhysicalPadding();
 
     // Construct the parent chain manually since constructing it normally
     // messes up dimensions.
     const ReflowInput *outerReflowInput = aState.OuterReflowInput();
     NS_ASSERTION(!outerReflowInput || outerReflowInput->mFrame != this,
                  "in and out of XUL on a single frame?");
-    const ReflowInput* parentRS;
+    const ReflowInput* parentRI;
     if (outerReflowInput && outerReflowInput->mFrame == parentFrame) {
       // We're a frame (such as a text control frame) that jumps into
       // box reflow and then straight out of it on the child frame.
       // This means we actually have a real parent reflow state.
       // nsLayoutUtils::InflationMinFontSizeFor used to need this to be
       // linked up correctly for text control frames, so do so here).
-      parentRS = outerReflowInput;
+      parentRI = outerReflowInput;
     } else {
-      parentRS = &parentReflowInput;
+      parentRI = &parentReflowInput;
     }
 
     // XXX Is it OK that this reflow state has only one ancestor?
     // (It used to have a bogus parent, skipping all the boxes).
     WritingMode wm = GetWritingMode();
     LogicalSize logicalSize(wm, nsSize(aWidth, aHeight));
     logicalSize.BSize(wm) = NS_INTRINSICSIZE;
-    ReflowInput reflowInput(aPresContext, *parentRS, this,
+    ReflowInput reflowInput(aPresContext, *parentRI, this,
                                   logicalSize, nullptr,
                                   ReflowInput::DUMMY_PARENT_REFLOW_STATE);
 
     // XXX_jwir3: This is somewhat fishy. If this is actually changing the value
     //            here (which it might be), then we should make sure that it's
     //            correct the first time around, rather than changing it later.
-    reflowInput.mCBReflowInput = parentRS;
+    reflowInput.mCBReflowInput = parentRI;
 
     reflowInput.mReflowDepth = aState.GetReflowDepth();
 
     // mComputedWidth and mComputedHeight are content-box, not
     // border-box
     if (aWidth != NS_INTRINSICSIZE) {
       nscoord computedWidth =
         aWidth - reflowInput.ComputedPhysicalBorderPadding().LeftRight();
@@ -10218,18 +10218,18 @@ void DR_State::FindMatchingRule(DR_Frame
 }
     
 DR_FrameTreeNode* DR_State::CreateTreeNode(nsIFrame*                aFrame,
                                            const ReflowInput* aReflowInput)
 {
   // find the frame of the parent reflow state (usually just the parent of aFrame)
   nsIFrame* parentFrame;
   if (aReflowInput) {
-    const ReflowInput* parentRS = aReflowInput->mParentReflowInput;
-    parentFrame = (parentRS) ? parentRS->mFrame : nullptr;
+    const ReflowInput* parentRI = aReflowInput->mParentReflowInput;
+    parentFrame = (parentRI) ? parentRI->mFrame : nullptr;
   } else {
     parentFrame = aFrame->GetParent();
   }
 
   // find the parent tree node leaf
   DR_FrameTreeNode* parentNode = nullptr;
   
   DR_FrameTreeNode* lastLeaf = nullptr;

--- a/layout/generic/nsGridContainerFrame.cpp
+++ b/layout/generic/nsGridContainerFrame.cpp
@@ -1666,19 +1666,19 @@ struct nsGridContainerFrame::SharedGridD
    * GridReflowInput from it.
    */
   NS_DECLARE_FRAME_PROPERTY_DELETABLE(Prop, SharedGridData)
 };
 
 struct MOZ_STACK_CLASS nsGridContainerFrame::GridReflowInput
 {
   GridReflowInput(nsGridContainerFrame*    aFrame,
-                  const ReflowInput& aRS)
-    : GridReflowInput(aFrame, *aRS.mRenderingContext, &aRS, aRS.mStylePosition,
-                      aRS.GetWritingMode())
+                  const ReflowInput& aRI)
+    : GridReflowInput(aFrame, *aRI.mRenderingContext, &aRI, aRI.mStylePosition,
+                      aRI.GetWritingMode())
   {}
   GridReflowInput(nsGridContainerFrame* aFrame,
                   nsRenderingContext&   aRC)
     : GridReflowInput(aFrame, aRC, nullptr, aFrame->StylePosition(),
                       aFrame->GetWritingMode())
   {}
 
   /**
@@ -2304,17 +2304,17 @@ SpaceToFill(WritingMode aWM, const Logic
                                             : aSize.ISize(aWM);
   return aCBSize - (size + aMargin);
 }
 
 // Align an item's margin box in its aAxis inside aCBSize.
 static void
 AlignJustifySelf(uint8_t aAlignment, bool aOverflowSafe, LogicalAxis aAxis,
                  bool aSameSide, nscoord aBaselineAdjust, nscoord aCBSize,
-                 const ReflowInput& aRS, const LogicalSize& aChildSize,
+                 const ReflowInput& aRI, const LogicalSize& aChildSize,
                  LogicalPoint* aPos)
 {
   MOZ_ASSERT(aAlignment != NS_STYLE_ALIGN_AUTO, "unexpected 'auto' "
              "computed value for normal flow grid item");
   MOZ_ASSERT(aAlignment != NS_STYLE_ALIGN_LEFT &&
              aAlignment != NS_STYLE_ALIGN_RIGHT,
              "caller should map that to the corresponding START/END");
 
@@ -2335,18 +2335,18 @@ AlignJustifySelf(uint8_t aAlignment, boo
       aAlignment = NS_STYLE_ALIGN_END;
       break;
   }
 
   // XXX try to condense this code a bit by adding the necessary convenience
   // methods? (bug 1209710)
 
   // Get the item's margin corresponding to the container's start/end side.
-  const LogicalMargin margin = aRS.ComputedLogicalMargin();
-  WritingMode wm = aRS.GetWritingMode();
+  const LogicalMargin margin = aRI.ComputedLogicalMargin();
+  WritingMode wm = aRI.GetWritingMode();
   nscoord marginStart, marginEnd;
   if (aAxis == eLogicalAxisBlock) {
     if (MOZ_LIKELY(aSameSide)) {
       marginStart = margin.BStart(wm);
       marginEnd = margin.BEnd(wm);
     } else {
       marginStart = margin.BEnd(wm);
       marginEnd = margin.BStart(wm);
@@ -2356,17 +2356,17 @@ AlignJustifySelf(uint8_t aAlignment, boo
       marginStart = margin.IStart(wm);
       marginEnd = margin.IEnd(wm);
     } else {
       marginStart = margin.IEnd(wm);
       marginEnd = margin.IStart(wm);
     }
   }
 
-  const auto& styleMargin = aRS.mStyleMargin->mMargin;
+  const auto& styleMargin = aRI.mStyleMargin->mMargin;
   bool hasAutoMarginStart;
   bool hasAutoMarginEnd;
   if (aAxis == eLogicalAxisBlock) {
     hasAutoMarginStart = styleMargin.GetBStartUnit(wm) == eStyleUnit_Auto;
     hasAutoMarginEnd = styleMargin.GetBEndUnit(wm) == eStyleUnit_Auto;
   } else {
     hasAutoMarginStart = styleMargin.GetIStartUnit(wm) == eStyleUnit_Auto;
     hasAutoMarginEnd = styleMargin.GetIEndUnit(wm) == eStyleUnit_Auto;
@@ -2441,60 +2441,60 @@ SameSide(WritingMode aContainerWM, Logic
                  aChildWM.PhysicalAxis(GetAxis(aChildSide)));
   return aContainerWM.PhysicalSide(aContainerSide) ==
              aChildWM.PhysicalSide(aChildSide);
 }
 
 static void
 AlignSelf(const nsGridContainerFrame::GridItemInfo& aGridItem,
           uint8_t aAlignSelf, nscoord aCBSize, const WritingMode aCBWM,
-          const ReflowInput& aRS, const LogicalSize& aSize,
+          const ReflowInput& aRI, const LogicalSize& aSize,
           LogicalPoint* aPos)
 {
   auto alignSelf = aAlignSelf;
   bool overflowSafe = alignSelf & NS_STYLE_ALIGN_SAFE;
   alignSelf &= ~NS_STYLE_ALIGN_FLAG_BITS;
   // Grid's 'align-self' axis is never parallel to the container's inline axis.
   if (alignSelf == NS_STYLE_ALIGN_LEFT || alignSelf == NS_STYLE_ALIGN_RIGHT) {
     alignSelf = NS_STYLE_ALIGN_START;
   }
   if (MOZ_LIKELY(alignSelf == NS_STYLE_ALIGN_NORMAL)) {
     alignSelf = NS_STYLE_ALIGN_STRETCH;
   }
-  WritingMode childWM = aRS.GetWritingMode();
+  WritingMode childWM = aRI.GetWritingMode();
   bool isOrthogonal = aCBWM.IsOrthogonalTo(childWM);
   // |sameSide| is true if the container's start side in this axis is the same
   // as the child's start side, in the child's parallel axis.
   bool sameSide = SameSide(aCBWM, eLogicalSideBStart,
                            childWM, isOrthogonal ? eLogicalSideIStart
                                                  : eLogicalSideBStart);
   nscoord baselineAdjust = 0;
   if (alignSelf == NS_STYLE_ALIGN_BASELINE ||
       alignSelf == NS_STYLE_ALIGN_LAST_BASELINE) {
     alignSelf = aGridItem.GetSelfBaseline(alignSelf, eLogicalAxisBlock,
                                           &baselineAdjust);
   }
   LogicalAxis axis = isOrthogonal ? eLogicalAxisInline : eLogicalAxisBlock;
   AlignJustifySelf(alignSelf, overflowSafe, axis, sameSide, baselineAdjust,
-                   aCBSize, aRS, aSize, aPos);
+                   aCBSize, aRI, aSize, aPos);
 }
 
 static void
 JustifySelf(const nsGridContainerFrame::GridItemInfo& aGridItem,
             uint8_t aJustifySelf, nscoord aCBSize, const WritingMode aCBWM,
-            const ReflowInput& aRS, const LogicalSize& aSize,
+            const ReflowInput& aRI, const LogicalSize& aSize,
             LogicalPoint* aPos)
 {
   auto justifySelf = aJustifySelf;
   bool overflowSafe = justifySelf & NS_STYLE_JUSTIFY_SAFE;
   justifySelf &= ~NS_STYLE_JUSTIFY_FLAG_BITS;
   if (MOZ_LIKELY(justifySelf == NS_STYLE_ALIGN_NORMAL)) {
     justifySelf = NS_STYLE_ALIGN_STRETCH;
   }
-  WritingMode childWM = aRS.GetWritingMode();
+  WritingMode childWM = aRI.GetWritingMode();
   bool isOrthogonal = aCBWM.IsOrthogonalTo(childWM);
   // |sameSide| is true if the container's start side in this axis is the same
   // as the child's start side, in the child's parallel axis.
   bool sameSide = SameSide(aCBWM, eLogicalSideIStart,
                            childWM, isOrthogonal ? eLogicalSideBStart
                                                  : eLogicalSideIStart);
   nscoord baselineAdjust = 0;
   // Grid's 'justify-self' axis is always parallel to the container's inline
@@ -2512,17 +2512,17 @@ JustifySelf(const nsGridContainerFrame::
     case NS_STYLE_JUSTIFY_LAST_BASELINE:
       justifySelf = aGridItem.GetSelfBaseline(justifySelf, eLogicalAxisInline,
                                               &baselineAdjust);
       break;
   }
 
   LogicalAxis axis = isOrthogonal ? eLogicalAxisBlock : eLogicalAxisInline;
   AlignJustifySelf(justifySelf, overflowSafe, axis, sameSide, baselineAdjust,
-                   aCBSize, aRS, aSize, aPos);
+                   aCBSize, aRI, aSize, aPos);
 }
 
 static uint16_t
 GetAlignJustifyValue(uint16_t aAlignment, const WritingMode aWM,
                      const bool aIsAlign, bool* aOverflowSafe)
 {
   *aOverflowSafe = aAlignment & NS_STYLE_ALIGN_SAFE;
   aAlignment &= (NS_STYLE_ALIGN_ALL_BITS & ~NS_STYLE_ALIGN_FLAG_BITS);
@@ -3436,26 +3436,26 @@ MeasuringReflow(nsIFrame*               
                              ReflowInput::DUMMY_PARENT_REFLOW_STATE);
     rs = dummyParentState.ptr();
   }
 #ifdef DEBUG
   // This will suppress various CRAZY_SIZE warnings for this reflow.
   parent->Properties().Set(
     nsContainerFrame::DebugReflowingWithInfiniteISize(), true);
 #endif
-  ReflowInput childRS(pc, *rs, aChild, aAvailableSize, nullptr,
+  ReflowInput childRI(pc, *rs, aChild, aAvailableSize, nullptr,
                             ReflowInput::COMPUTE_SIZE_SHRINK_WRAP |
                             ReflowInput::COMPUTE_SIZE_USE_AUTO_BSIZE);
-  ReflowOutput childSize(childRS);
+  ReflowOutput childSize(childRI);
   nsReflowStatus childStatus;
   const uint32_t flags = NS_FRAME_NO_MOVE_FRAME | NS_FRAME_NO_SIZE_VIEW;
-  WritingMode wm = childRS.GetWritingMode();
-  parent->ReflowChild(aChild, pc, childSize, childRS, wm,
+  WritingMode wm = childRI.GetWritingMode();
+  parent->ReflowChild(aChild, pc, childSize, childRI, wm,
                       LogicalPoint(wm), nsSize(), flags, childStatus);
-  parent->FinishReflowChild(aChild, pc, childSize, &childRS, wm,
+  parent->FinishReflowChild(aChild, pc, childSize, &childRI, wm,
                             LogicalPoint(wm), nsSize(), flags);
 #ifdef DEBUG
     parent->Properties().Delete(nsContainerFrame::DebugReflowingWithInfiniteISize());
 #endif
   return childSize.BSize(wm);
 }
 
 /**
@@ -4559,45 +4559,45 @@ nsGridContainerFrame::GridReflowInput::C
  * continue traversing the ancestor chain as long as the CBs have
  * the same writing-mode and have overflow:visible.
  */
 Maybe<nsGridContainerFrame::Fragmentainer>
 nsGridContainerFrame::GetNearestFragmentainer(const GridReflowInput& aState) const
 {
   Maybe<nsGridContainerFrame::Fragmentainer> data;
   WritingMode wm = aState.mWM;
-  const ReflowInput* gridRS = aState.mReflowInput;
-  const ReflowInput* cbRS = gridRS->mCBReflowInput;
+  const ReflowInput* gridRI = aState.mReflowInput;
+  const ReflowInput* cbRS = gridRI->mCBReflowInput;
   for ( ; cbRS; cbRS = cbRS->mCBReflowInput) {
     nsIScrollableFrame* sf = do_QueryFrame(cbRS->mFrame);
     if (sf) {
       break;
     }
     if (wm.IsOrthogonalTo(cbRS->GetWritingMode())) {
       break;
     }
     nsIAtom* frameType = cbRS->mFrame->GetType();
     if ((frameType == nsGkAtoms::canvasFrame &&
          PresContext()->IsPaginated()) ||
         frameType == nsGkAtoms::columnSetFrame) {
       data.emplace();
-      data->mIsTopOfPage = gridRS->mFlags.mIsTopOfPage;
+      data->mIsTopOfPage = gridRI->mFlags.mIsTopOfPage;
       data->mToFragmentainerEnd = aState.mFragBStart +
-        gridRS->AvailableBSize() - aState.mBorderPadding.BStart(wm);
+        gridRI->AvailableBSize() - aState.mBorderPadding.BStart(wm);
       const auto numRows = aState.mRows.mSizes.Length();
       data->mCanBreakAtStart =
         numRows > 0 && aState.mRows.mSizes[0].mPosition > 0;
-      nscoord bSize = gridRS->ComputedBSize();
+      nscoord bSize = gridRI->ComputedBSize();
       data->mIsAutoBSize = bSize == NS_AUTOHEIGHT;
       if (data->mIsAutoBSize) {
-        bSize = gridRS->ComputedMinBSize();
+        bSize = gridRI->ComputedMinBSize();
       } else {
         bSize = NS_CSS_MINMAX(bSize,
-                              gridRS->ComputedMinBSize(),
-                              gridRS->ComputedMaxBSize());
+                              gridRI->ComputedMinBSize(),
+                              gridRI->ComputedMaxBSize());
       }
       nscoord gridEnd =
         aState.mRows.GridLineEdge(numRows, GridLineSide::eBeforeGridGap);
       data->mCanBreakAtEnd = bSize > gridEnd &&
                              bSize > aState.mFragBStart;
       break;
     }
   }
@@ -4688,78 +4688,78 @@ nsGridContainerFrame::ReflowInFlowChild(
     reflowSize.BSize(wm) = toFragmentainerEnd;
   }
   LogicalSize childCBSize = reflowSize.ConvertTo(childWM, wm);
   if (!isConstrainedBSize) {
     childCBSize.BSize(childWM) = NS_UNCONSTRAINEDSIZE;
   }
 
   LogicalSize percentBasis(cb.Size(wm).ConvertTo(childWM, wm));
-  ReflowInput childRS(pc, *aState.mReflowInput, aChild, childCBSize,
+  ReflowInput childRI(pc, *aState.mReflowInput, aChild, childCBSize,
                             &percentBasis);
-  childRS.mFlags.mIsTopOfPage = aFragmentainer ? aFragmentainer->mIsTopOfPage : false;
+  childRI.mFlags.mIsTopOfPage = aFragmentainer ? aFragmentainer->mIsTopOfPage : false;
 
   // If the child is stretching in its block axis, and we might be fragmenting
   // it in that axis, then setup a frame property to tell
   // nsBlockFrame::ComputeFinalSize the size.
   if (isConstrainedBSize && !wm.IsOrthogonalTo(childWM)) {
     bool stretch = false;
-    if (!childRS.mStyleMargin->HasBlockAxisAuto(childWM) &&
-        childRS.mStylePosition->BSize(childWM).GetUnit() == eStyleUnit_Auto) {
+    if (!childRI.mStyleMargin->HasBlockAxisAuto(childWM) &&
+        childRI.mStylePosition->BSize(childWM).GetUnit() == eStyleUnit_Auto) {
       auto blockAxisAlignment =
-        childRS.mStylePosition->ComputedAlignSelf(StyleContext());
+        childRI.mStylePosition->ComputedAlignSelf(StyleContext());
       if (blockAxisAlignment == NS_STYLE_ALIGN_NORMAL ||
           blockAxisAlignment == NS_STYLE_ALIGN_STRETCH) {
         stretch = true;
       }
     }
     if (stretch) {
       aChild->Properties().Set(FragStretchBSizeProperty(), *aStretchBSize);
     } else {
       aChild->Properties().Delete(FragStretchBSizeProperty());
     }
   }
 
   // We need the width of the child before we can correctly convert
   // the writing-mode of its origin, so we reflow at (0, 0) using a dummy
   // aContainerSize, and then pass the correct position to FinishReflowChild.
-  ReflowOutput childSize(childRS);
+  ReflowOutput childSize(childRI);
   const nsSize dummyContainerSize;
-  ReflowChild(aChild, pc, childSize, childRS, childWM, LogicalPoint(childWM),
+  ReflowChild(aChild, pc, childSize, childRI, childWM, LogicalPoint(childWM),
               dummyContainerSize, 0, aStatus);
   LogicalPoint childPos =
     cb.Origin(wm).ConvertTo(childWM, wm,
                             aContainerSize - childSize.PhysicalSize());
   // Apply align/justify-self and reflow again if that affects the size.
   if (MOZ_LIKELY(isGridItem)) {
     LogicalSize size = childSize.Size(childWM); // from the ReflowChild()
     if (NS_FRAME_IS_COMPLETE(aStatus)) {
-      auto align = childRS.mStylePosition->ComputedAlignSelf(containerSC);
+      auto align = childRI.mStylePosition->ComputedAlignSelf(containerSC);
       auto state = aGridItemInfo->mState[eLogicalAxisBlock];
       if (state & ItemState::eContentBaseline) {
         align = (state & ItemState::eFirstBaseline) ? NS_STYLE_ALIGN_SELF_START
                                                     : NS_STYLE_ALIGN_SELF_END;
       }
       nscoord cbsz = cb.BSize(wm) - consumedGridAreaBSize;
-      AlignSelf(*aGridItemInfo, align, cbsz, wm, childRS, size, &childPos);
-    }
-    auto justify = childRS.mStylePosition->ComputedJustifySelf(containerSC);
+      AlignSelf(*aGridItemInfo, align, cbsz, wm, childRI, size, &childPos);
+    }
+    auto justify = childRI.mStylePosition->ComputedJustifySelf(containerSC);
     auto state = aGridItemInfo->mState[eLogicalAxisInline];
     if (state & ItemState::eContentBaseline) {
       justify = (state & ItemState::eFirstBaseline) ? NS_STYLE_JUSTIFY_SELF_START
                                                     : NS_STYLE_JUSTIFY_SELF_END;
     }
     nscoord cbsz = cb.ISize(wm);
-    JustifySelf(*aGridItemInfo, justify, cbsz, wm, childRS, size, &childPos);
+    JustifySelf(*aGridItemInfo, justify, cbsz, wm, childRI, size, &childPos);
   } else {
     // Put a placeholder at the padding edge, in case an ancestor is its CB.
     childPos -= padStart;
   }
-  childRS.ApplyRelativePositioning(&childPos, aContainerSize);
-  FinishReflowChild(aChild, pc, childSize, &childRS, childWM, childPos,
+  childRI.ApplyRelativePositioning(&childPos, aContainerSize);
+  FinishReflowChild(aChild, pc, childSize, &childRI, childWM, childPos,
                     aContainerSize, 0);
   ConsiderChildOverflow(aDesiredSize.mOverflowAreas, aChild);
 }
 
 nscoord
 nsGridContainerFrame::ReflowInFragmentainer(GridReflowInput&     aState,
                                             const LogicalRect&   aContentArea,
                                             ReflowOutput& aDesiredSize,

--- a/layout/generic/nsLineLayout.cpp
+++ b/layout/generic/nsLineLayout.cpp
@@ -58,17 +58,17 @@ nsLineLayout::nsLineLayout(nsPresContext
                            const nsLineList::iterator* aLine,
                            nsLineLayout* aBaseLineLayout)
   : mPresContext(aPresContext),
     mFloatManager(aFloatManager),
     mBlockReflowInput(aOuterReflowInput),
     mBaseLineLayout(aBaseLineLayout),
     mLastOptionalBreakFrame(nullptr),
     mForceBreakFrame(nullptr),
-    mBlockRS(nullptr),/* XXX temporary */
+    mBlockRI(nullptr),/* XXX temporary */
     mLastOptionalBreakPriority(gfxBreakPriority::eNoBreak),
     mLastOptionalBreakFrameOffset(-1),
     mForceBreakFrameOffset(-1),
     mMinLineBSize(0),
     mTextIndent(0),
     mFirstLetterStyleOK(false),
     mIsTopOfPage(false),
     mImpactedByFloats(false),

--- a/layout/generic/nsLineLayout.h
+++ b/layout/generic/nsLineLayout.h
@@ -41,17 +41,17 @@ public:
                nsFloatManager* aFloatManager,
                const ReflowInput* aOuterReflowInput,
                const nsLineList::iterator* aLine,
                nsLineLayout* aBaseLineLayout);
   ~nsLineLayout();
 
   void Init(BlockReflowInput* aState, nscoord aMinLineBSize,
             int32_t aLineNumber) {
-    mBlockRS = aState;
+    mBlockRI = aState;
     mMinLineBSize = aMinLineBSize;
     mLineNumber = aLineNumber;
   }
 
   int32_t GetLineNumber() const {
     return mLineNumber;
   }
 
@@ -179,20 +179,20 @@ public:
   // Inform the line-layout about the presence of a floating frame
   // XXX get rid of this: use get-frame-type?
   bool AddFloat(nsIFrame* aFloat, nscoord aAvailableISize)
   {
     // When reflowing ruby text frames, no block reflow state is
     // provided to the line layout. However, floats should never be
     // associated with ruby text containers, hence this method should
     // not be called in that case.
-    MOZ_ASSERT(mBlockRS,
+    MOZ_ASSERT(mBlockRI,
                "Should not call this method if there is no block reflow state "
                "available");
-    return mBlockRS->AddFloat(this, aFloat, aAvailableISize);
+    return mBlockRI->AddFloat(this, aFloat, aAvailableISize);
   }
 
   void SetTrimmableISize(nscoord aTrimmableISize) {
     mTrimmableISize = aTrimmableISize;
   }
 
   //----------------------------------------
 
@@ -338,17 +338,17 @@ public:
   }
 
   /**
    * This can't be null. It usually returns a block frame but may return
    * some other kind of frame when inline frames are reflowed in a non-block
    * context (e.g. MathML or floating first-letter).
    */
   nsIFrame* LineContainerFrame() const { return mBlockReflowInput->mFrame; }
-  const ReflowInput* LineContainerRS() const { return mBlockReflowInput; }
+  const ReflowInput* LineContainerRI() const { return mBlockReflowInput; }
   const nsLineList::iterator* GetLine() const {
     return mGotLineBox ? &mLineBox : nullptr;
   }
   nsLineList::iterator* GetLine() {
     return mGotLineBox ? &mLineBox : nullptr;
   }
   
   /**
@@ -407,17 +407,17 @@ protected:
   
   // XXX remove this when landing bug 154892 (splitting absolute positioned frames)
   friend class nsInlineFrame;
 
   // XXX Take care that nsRubyBaseContainer would give nullptr to this
   //     member. It should not be a problem currently, since the only
   //     code use it is handling float, which does not affect ruby.
   //     See comment in nsLineLayout::AddFloat
-  BlockReflowInput* mBlockRS;/* XXX hack! */
+  BlockReflowInput* mBlockRI;/* XXX hack! */
 
   nsLineList::iterator mLineBox;
 
   // Per-frame data recorded by the line-layout reflow logic. This
   // state is the state needed to post-process the line after reflow
   // has completed (block-direction alignment, inline-direction alignment,
   // justification and relative positioning).
 

--- a/layout/generic/nsRubyBaseContainerFrame.cpp
+++ b/layout/generic/nsRubyBaseContainerFrame.cpp
@@ -355,17 +355,17 @@ nsRubyBaseContainerFrame::Reflow(nsPresC
                                                 reflowInput->mFloatManager,
                                                 reflowInput, nullptr,
                                                 aReflowInput.mLineLayout);
     lineLayout->SetSuppressLineWrap(true);
     lineLayouts.AppendElement(lineLayout);
 
     // Line number is useless for ruby text
     // XXX nullptr here may cause problem, see comments for
-    //     nsLineLayout::mBlockRS and nsLineLayout::AddFloat
+    //     nsLineLayout::mBlockRI and nsLineLayout::AddFloat
     lineLayout->Init(nullptr, reflowInput->CalcLineHeight(), -1);
     reflowInput->mLineLayout = lineLayout;
 
     // Border and padding are suppressed on ruby text containers.
     // If the writing mode is vertical-rl, the horizontal position of
     // rt frames will be updated when reflowing this text container,
     // hence leave container size 0 here for now.
     lineLayout->BeginLineReflow(0, 0, reflowInput->ComputedISize(),

--- a/layout/generic/nsTextFrame.cpp
+++ b/layout/generic/nsTextFrame.cpp
@@ -9162,17 +9162,17 @@ nsTextFrame::ReflowText(nsLineLayout& aL
     boundingBox.y += mAscent;
   }
   aMetrics.SetOverflowAreasToDesiredBounds();
   aMetrics.VisualOverflow().UnionRect(aMetrics.VisualOverflow(), boundingBox);
 
   // When we have text decorations, we don't need to compute their overflow now
   // because we're guaranteed to do it later
   // (see nsLineLayout::RelativePositionFrames)
-  UnionAdditionalOverflow(presContext, aLineLayout.LineContainerRS()->mFrame,
+  UnionAdditionalOverflow(presContext, aLineLayout.LineContainerRI()->mFrame,
                           provider, &aMetrics.VisualOverflow(), false);
 
   /////////////////////////////////////////////////////////////////////
   // Clean up, update state
   /////////////////////////////////////////////////////////////////////
 
   // If all our characters are discarded or collapsed, then trimmable width
   // from the last textframe should be preserved. Otherwise the trimmable width

--- a/layout/tables/nsTableCellFrame.cpp
+++ b/layout/tables/nsTableCellFrame.cpp
@@ -113,41 +113,41 @@ nsTableCellFrame::NotifyPercentBSize(con
   // ReflowInput ensures the mCBReflowInput of blocks inside a
   // cell is the cell frame, not the inner-cell block, and that the
   // containing block of an inner table is the containing block of its
   // table wrapper.
   // XXXldb Given the now-stricter |NeedsToObserve|, many if not all of
   // these tests are probably unnecessary.
 
   // Maybe the cell reflow state; we sure if we're inside the |if|.
-  const ReflowInput *cellRS = aReflowInput.mCBReflowInput;
+  const ReflowInput *cellRI = aReflowInput.mCBReflowInput;
 
-  if (cellRS && cellRS->mFrame == this &&
-      (cellRS->ComputedBSize() == NS_UNCONSTRAINEDSIZE ||
-       cellRS->ComputedBSize() == 0)) { // XXXldb Why 0?
+  if (cellRI && cellRI->mFrame == this &&
+      (cellRI->ComputedBSize() == NS_UNCONSTRAINEDSIZE ||
+       cellRI->ComputedBSize() == 0)) { // XXXldb Why 0?
     // This is a percentage bsize on a frame whose percentage bsizes
     // are based on the bsize of the cell, since its containing block
     // is the inner cell frame.
 
     // We'll only honor the percent bsize if sibling-cells/ancestors
     // have specified/pct bsize. (Also, siblings only count for this if
     // both this cell and the sibling cell span exactly 1 row.)
 
-    if (nsTableFrame::AncestorsHaveStyleBSize(*cellRS) ||
+    if (nsTableFrame::AncestorsHaveStyleBSize(*cellRI) ||
         (GetTableFrame()->GetEffectiveRowSpan(*this) == 1 &&
-         cellRS->mParentReflowInput->mFrame->
+         cellRI->mParentReflowInput->mFrame->
            HasAnyStateBits(NS_ROW_HAS_CELL_WITH_STYLE_BSIZE))) {
 
       for (const ReflowInput *rs = aReflowInput.mParentReflowInput;
-           rs != cellRS;
+           rs != cellRI;
            rs = rs->mParentReflowInput) {
         rs->mFrame->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);
       }
 
-      nsTableFrame::RequestSpecialBSizeReflow(*cellRS);
+      nsTableFrame::RequestSpecialBSizeReflow(*cellRI);
     }
   }
 }
 
 // The cell needs to observe its block and things inside its block but nothing below that
 bool
 nsTableCellFrame::NeedsToObserve(const ReflowInput& aReflowInput)
 {

--- a/layout/tables/nsTableRowGroupFrame.cpp
+++ b/layout/tables/nsTableRowGroupFrame.cpp
@@ -1587,24 +1587,24 @@ nsTableRowGroupFrame::GetBSizeBasis(cons
   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* parentRS = aReflowInput.mParentReflowInput;
-    if (parentRS && (tableFrame != parentRS->mFrame)) {
-      parentRS = parentRS->mParentReflowInput;
+    const ReflowInput* parentRI = aReflowInput.mParentReflowInput;
+    if (parentRI && (tableFrame != parentRI->mFrame)) {
+      parentRI = parentRI->mParentReflowInput;
     }
-    if (parentRS && (tableFrame == parentRS->mFrame) &&
-        (parentRS->ComputedBSize() > 0) && (parentRS->ComputedBSize() < NS_UNCONSTRAINEDSIZE)) {
+    if (parentRI && (tableFrame == parentRI->mFrame) &&
+        (parentRI->ComputedBSize() > 0) && (parentRI->ComputedBSize() < NS_UNCONSTRAINEDSIZE)) {
       nscoord cellSpacing = tableFrame->GetRowSpacing(-1, tableFrame->GetRowCount());
-      result = parentRS->ComputedBSize() - cellSpacing;
+      result = parentRI->ComputedBSize() - cellSpacing;
     }
   }
 
   return result;
 }
 
 bool
 nsTableRowGroupFrame::IsSimpleRowFrame(nsTableFrame* aTableFrame,

--- a/layout/tables/nsTableWrapperFrame.cpp
+++ b/layout/tables/nsTableWrapperFrame.cpp
@@ -245,43 +245,43 @@ nsTableWrapperFrame::InitChildReflowInpu
   }
   aReflowInput.Init(&aPresContext, nullptr, pCollapseBorder, pCollapsePadding);
 }
 
 // get the margin and padding data. ReflowInput doesn't handle the
 // case of auto margins
 void
 nsTableWrapperFrame::GetChildMargin(nsPresContext*           aPresContext,
-                                    const ReflowInput& aOuterRS,
+                                    const ReflowInput& aOuterRI,
                                     nsIFrame*                aChildFrame,
                                     nscoord                  aAvailISize,
                                     LogicalMargin&           aMargin)
 {
   NS_ASSERTION(!aChildFrame->IsTableCaption(),
                "didn't expect caption frame; writing-mode may be wrong!");
 
   // construct a reflow state to compute margin and padding. Auto margins
   // will not be computed at this time.
 
   // create and init the child reflow state
   // XXX We really shouldn't construct a reflow state to do this.
-  WritingMode wm = aOuterRS.GetWritingMode();
-  LogicalSize availSize(wm, aAvailISize, aOuterRS.AvailableSize(wm).BSize(wm));
-  ReflowInput childRS(aPresContext, aOuterRS, aChildFrame, availSize,
+  WritingMode wm = aOuterRI.GetWritingMode();
+  LogicalSize availSize(wm, aAvailISize, aOuterRI.AvailableSize(wm).BSize(wm));
+  ReflowInput childRI(aPresContext, aOuterRI, aChildFrame, availSize,
                             nullptr, ReflowInput::CALLER_WILL_INIT);
-  InitChildReflowInput(*aPresContext, childRS);
+  InitChildReflowInput(*aPresContext, childRI);
 
-  aMargin = childRS.ComputedLogicalMargin();
+  aMargin = childRI.ComputedLogicalMargin();
 }
 
 static nsSize
-GetContainingBlockSize(const ReflowInput& aOuterRS)
+GetContainingBlockSize(const ReflowInput& aOuterRI)
 {
   nsSize size(0,0);
-  const ReflowInput* containRS = aOuterRS.mCBReflowInput;
+  const ReflowInput* containRS = aOuterRI.mCBReflowInput;
 
   if (containRS) {
     size.width = containRS->ComputedWidth();
     if (NS_UNCONSTRAINEDSIZE == size.width) {
       size.width = 0;
     }
     size.height = containRS->ComputedHeight();
     if (NS_UNCONSTRAINEDSIZE == size.height) {
@@ -727,122 +727,122 @@ nsTableWrapperFrame::GetInnerOrigin(uint
       break;
   }
   return NS_OK;
 }
 
 void
 nsTableWrapperFrame::OuterBeginReflowChild(nsPresContext*            aPresContext,
                                            nsIFrame*                 aChildFrame,
-                                           const ReflowInput&  aOuterRS,
-                                           Maybe<ReflowInput>& aChildRS,
+                                           const ReflowInput&  aOuterRI,
+                                           Maybe<ReflowInput>& aChildRI,
                                            nscoord                   aAvailISize)
 {
   // work around pixel rounding errors, round down to ensure we don't exceed the avail height in
   WritingMode wm = aChildFrame->GetWritingMode();
-  LogicalSize outerSize = aOuterRS.AvailableSize(wm);
+  LogicalSize outerSize = aOuterRI.AvailableSize(wm);
   nscoord availBSize = outerSize.BSize(wm);
   if (NS_UNCONSTRAINEDSIZE != availBSize) {
     if (mCaptionFrames.FirstChild() == aChildFrame) {
       availBSize = NS_UNCONSTRAINEDSIZE;
     } else {
       LogicalMargin margin(wm);
-      GetChildMargin(aPresContext, aOuterRS, aChildFrame,
+      GetChildMargin(aPresContext, aOuterRI, aChildFrame,
                      outerSize.ISize(wm), margin);
 
       NS_ASSERTION(NS_UNCONSTRAINEDSIZE != margin.BStart(wm),
                    "No unconstrainedsize arithmetic, please");
       availBSize -= margin.BStart(wm);
 
       NS_ASSERTION(NS_UNCONSTRAINEDSIZE != margin.BEnd(wm),
                    "No unconstrainedsize arithmetic, please");
       availBSize -= margin.BEnd(wm);
     }
   }
   LogicalSize availSize(wm, aAvailISize, availBSize);
   // create and init the child reflow state, using passed-in Maybe<>,
   // so that caller can use it after we return.
-  aChildRS.emplace(aPresContext, aOuterRS, aChildFrame, availSize,
+  aChildRI.emplace(aPresContext, aOuterRI, aChildFrame, availSize,
                   nullptr, ReflowInput::CALLER_WILL_INIT);
-  InitChildReflowInput(*aPresContext, *aChildRS);
+  InitChildReflowInput(*aPresContext, *aChildRI);
 
   // see if we need to reset top-of-page due to a caption
-  if (aChildRS->mFlags.mIsTopOfPage &&
+  if (aChildRI->mFlags.mIsTopOfPage &&
       mCaptionFrames.FirstChild() == aChildFrame) {
     uint8_t captionSide = GetCaptionSide();
     if (captionSide == NS_STYLE_CAPTION_SIDE_BOTTOM ||
         captionSide == NS_STYLE_CAPTION_SIDE_BOTTOM_OUTSIDE) {
-      aChildRS->mFlags.mIsTopOfPage = false;
+      aChildRI->mFlags.mIsTopOfPage = false;
     }
   }
 }
 
 void
 nsTableWrapperFrame::OuterDoReflowChild(nsPresContext*             aPresContext,
                                         nsIFrame*                  aChildFrame,
-                                        const ReflowInput&   aChildRS,
+                                        const ReflowInput&   aChildRI,
                                         ReflowOutput&       aMetrics,
                                         nsReflowStatus&            aStatus)
 {
   // Using zero as containerSize here because we want consistency between
   // the GetLogicalPosition and ReflowChild calls, to avoid unnecessarily
   // changing the frame's coordinates; but we don't yet know its final
   // position anyway so the actual value is unimportant.
   const nsSize zeroCSize;
-  WritingMode wm = aChildRS.GetWritingMode();
+  WritingMode wm = aChildRI.GetWritingMode();
 
   // Use the current position as a best guess for placement.
   LogicalPoint childPt = aChildFrame->GetLogicalPosition(wm, zeroCSize);
   uint32_t flags = NS_FRAME_NO_MOVE_FRAME;
 
   // We don't want to delete our next-in-flow's child if it's an inner table
   // frame, because table wrapper frames always assume that their inner table
   // frames don't go away. If a table wrapper frame is removed because it is
   // a next-in-flow of an already complete table wrapper frame, then it will
   // take care of removing it's inner table frame.
   if (aChildFrame == InnerTableFrame()) {
     flags |= NS_FRAME_NO_DELETE_NEXT_IN_FLOW_CHILD;
   }
 
-  ReflowChild(aChildFrame, aPresContext, aMetrics, aChildRS,
+  ReflowChild(aChildFrame, aPresContext, aMetrics, aChildRI,
               wm, childPt, zeroCSize, flags, aStatus);
 }
 
 void
 nsTableWrapperFrame::UpdateOverflowAreas(ReflowOutput& aMet)
 {
   aMet.SetOverflowAreasToDesiredBounds();
   ConsiderChildOverflow(aMet.mOverflowAreas, InnerTableFrame());
   if (mCaptionFrames.NotEmpty()) {
     ConsiderChildOverflow(aMet.mOverflowAreas, mCaptionFrames.FirstChild());
   }
 }
 
 void
 nsTableWrapperFrame::Reflow(nsPresContext*           aPresContext,
                             ReflowOutput&     aDesiredSize,
-                            const ReflowInput& aOuterRS,
+                            const ReflowInput& aOuterRI,
                             nsReflowStatus&          aStatus)
 {
   MarkInReflow();
   DO_GLOBAL_REFLOW_COUNT("nsTableWrapperFrame");
-  DISPLAY_REFLOW(aPresContext, this, aOuterRS, aDesiredSize, aStatus);
+  DISPLAY_REFLOW(aPresContext, this, aOuterRI, aDesiredSize, aStatus);
 
   // Initialize out parameters
   aDesiredSize.ClearSize();
   aStatus = NS_FRAME_COMPLETE;
 
   if (!HasAnyStateBits(NS_FRAME_FIRST_REFLOW)) {
     // Set up our kids.  They're already present, on an overflow list,
     // or there are none so we'll create them now
     MoveOverflowToChildList();
   }
 
-  Maybe<ReflowInput> captionRS;
-  Maybe<ReflowInput> innerRS;
+  Maybe<ReflowInput> captionRI;
+  Maybe<ReflowInput> innerRI;
 
   nsRect origInnerRect = InnerTableFrame()->GetRect();
   nsRect origInnerVisualOverflow = InnerTableFrame()->GetVisualOverflowRect();
   bool innerFirstReflow =
     InnerTableFrame()->HasAnyStateBits(NS_FRAME_FIRST_REFLOW);
   nsRect origCaptionRect;
   nsRect origCaptionVisualOverflow;
   bool captionFirstReflow;
@@ -850,110 +850,110 @@ nsTableWrapperFrame::Reflow(nsPresContex
     origCaptionRect = mCaptionFrames.FirstChild()->GetRect();
     origCaptionVisualOverflow =
       mCaptionFrames.FirstChild()->GetVisualOverflowRect();
     captionFirstReflow =
       mCaptionFrames.FirstChild()->HasAnyStateBits(NS_FRAME_FIRST_REFLOW);
   }
   
   // ComputeAutoSize has to match this logic.
-  WritingMode wm = aOuterRS.GetWritingMode();
+  WritingMode wm = aOuterRI.GetWritingMode();
   uint8_t captionSide = GetCaptionSide();
   WritingMode captionWM = wm; // will be changed below if necessary
 
   if (captionSide == NO_SIDE) {
     // We don't have a caption.
-    OuterBeginReflowChild(aPresContext, InnerTableFrame(), aOuterRS,
-                          innerRS, aOuterRS.ComputedSize(wm).ISize(wm));
+    OuterBeginReflowChild(aPresContext, InnerTableFrame(), aOuterRI,
+                          innerRI, aOuterRI.ComputedSize(wm).ISize(wm));
   } else if (captionSide == NS_STYLE_CAPTION_SIDE_LEFT ||
              captionSide == NS_STYLE_CAPTION_SIDE_RIGHT) {
     // ComputeAutoSize takes care of making side captions small. Compute
     // the caption's size first, and tell the table to fit in what's left.
-    OuterBeginReflowChild(aPresContext, mCaptionFrames.FirstChild(), aOuterRS,
-                          captionRS, aOuterRS.ComputedSize(wm).ISize(wm));
-    captionWM = captionRS->GetWritingMode();
-    nscoord innerAvailISize = aOuterRS.ComputedSize(wm).ISize(wm) -
-      captionRS->ComputedSizeWithMarginBorderPadding(wm).ISize(wm);
-    OuterBeginReflowChild(aPresContext, InnerTableFrame(), aOuterRS,
-                          innerRS, innerAvailISize);
+    OuterBeginReflowChild(aPresContext, mCaptionFrames.FirstChild(), aOuterRI,
+                          captionRI, aOuterRI.ComputedSize(wm).ISize(wm));
+    captionWM = captionRI->GetWritingMode();
+    nscoord innerAvailISize = aOuterRI.ComputedSize(wm).ISize(wm) -
+      captionRI->ComputedSizeWithMarginBorderPadding(wm).ISize(wm);
+    OuterBeginReflowChild(aPresContext, InnerTableFrame(), aOuterRI,
+                          innerRI, innerAvailISize);
   } else if (captionSide == NS_STYLE_CAPTION_SIDE_TOP ||
              captionSide == NS_STYLE_CAPTION_SIDE_BOTTOM) {
     // Compute the table's size first, and then prevent the caption from
     // being larger in the inline dir unless it has to be.
     //
     // Note that CSS 2.1 (but not 2.0) says:
     //   The width of the anonymous box is the border-edge width of the
     //   table box inside it
     // We don't actually make our anonymous box that isize (if we did,
     // it would break 'auto' margins), but this effectively does that.
-    OuterBeginReflowChild(aPresContext, InnerTableFrame(), aOuterRS,
-                          innerRS, aOuterRS.ComputedSize(wm).ISize(wm));
+    OuterBeginReflowChild(aPresContext, InnerTableFrame(), aOuterRI,
+                          innerRI, aOuterRI.ComputedSize(wm).ISize(wm));
     // It's good that CSS 2.1 says not to include margins, since we
     // can't, since they already been converted so they exactly
     // fill the available isize (ignoring the margin on one side if
     // neither are auto).  (We take advantage of that later when we call
     // GetCaptionOrigin, though.)
     nscoord innerBorderISize =
-      innerRS->ComputedSizeWithBorderPadding(wm).ISize(wm);
-    OuterBeginReflowChild(aPresContext, mCaptionFrames.FirstChild(), aOuterRS,
-                          captionRS, innerBorderISize);
-    captionWM = captionRS->GetWritingMode();
+      innerRI->ComputedSizeWithBorderPadding(wm).ISize(wm);
+    OuterBeginReflowChild(aPresContext, mCaptionFrames.FirstChild(), aOuterRI,
+                          captionRI, innerBorderISize);
+    captionWM = captionRI->GetWritingMode();
   } else {
     NS_ASSERTION(captionSide == NS_STYLE_CAPTION_SIDE_TOP_OUTSIDE ||
                  captionSide == NS_STYLE_CAPTION_SIDE_BOTTOM_OUTSIDE,
                  "unexpected caption-side");
     // Size the table and the caption independently.
     captionWM = mCaptionFrames.FirstChild()->GetWritingMode();
     OuterBeginReflowChild(aPresContext, mCaptionFrames.FirstChild(),
-                          aOuterRS, captionRS,
-                          aOuterRS.ComputedSize(captionWM).ISize(captionWM));
-    OuterBeginReflowChild(aPresContext, InnerTableFrame(), aOuterRS,
-                          innerRS, aOuterRS.ComputedSize(wm).ISize(wm));
+                          aOuterRI, captionRI,
+                          aOuterRI.ComputedSize(captionWM).ISize(captionWM));
+    OuterBeginReflowChild(aPresContext, InnerTableFrame(), aOuterRI,
+                          innerRI, aOuterRI.ComputedSize(wm).ISize(wm));
   }
 
   // First reflow the caption.
   Maybe<ReflowOutput> captionMet;
   LogicalSize captionSize(wm);
   LogicalMargin captionMargin(wm);
   if (mCaptionFrames.NotEmpty()) {
     captionMet.emplace(wm);
     nsReflowStatus capStatus; // don't let the caption cause incomplete
     OuterDoReflowChild(aPresContext, mCaptionFrames.FirstChild(),
-                       *captionRS, *captionMet, capStatus);
+                       *captionRI, *captionMet, capStatus);
     captionSize.ISize(wm) = captionMet->ISize(wm);
     captionSize.BSize(wm) = captionMet->BSize(wm);
     captionMargin =
-      captionRS->ComputedLogicalMargin().ConvertTo(wm, captionWM);
+      captionRI->ComputedLogicalMargin().ConvertTo(wm, captionWM);
     // Now that we know the bsize of the caption, reduce the available bsize
     // for the table frame if we are bsize constrained and the caption is above
     // or below the inner table.
-    if (NS_UNCONSTRAINEDSIZE != aOuterRS.AvailableBSize()) {
+    if (NS_UNCONSTRAINEDSIZE != aOuterRI.AvailableBSize()) {
       nscoord captionBSize = 0;
       switch (captionSide) {
         case NS_STYLE_CAPTION_SIDE_TOP:
         case NS_STYLE_CAPTION_SIDE_BOTTOM:
         case NS_STYLE_CAPTION_SIDE_TOP_OUTSIDE:
         case NS_STYLE_CAPTION_SIDE_BOTTOM_OUTSIDE:
           captionBSize = captionSize.BSize(wm) + captionMargin.BStartEnd(wm);
           break;
       }
-      innerRS->AvailableBSize() =
-        std::max(0, innerRS->AvailableBSize() - captionBSize);
+      innerRI->AvailableBSize() =
+        std::max(0, innerRI->AvailableBSize() - captionBSize);
     }
   }
 
   // Then, now that we know how much to reduce the isize of the inner
   // table to account for side captions, reflow the inner table.
-  ReflowOutput innerMet(innerRS->GetWritingMode());
-  OuterDoReflowChild(aPresContext, InnerTableFrame(), *innerRS,
+  ReflowOutput innerMet(innerRI->GetWritingMode());
+  OuterDoReflowChild(aPresContext, InnerTableFrame(), *innerRI,
                      innerMet, aStatus);
   LogicalSize innerSize(wm, innerMet.ISize(wm), innerMet.BSize(wm));
-  LogicalMargin innerMargin = innerRS->ComputedLogicalMargin();
+  LogicalMargin innerMargin = innerRI->ComputedLogicalMargin();
 
-  LogicalSize containSize(wm, GetContainingBlockSize(aOuterRS));
+  LogicalSize containSize(wm, GetContainingBlockSize(aOuterRI));
 
   // Now that we've reflowed both we can place them.
   // XXXldb Most of the input variables here are now uninitialized!
 
   // XXX Need to recompute inner table's auto margins for the case of side
   // captions.  (Caption's are broken too, but that should be fixed earlier.)
 
   // Compute the desiredSize so that we can use it as the containerSize
@@ -967,52 +967,52 @@ nsTableWrapperFrame::Reflow(nsPresContex
   // XXX It's possible for this to be NS_UNCONSTRAINEDSIZE, which will result
   // in assertions from FinishReflowChild.
 
   if (mCaptionFrames.NotEmpty()) {
     LogicalPoint captionOrigin(wm);
     GetCaptionOrigin(captionSide, containSize, innerSize, innerMargin,
                      captionSize, captionMargin, captionOrigin, wm);
     FinishReflowChild(mCaptionFrames.FirstChild(), aPresContext, *captionMet,
-                      captionRS.ptr(), wm, captionOrigin, containerSize, 0);
-    captionRS.reset();
+                      captionRI.ptr(), wm, captionOrigin, containerSize, 0);
+    captionRI.reset();
   }
   // XXX If the bsize is constrained then we need to check whether
   // everything still fits...
 
   LogicalPoint innerOrigin(wm);
   GetInnerOrigin(captionSide, containSize, captionSize, captionMargin,
                  innerSize, innerMargin, innerOrigin, wm);
-  FinishReflowChild(InnerTableFrame(), aPresContext, innerMet, innerRS.ptr(),
+  FinishReflowChild(InnerTableFrame(), aPresContext, innerMet, innerRI.ptr(),
                     wm, innerOrigin, containerSize, 0);
-  innerRS.reset();
+  innerRI.reset();
 
   nsTableFrame::InvalidateTableFrame(InnerTableFrame(), origInnerRect,
                                      origInnerVisualOverflow,
                                      innerFirstReflow);
   if (mCaptionFrames.NotEmpty()) {
     nsTableFrame::InvalidateTableFrame(mCaptionFrames.FirstChild(),
                                        origCaptionRect,
                                        origCaptionVisualOverflow,
                                        captionFirstReflow);
   }
 
   UpdateOverflowAreas(aDesiredSize);
 
   if (GetPrevInFlow()) {
-    ReflowOverflowContainerChildren(aPresContext, aOuterRS,
+    ReflowOverflowContainerChildren(aPresContext, aOuterRI,
                                     aDesiredSize.mOverflowAreas, 0,
                                     aStatus);
   }
 
-  FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize, aOuterRS, aStatus);
+  FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize, aOuterRI, aStatus);
 
   // Return our desired rect
 
-  NS_FRAME_SET_TRUNCATION(aStatus, aOuterRS, aDesiredSize);
+  NS_FRAME_SET_TRUNCATION(aStatus, aOuterRI, aDesiredSize);
 }
 
 nsIAtom*
 nsTableWrapperFrame::GetType() const
 {
   return nsGkAtoms::tableWrapperFrame;
 }
 

--- a/layout/tables/nsTableWrapperFrame.h
+++ b/layout/tables/nsTableWrapperFrame.h
@@ -226,32 +226,32 @@ protected:
                             const mozilla::LogicalSize&    aInnerSize,
                             mozilla::LogicalMargin&        aInnerMargin,
                             mozilla::LogicalPoint&         aOrigin,
                             mozilla::WritingMode           aWM);
   
   // reflow the child (caption or innertable frame)
   void OuterBeginReflowChild(nsPresContext*                     aPresContext,
                              nsIFrame*                          aChildFrame,
-                             const ReflowInput&           aOuterRS,
-                             mozilla::Maybe<ReflowInput>& aChildRS,
+                             const ReflowInput&           aOuterRI,
+                             mozilla::Maybe<ReflowInput>& aChildRI,
                              nscoord                            aAvailISize);
 
   void OuterDoReflowChild(nsPresContext*           aPresContext,
                           nsIFrame*                aChildFrame,
-                          const ReflowInput& aChildRS,
+                          const ReflowInput& aChildRI,
                           ReflowOutput&     aMetrics,
                           nsReflowStatus&          aStatus);
 
   // Set the overflow areas in our reflow metrics
   void UpdateOverflowAreas(ReflowOutput& aMet);
 
   // Get the margin.
   void GetChildMargin(nsPresContext*           aPresContext,
-                      const ReflowInput& aOuterRS,
+                      const ReflowInput& aOuterRI,
                       nsIFrame*                aChildFrame,
                       nscoord                  aAvailableWidth,
                       mozilla::LogicalMargin&  aMargin);
 
   virtual bool IsFrameOfType(uint32_t aFlags) const override
   {
     return nsContainerFrame::IsFrameOfType(aFlags &
                                            (~eCanContainOverflowContainers));