Bug 1277129 Part 2c - Rename nsBlockReflowState to BlockReflowInput. r=dbaron
authorTing-Yu Lin <tlin@mozilla.com>
Thu, 21 Jul 2016 18:36:36 +0800
changeset 331131 d8ef49c1d01eaf977a88583c6f65a4b1552363d2
parent 331130 3ae833bfcad42f7cb0671f7c645b2c1d9c8b2319
child 331132 64eb9c0b65c78c59609f6aaffb0f02148ff6b037
push id9858
push userjlund@mozilla.com
push dateMon, 01 Aug 2016 14:37:10 +0000
treeherdermozilla-aurora@203106ef6cb6 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersdbaron
bugs1277129
milestone50.0a1
Bug 1277129 Part 2c - Rename nsBlockReflowState to BlockReflowInput. r=dbaron This patch is generated by the following script: function rename() { find .\ -type f\ ! -path "./obj*"\ ! -path "./.git"\ ! -path "./.hg"\ \( -name "*.cpp" -or\ -name "*.h" \)\ -exec sed -i -e "s/$1/$2/g" "{}" \; } rename "nsBlockReflowState" "BlockReflowInput" MozReview-Commit-ID: FtjqkQpGfcI
layout/generic/BlockReflowInput.cpp
layout/generic/BlockReflowInput.h
layout/generic/nsBlockFrame.cpp
layout/generic/nsBlockFrame.h
layout/generic/nsBlockReflowContext.cpp
layout/generic/nsBlockReflowContext.h
layout/generic/nsFrameStateBits.h
layout/generic/nsLineLayout.h
--- a/layout/generic/BlockReflowInput.cpp
+++ b/layout/generic/BlockReflowInput.cpp
@@ -23,17 +23,17 @@
 #endif
 
 using namespace mozilla;
 using namespace mozilla::layout;
 
 static bool sFloatFragmentsInsideColumnEnabled;
 static bool sFloatFragmentsInsideColumnPrefCached;
 
-nsBlockReflowState::nsBlockReflowState(const ReflowInput& aReflowState,
+BlockReflowInput::BlockReflowInput(const ReflowInput& aReflowState,
                                        nsPresContext* aPresContext,
                                        nsBlockFrame* aFrame,
                                        bool aBStartMarginRoot,
                                        bool aBEndMarginRoot,
                                        bool aBlockNeedsFloatManager,
                                        nscoord aConsumedBSize)
   : mBlock(aFrame),
     mPresContext(aPresContext),
@@ -96,17 +96,17 @@ nsBlockReflowState::nsBlockReflowState(c
   }
   if (aBlockNeedsFloatManager) {
     SetFlag(BRS_FLOAT_MGR, true);
   }
   
   mFloatManager = aReflowState.mFloatManager;
 
   NS_ASSERTION(mFloatManager,
-               "FloatManager should be set in nsBlockReflowState" );
+               "FloatManager should be set in BlockReflowInput" );
   if (mFloatManager) {
     // Save the coordinate system origin for later.
     mFloatManager->GetTranslation(mFloatManagerI, mFloatManagerB);
     mFloatManager->PushState(&mFloatManagerStateBefore); // never popped
   }
 
   mReflowStatus = NS_FRAME_COMPLETE;
 
@@ -142,27 +142,27 @@ nsBlockReflowState::nsBlockReflowState(c
 
   mPrevChild = nullptr;
   mCurrentLine = aFrame->end_lines();
 
   mMinLineHeight = aReflowState.CalcLineHeight();
 }
 
 nscoord
-nsBlockReflowState::GetConsumedBSize()
+BlockReflowInput::GetConsumedBSize()
 {
   if (mConsumedBSize == NS_INTRINSICSIZE) {
     mConsumedBSize = mBlock->GetConsumedBSize();
   }
 
   return mConsumedBSize;
 }
 
 void
-nsBlockReflowState::ComputeReplacedBlockOffsetsForFloats(
+BlockReflowInput::ComputeReplacedBlockOffsetsForFloats(
                       nsIFrame* aFrame,
                       const LogicalRect& aFloatAvailableSpace,
                       nscoord& aIStartResult,
                       nscoord& aIEndResult) const
 {
   WritingMode wm = mReflowState.GetWritingMode();
   // The frame is clueless about the float manager and therefore we
   // only give it free space. An example is a table frame - the
@@ -217,17 +217,17 @@ GetBEndMarginClone(nsIFrame* aFrame,
   }
   return 0;
 }
 
 // Compute the amount of available space for reflowing a block frame
 // at the current Y coordinate. This method assumes that
 // GetAvailableSpace has already been called.
 void
-nsBlockReflowState::ComputeBlockAvailSpace(nsIFrame* aFrame,
+BlockReflowInput::ComputeBlockAvailSpace(nsIFrame* aFrame,
                                            const nsStyleDisplay* aDisplay,
                                            const nsFlowAreaRect& aFloatAvailableSpace,
                                            bool aBlockAvoidsFloats,
                                            LogicalRect& aResult)
 {
 #ifdef REALLY_NOISY_REFLOW
   printf("CBAS frame=%p has floats %d\n",
          aFrame, aFloatAvailableSpace.mHasFloats);
@@ -298,17 +298,17 @@ nsBlockReflowState::ComputeBlockAvailSpa
 
 #ifdef REALLY_NOISY_REFLOW
   printf("  CBAS: result %d %d %d %d\n", aResult.IStart(wm), aResult.BStart(wm),
          aResult.ISize(wm), aResult.BSize(wm));
 #endif
 }
 
 bool
-nsBlockReflowState::ReplacedBlockFitsInAvailSpace(nsIFrame* aReplacedBlock,
+BlockReflowInput::ReplacedBlockFitsInAvailSpace(nsIFrame* aReplacedBlock,
                             const nsFlowAreaRect& aFloatAvailableSpace) const
 {
   if (!aFloatAvailableSpace.mHasFloats) {
     // If there aren't any floats here, then we always fit.
     // We check this before calling ISizeToClearPastFloats, which is
     // somewhat expensive.
     return true;
   }
@@ -325,17 +325,17 @@ nsBlockReflowState::ReplacedBlockFitsInA
                   replacedISize.marginIStart) +
            replacedISize.borderBoxISize +
            (mContentArea.IEnd(wm) -
             aFloatAvailableSpace.mRect.IEnd(wm)) <=
          mContentArea.ISize(wm);
 }
 
 nsFlowAreaRect
-nsBlockReflowState::GetFloatAvailableSpaceWithState(
+BlockReflowInput::GetFloatAvailableSpaceWithState(
                       nscoord aBCoord,
                       nsFloatManager::SavedState *aState) const
 {
   WritingMode wm = mReflowState.GetWritingMode();
 #ifdef DEBUG
   // Verify that the caller setup the coordinate system properly
   nscoord wI, wB;
   mFloatManager->GetTranslation(wI, wB);
@@ -362,17 +362,17 @@ nsBlockReflowState::GetFloatAvailableSpa
            result.mRect.IStart(wm), result.mRect.BStart(wm),
            result.mRect.ISize(wm), result.mRect.BSize(wm), result.mHasFloats);
   }
 #endif
   return result;
 }
 
 nsFlowAreaRect
-nsBlockReflowState::GetFloatAvailableSpaceForBSize(
+BlockReflowInput::GetFloatAvailableSpaceForBSize(
                       nscoord aBCoord, nscoord aBSize,
                       nsFloatManager::SavedState *aState) const
 {
   WritingMode wm = mReflowState.GetWritingMode();
 #ifdef DEBUG
   // Verify that the caller setup the coordinate system properly
   nscoord wI, wB;
   mFloatManager->GetTranslation(wI, wB);
@@ -408,17 +408,17 @@ nsBlockReflowState::GetFloatAvailableSpa
  *
  * The reconstruction involves walking backward through the line list to
  * find any collapsed margins preceding the line that would have been in
  * the reflow state's |mPrevBEndMargin| when we reflowed that line in
  * a full reflow (under the rule in CSS2 that all adjacent vertical
  * margins of blocks collapse).
  */
 void
-nsBlockReflowState::ReconstructMarginBefore(nsLineList::iterator aLine)
+BlockReflowInput::ReconstructMarginBefore(nsLineList::iterator aLine)
 {
   mPrevBEndMargin.Zero();
   nsBlockFrame *block = mBlock;
 
   nsLineList::iterator firstLine = block->begin_lines();
   for (;;) {
     --aLine;
     if (aLine->IsBlock()) {
@@ -435,17 +435,17 @@ nsBlockReflowState::ReconstructMarginBef
         mPrevBEndMargin.Zero();
       }
       break;
     }
   }
 }
 
 void
-nsBlockReflowState::SetupPushedFloatList()
+BlockReflowInput::SetupPushedFloatList()
 {
   MOZ_ASSERT(!GetFlag(BRS_PROPTABLE_FLOATCLIST) == !mPushedFloats,
              "flag mismatch");
   if (!GetFlag(BRS_PROPTABLE_FLOATCLIST)) {
     // If we're being re-Reflow'd without our next-in-flow having been
     // reflowed, some pushed floats from our previous reflow might
     // still be on our pushed floats list.  However, that's
     // actually fine, since they'll all end up being stolen and
@@ -453,17 +453,17 @@ nsBlockReflowState::SetupPushedFloatList
     // (nsBlockFrame::ReflowDirtyLines ensures that any lines with
     // pushed floats are reflowed.)
     mPushedFloats = mBlock->EnsurePushedFloats();
     SetFlag(BRS_PROPTABLE_FLOATCLIST, true);
   }
 }
 
 void
-nsBlockReflowState::AppendPushedFloatChain(nsIFrame* aFloatCont)
+BlockReflowInput::AppendPushedFloatChain(nsIFrame* aFloatCont)
 {
   SetupPushedFloatList();
   while (true) {
     aFloatCont->AddStateBits(NS_FRAME_IS_PUSHED_FLOAT);
     mPushedFloats->AppendFrame(mBlock, aFloatCont);
     aFloatCont = aFloatCont->GetNextInFlow();
     if (!aFloatCont || aFloatCont->GetParent() != mBlock) {
       break;
@@ -477,17 +477,17 @@ nsBlockReflowState::AppendPushedFloatCha
  * Restore information about floats into the float manager for an
  * incremental reflow, and simultaneously push the floats by
  * |aDeltaBCoord|, which is the amount |aLine| was pushed relative to its
  * parent.  The recovery of state is one of the things that makes
  * incremental reflow O(N^2) and this state should really be kept
  * around, attached to the frame tree.
  */
 void
-nsBlockReflowState::RecoverFloats(nsLineList::iterator aLine,
+BlockReflowInput::RecoverFloats(nsLineList::iterator aLine,
                                   nscoord aDeltaBCoord)
 {
   WritingMode wm = mReflowState.GetWritingMode();
   if (aLine->HasFloats()) {
     // Place the floats into the space-manager again. Also slide
     // them, just like the regular frames on the line.
     nsFloatCache* fc = aLine->GetFirstFloat();
     while (fc) {
@@ -526,23 +526,23 @@ nsBlockReflowState::RecoverFloats(nsLine
 
 /**
  * Everything done in this function is done O(N) times for each pass of
  * reflow so it is O(N*M) where M is the number of incremental reflow
  * passes.  That's bad.  Don't do stuff here.
  *
  * When this function is called, |aLine| has just been slid by |aDeltaBCoord|
  * and the purpose of RecoverStateFrom is to ensure that the
- * nsBlockReflowState is in the same state that it would have been in
+ * BlockReflowInput is in the same state that it would have been in
  * had the line just been reflowed.
  *
  * Most of the state recovery that we have to do involves floats.
  */
 void
-nsBlockReflowState::RecoverStateFrom(nsLineList::iterator aLine,
+BlockReflowInput::RecoverStateFrom(nsLineList::iterator aLine,
                                      nscoord aDeltaBCoord)
 {
   // Make the line being recovered the current line
   mCurrentLine = aLine;
 
   // Place floats for this line into the float manager
   if (aLine->HasFloats() || aLine->IsBlock()) {
     RecoverFloats(aLine, aDeltaBCoord);
@@ -561,17 +561,17 @@ nsBlockReflowState::RecoverStateFrom(nsL
 // then the float is place immediately, otherwise the float
 // placement is deferred until the line has been reflowed.
 
 // XXXldb This behavior doesn't quite fit with CSS1 and CSS2 --
 // technically we're supposed let the current line flow around the
 // float as well unless it won't fit next to what we already have.
 // But nobody else implements it that way...
 bool
-nsBlockReflowState::AddFloat(nsLineLayout*       aLineLayout,
+BlockReflowInput::AddFloat(nsLineLayout*       aLineLayout,
                              nsIFrame*           aFloat,
                              nscoord             aAvailableISize)
 {
   NS_PRECONDITION(aLineLayout, "must have line layout");
   NS_PRECONDITION(mBlock->end_lines() != mCurrentLine, "null ptr");
   NS_PRECONDITION(aFloat->GetStateBits() & NS_FRAME_OUT_OF_FLOW,
                   "aFloat must be an out-of-flow frame");
 
@@ -652,17 +652,17 @@ nsBlockReflowState::AddFloat(nsLineLayou
 
   // Restore coordinate system
   mFloatManager->Translate(dI, dB);
 
   return placed;
 }
 
 bool
-nsBlockReflowState::CanPlaceFloat(nscoord aFloatISize,
+BlockReflowInput::CanPlaceFloat(nscoord aFloatISize,
                                   const nsFlowAreaRect& aFloatAvailableSpace)
 {
   // A float fits at a given block-dir position if there are no floats
   // at its inline-dir position (no matter what its inline size) or if
   // its inline size fits in the space remaining after prior floats have
   // been placed.
   // FIXME: We should allow overflow by up to half a pixel here (bug 21193).
   return !aFloatAvailableSpace.mHasFloats ||
@@ -705,17 +705,17 @@ FloatMarginISize(const ReflowInput& aCBR
   return floatISize +
          aFloatOffsetState.ComputedLogicalMargin().Size(wm).
            ConvertTo(cbwm, wm).ISize(cbwm) +
          aFloatOffsetState.ComputedLogicalBorderPadding().Size(wm).
            ConvertTo(cbwm, wm).ISize(cbwm);
 }
 
 bool
-nsBlockReflowState::FlowAndPlaceFloat(nsIFrame* aFloat)
+BlockReflowInput::FlowAndPlaceFloat(nsIFrame* aFloat)
 {
   WritingMode wm = mReflowState.GetWritingMode();
   // Save away the Y coordinate before placing the float. We will
   // restore mBCoord at the end after placing the float. This is
   // necessary because any adjustments to mBCoord during the float
   // placement are for the float only, not for any non-floating
   // content.
   AutoRestore<nscoord> restoreBCoord(mBCoord);
@@ -1024,17 +1024,17 @@ nsBlockReflowState::FlowAndPlaceFloat(ns
     printf(" %d,%d,%d,%d\n", r.x, r.y, r.width, r.height);
   }
 #endif
 
   return true;
 }
 
 void
-nsBlockReflowState::PushFloatPastBreak(nsIFrame *aFloat)
+BlockReflowInput::PushFloatPastBreak(nsIFrame *aFloat)
 {
   // This ensures that we:
   //  * don't try to place later but smaller floats (which CSS says
   //    must have their tops below the top of this float)
   //  * don't waste much time trying to reflow this float again until
   //    after the break
   uint8_t floatStyle =
     aFloat->StyleDisplay()->PhysicalFloats(mReflowState.GetWritingMode());
@@ -1052,17 +1052,17 @@ nsBlockReflowState::PushFloatPastBreak(n
   AppendPushedFloatChain(aFloat);
   NS_FRAME_SET_OVERFLOW_INCOMPLETE(mReflowStatus);
 }
 
 /**
  * Place below-current-line floats.
  */
 void
-nsBlockReflowState::PlaceBelowCurrentLineFloats(nsFloatCacheFreeList& aList,
+BlockReflowInput::PlaceBelowCurrentLineFloats(nsFloatCacheFreeList& aList,
                                                 nsLineBox* aLine)
 {
   nsFloatCache* fc = aList.Head();
   while (fc) {
 #ifdef DEBUG
     if (nsBlockFrame::gNoisyReflow) {
       nsFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent);
       printf("placing bcl float: ");
@@ -1078,29 +1078,29 @@ nsBlockReflowState::PlaceBelowCurrentLin
       delete fc;
       aLine->SetHadFloatPushed();
     }
     fc = next;
   }
 }
 
 nscoord
-nsBlockReflowState::ClearFloats(nscoord aBCoord, uint8_t aBreakType,
+BlockReflowInput::ClearFloats(nscoord aBCoord, uint8_t aBreakType,
                                 nsIFrame *aReplacedBlock,
                                 uint32_t aFlags)
 {
 #ifdef DEBUG
   if (nsBlockFrame::gNoisyReflow) {
     nsFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent);
     printf("clear floats: in: aBCoord=%d\n", aBCoord);
   }
 #endif
 
 #ifdef NOISY_FLOAT_CLEARING
-  printf("nsBlockReflowState::ClearFloats: aBCoord=%d breakType=%d\n",
+  printf("BlockReflowInput::ClearFloats: aBCoord=%d breakType=%d\n",
          aBCoord, aBreakType);
   mFloatManager->List(stdout);
 #endif
 
   if (!mFloatManager->HasAnyFloats()) {
     return aBCoord;
   }
 
--- a/layout/generic/BlockReflowInput.h
+++ b/layout/generic/BlockReflowInput.h
@@ -1,41 +1,41 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* state used in reflow of block frames */
 
-#ifndef nsBlockReflowState_h
-#define nsBlockReflowState_h
+#ifndef BlockReflowInput_h
+#define BlockReflowInput_h
 
 #include "nsFloatManager.h"
 #include "nsLineBox.h"
 #include "mozilla/ReflowInput.h"
 
 class nsBlockFrame;
 class nsFrameList;
 class nsOverflowContinuationTracker;
 
 // Block reflow state flags.
 //
-// BRS_UNCONSTRAINEDBSIZE is set in the nsBlockReflowState constructor when the
+// BRS_UNCONSTRAINEDBSIZE is set in the BlockReflowInput constructor when the
 // frame being reflowed has been given NS_UNCONSTRAINEDSIZE as its available
 // BSize in the ReflowInput. If set, NS_UNCONSTRAINEDSIZE is passed to
 // nsLineLayout as the available BSize.
 #define BRS_UNCONSTRAINEDBSIZE    0x00000001
-// BRS_ISBSTARTMARGINROOT is set in the nsBlockReflowState constructor when
+// BRS_ISBSTARTMARGINROOT is set in the BlockReflowInput constructor when
 // reflowing a "block margin root" frame (i.e. a frame with the
 // NS_BLOCK_MARGIN_ROOT flag set, for which margins apply by default).
 //
 // The flag is also set when reflowing a frame whose computed BStart border
 // padding is non-zero.
 #define BRS_ISBSTARTMARGINROOT    0x00000002
-// BRS_ISBENDMARGINROOT is set in the nsBlockReflowState constructor when
+// BRS_ISBENDMARGINROOT is set in the BlockReflowInput constructor when
 // reflowing a "block margin root" frame (i.e. a frame with the
 // NS_BLOCK_MARGIN_ROOT flag set, for which margins apply by default).
 //
 // The flag is also set when reflowing a frame whose computed BEnd border
 // padding is non-zero.
 #define BRS_ISBENDMARGINROOT      0x00000004
 // BRS_APPLYBSTARTMARGIN is set if the BStart margin should be considered when
 // placing a linebox that contains a block frame. It may be set as a side-effect
@@ -47,17 +47,17 @@ class nsOverflowContinuationTracker;
 // ShouldApplyBStartMargin() will crawl the line list to see if a block frame
 // precedes the specified frame. If so, the BStart margin should be applied, and
 // the flag is set to cache the result. (If not, the BStart margin will be
 // applied as a result of the generational margin collapsing logic in
 // nsBlockReflowContext::ComputeCollapsedBStartMargin(). In this case, the flag
 // won't be set, so subsequent calls to ShouldApplyBStartMargin() will continue
 // crawl the line list.)
 //
-// This flag is also set in the nsBlockReflowState constructor if
+// This flag is also set in the BlockReflowInput constructor if
 // BRS_ISBSTARTMARGINROOT is set; that is, the frame being reflowed is a margin
 // root by default.
 #define BRS_APPLYBSTARTMARGIN     0x00000008
 #define BRS_ISFIRSTINFLOW         0x00000010
 // Set when mLineAdjacentToTop is valid
 #define BRS_HAVELINEADJACENTTOTOP 0x00000020
 // Set when the block has the equivalent of NS_BLOCK_FLOAT_MGR
 #define BRS_FLOAT_MGR             0x00000040
@@ -68,24 +68,24 @@ class nsOverflowContinuationTracker;
 // Our mPushedFloats list is stored on the blocks' proptable
 #define BRS_PROPTABLE_FLOATCLIST  0x00000200
 // Set when the pref layout.float-fragments-inside-column.enabled is true.
 #define BRS_FLOAT_FRAGMENTS_INSIDE_COLUMN_ENABLED 0x00000400
 #define BRS_LASTFLAG              BRS_FLOAT_FRAGMENTS_INSIDE_COLUMN_ENABLED
 
 namespace mozilla {
 
-// nsBlockReflowState contains additional reflow state information that the
+// BlockReflowInput contains additional reflow state information that the
 // block frame uses along with ReflowInput. Like ReflowInput, this
 // is read-only data that is passed down from a parent frame to its children.
-class nsBlockReflowState {
+class BlockReflowInput {
   using ReflowInput = mozilla::ReflowInput;
 
 public:
-  nsBlockReflowState(const ReflowInput& aReflowState,
+  BlockReflowInput(const ReflowInput& aReflowState,
                      nsPresContext* aPresContext,
                      nsBlockFrame* aFrame,
                      bool aBStartMarginRoot, bool aBEndMarginRoot,
                      bool aBlockNeedsFloatManager,
                      nscoord aConsumedBSize = NS_INTRINSICSIZE);
 
   /**
    * Get the available reflow space (the area not occupied by floats)
@@ -377,9 +377,9 @@ private:
 
   void PushFloatPastBreak(nsIFrame* aFloat);
 
   void RecoverFloats(nsLineList::iterator aLine, nscoord aDeltaBCoord);
 };
 
 }; // namespace mozilla
 
-#endif // nsBlockReflowState_h
+#endif // BlockReflowInput_h
--- a/layout/generic/nsBlockFrame.cpp
+++ b/layout/generic/nsBlockFrame.cpp
@@ -1097,17 +1097,17 @@ nsBlockFrame::Reflow(nsPresContext*     
     return;
   }
 
   bool blockStartMarginRoot, blockEndMarginRoot;
   IsMarginRoot(&blockStartMarginRoot, &blockEndMarginRoot);
 
   // Cache the consumed height in the block reflow state so that we don't have
   // to continually recompute it.
-  nsBlockReflowState state(*reflowState, aPresContext, this,
+  BlockReflowInput state(*reflowState, aPresContext, this,
                            blockStartMarginRoot, blockEndMarginRoot,
                            needFloatManager, consumedBSize);
 
   if (GetStateBits() & NS_BLOCK_NEEDS_BIDI_RESOLUTION)
     static_cast<nsBlockFrame*>(FirstContinuation())->ResolveBidi();
 
   if (RenumberLists(aPresContext)) {
     AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN);
@@ -1268,17 +1268,17 @@ nsBlockFrame::Reflow(nsPresContext*     
   // Compute our final size
   nscoord blockEndEdgeOfChildren;
   ComputeFinalSize(*reflowState, state, aMetrics, &blockEndEdgeOfChildren);
 
   // If the block direction is right-to-left, we need to update the bounds of
   // lines that were placed relative to mContainerSize during reflow, as
   // we typically do not know the true container size until we've reflowed all
   // its children. So we use a dummy mContainerSize during reflow (see
-  // nsBlockReflowState's constructor) and then fix up the positions of the
+  // BlockReflowInput's constructor) and then fix up the positions of the
   // lines here, once the final block size is known.
   //
   // Note that writing-mode:vertical-rl is the only case where the block
   // logical direction progresses in a negative physical direction, and
   // therefore block-dir coordinate conversion depends on knowing the width
   // of the coordinate space in order to translate between the logical and
   // physical origins.
   if (wm.IsVerticalRL()) {
@@ -1472,17 +1472,17 @@ nsBlockFrame::CheckForCollapsedBEndMargi
       return true;
     }
   }
   // not reached
 }
 
 void
 nsBlockFrame::ComputeFinalSize(const ReflowInput& aReflowState,
-                               nsBlockReflowState&      aState,
+                               BlockReflowInput&      aState,
                                nsHTMLReflowMetrics&     aMetrics,
                                nscoord*                 aBEndEdgeOfChildren)
 {
   WritingMode wm = aState.mReflowState.GetWritingMode();
   const LogicalMargin& borderPadding = aState.BorderPadding();
 #ifdef NOISY_FINAL_SIZE
   ListTag(stdout);
   printf(": mBCoord=%d mIsBEndMarginRoot=%s mPrevBEndMargin=%d bp=%d,%d\n",
@@ -1843,17 +1843,17 @@ IsAlignedLeft(uint8_t aAlignment,
          (((NS_STYLE_TEXT_ALIGN_START == aAlignment &&
            NS_STYLE_DIRECTION_LTR == aDirection) ||
           (NS_STYLE_TEXT_ALIGN_END == aAlignment &&
            NS_STYLE_DIRECTION_RTL == aDirection)) &&
          !(NS_STYLE_UNICODE_BIDI_PLAINTEXT & aUnicodeBidi));
 }
 
 void
-nsBlockFrame::PrepareResizeReflow(nsBlockReflowState& aState)
+nsBlockFrame::PrepareResizeReflow(BlockReflowInput& aState)
 {
   // See if we can try and avoid marking all the lines as dirty
   bool tryAndSkipLines =
     // The left content-edge must be a constant distance from the left
     // border-edge.
     !StylePadding()->mPadding.GetLeft().HasPercent();
 
 #ifdef DEBUG
@@ -1946,17 +1946,17 @@ nsBlockFrame::PrepareResizeReflow(nsBloc
  *  2. The combination of nonzero |aDeltaBCoord| and any impact by a
  *     float, either the previous reflow or now.
  *
  * When entering this function, |aLine| is still at its old position and
  * |aDeltaBCoord| indicates how much it will later be slid (assuming it
  * doesn't get marked dirty and reflowed entirely).
  */
 void
-nsBlockFrame::PropagateFloatDamage(nsBlockReflowState& aState,
+nsBlockFrame::PropagateFloatDamage(BlockReflowInput& aState,
                                    nsLineBox* aLine,
                                    nscoord aDeltaBCoord)
 {
   nsFloatManager *floatManager = aState.mReflowState.mFloatManager;
   NS_ASSERTION((aState.mReflowState.mParentReflowState &&
                 aState.mReflowState.mParentReflowState->mFloatManager == floatManager) ||
                 aState.mReflowState.mBlockDelta == 0, "Bad block delta passed in");
 
@@ -2045,17 +2045,17 @@ nsBlockFrame::ReparentFloats(nsIFrame* a
       MOZ_ASSERT(!(f->GetStateBits() & NS_FRAME_IS_PUSHED_FLOAT),
                  "CollectFloats should've removed that bit");
       ReparentFrame(f, aOldParent, this);
     }
     mFloats.AppendFrames(nullptr, list);
   }
 }
 
-static void DumpLine(const nsBlockReflowState& aState, nsLineBox* aLine,
+static void DumpLine(const BlockReflowInput& aState, nsLineBox* aLine,
                      nscoord aDeltaBCoord, int32_t aDeltaIndent) {
 #ifdef DEBUG
   if (nsBlockFrame::gNoisyReflow) {
     nsRect ovis(aLine->GetVisualOverflowArea());
     nsRect oscr(aLine->GetScrollableOverflowArea());
     nsBlockFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent + aDeltaIndent);
     printf("line=%p mBCoord=%d dirty=%s oldBounds={%d,%d,%d,%d} oldoverflow-vis={%d,%d,%d,%d} oldoverflow-scr={%d,%d,%d,%d} deltaBCoord=%d mPrevBEndMargin=%d childCount=%d\n",
            static_cast<void*>(aLine), aState.mBCoord,
@@ -2065,17 +2065,17 @@ static void DumpLine(const nsBlockReflow
            ovis.x, ovis.y, ovis.width, ovis.height,
            oscr.x, oscr.y, oscr.width, oscr.height,
            aDeltaBCoord, aState.mPrevBEndMargin.get(), aLine->GetChildCount());
   }
 #endif
 }
 
 void
-nsBlockFrame::ReflowDirtyLines(nsBlockReflowState& aState)
+nsBlockFrame::ReflowDirtyLines(BlockReflowInput& aState)
 {
   bool keepGoing = true;
   bool repositionViews = false; // should we really need this?
   bool foundAnyClears = aState.mFloatBreakType != NS_STYLE_CLEAR_NONE;
   bool willReflowAgain = false;
 
 #ifdef DEBUG
   if (gNoisyReflow) {
@@ -2704,17 +2704,17 @@ nsBlockFrame::MarkLineDirtyForInterrupt(
     nsBlockFrame* bf = nsLayoutUtils::GetAsBlock(aLine->mFirstChild);
     if (bf) {
       MarkAllDescendantLinesDirty(bf);
     }
   }
 }
 
 void
-nsBlockFrame::DeleteLine(nsBlockReflowState& aState,
+nsBlockFrame::DeleteLine(BlockReflowInput& aState,
                          nsLineList::iterator aLine,
                          nsLineList::iterator aLineEnd)
 {
   NS_PRECONDITION(0 == aLine->GetChildCount(), "can't delete !empty line");
   if (0 == aLine->GetChildCount()) {
     NS_ASSERTION(aState.mCurrentLine == aLine,
                  "using function more generally than designed, "
                  "but perhaps OK now");
@@ -2729,17 +2729,17 @@ nsBlockFrame::DeleteLine(nsBlockReflowSt
 }
 
 /**
  * Reflow a line. The line will either contain a single block frame
  * or contain 1 or more inline frames. aKeepReflowGoing indicates
  * whether or not the caller should continue to reflow more lines.
  */
 void
-nsBlockFrame::ReflowLine(nsBlockReflowState& aState,
+nsBlockFrame::ReflowLine(BlockReflowInput& aState,
                          line_iterator aLine,
                          bool* aKeepReflowGoing)
 {
   MOZ_ASSERT(aLine->GetChildCount(), "reflowing empty line");
 
   // Setup the line-layout for the new line
   aState.mCurrentLine = aLine;
   aLine->ClearDirty();
@@ -2751,17 +2751,17 @@ nsBlockFrame::ReflowLine(nsBlockReflowSt
     ReflowBlockFrame(aState, aLine, aKeepReflowGoing);
   } else {
     aLine->SetLineWrapped(false);
     ReflowInlineFrames(aState, aLine, aKeepReflowGoing);
   }
 }
 
 nsIFrame*
-nsBlockFrame::PullFrame(nsBlockReflowState& aState,
+nsBlockFrame::PullFrame(BlockReflowInput& aState,
                         line_iterator       aLine)
 {
   // First check our remaining lines.
   if (end_lines() != aLine.next()) {
     return PullFrameFrom(aLine, this, aLine.next());
   }
 
   NS_ASSERTION(!GetOverflowLines(),
@@ -2848,17 +2848,17 @@ nsBlockFrame::PullFrameFrom(nsLineBox*  
   VerifyLines(true);
   VerifyOverflowSituation();
 #endif
 
   return frame;
 }
 
 void
-nsBlockFrame::SlideLine(nsBlockReflowState& aState,
+nsBlockFrame::SlideLine(BlockReflowInput& aState,
                         nsLineBox* aLine, nscoord aDeltaBCoord)
 {
   NS_PRECONDITION(aDeltaBCoord != 0, "why slide a line nowhere?");
 
   // Adjust line state
   aLine->SlideBy(aDeltaBCoord, aState.ContainerSize());
 
   // Adjust the frames in the line
@@ -3064,17 +3064,17 @@ nsBlockFrame::IsEmpty()
     if (!line->IsEmpty())
       return false;
   }
 
   return true;
 }
 
 bool
-nsBlockFrame::ShouldApplyBStartMargin(nsBlockReflowState& aState,
+nsBlockFrame::ShouldApplyBStartMargin(BlockReflowInput& aState,
                                       nsLineBox* aLine,
                                       nsIFrame* aChildFrame)
 {
   if (aState.GetFlag(BRS_APPLYBSTARTMARGIN)) {
     // Apply short-circuit check to avoid searching the line list
     return true;
   }
 
@@ -3109,17 +3109,17 @@ nsBlockFrame::ShouldApplyBStartMargin(ns
 
   // The line being reflowed is "essentially" the first line in the
   // block. Therefore its block-start margin will be collapsed by the
   // generational collapsing logic with its parent (us).
   return false;
 }
 
 void
-nsBlockFrame::ReflowBlockFrame(nsBlockReflowState& aState,
+nsBlockFrame::ReflowBlockFrame(BlockReflowInput& aState,
                                line_iterator aLine,
                                bool* aKeepReflowGoing)
 {
   NS_PRECONDITION(*aKeepReflowGoing, "bad caller");
 
   nsIFrame* frame = aLine->mFirstChild;
   if (!frame) {
     NS_ASSERTION(false, "program error - unexpected empty line"); 
@@ -3707,17 +3707,17 @@ nsBlockFrame::ReflowBlockFrame(nsBlockRe
   }
   
 #ifdef DEBUG
   VerifyLines(true);
 #endif
 }
 
 void
-nsBlockFrame::ReflowInlineFrames(nsBlockReflowState& aState,
+nsBlockFrame::ReflowInlineFrames(BlockReflowInput& aState,
                                  line_iterator aLine,
                                  bool* aKeepReflowGoing)
 {
   *aKeepReflowGoing = true;
 
   aLine->SetLineIsImpactedByFloat(false);
 
   // Setup initial coordinate system for reflowing the inline frames
@@ -3782,17 +3782,17 @@ nsBlockFrame::ReflowInlineFrames(nsBlock
         // Don't allow pullup on a subsequent LINE_REFLOW_REDO_NO_PULL pass
         allowPullUp = false;
       } while (LINE_REFLOW_REDO_NO_PULL == lineReflowStatus);
     } while (LINE_REFLOW_REDO_MORE_FLOATS == lineReflowStatus);
   } while (LINE_REFLOW_REDO_NEXT_BAND == lineReflowStatus);
 }
 
 void
-nsBlockFrame::PushTruncatedLine(nsBlockReflowState& aState,
+nsBlockFrame::PushTruncatedLine(BlockReflowInput& aState,
                                 line_iterator       aLine,
                                 bool*               aKeepReflowGoing)
 {
   PushLines(aState, aLine.prev());
   *aKeepReflowGoing = false;
   NS_FRAME_SET_INCOMPLETE(aState.mReflowStatus);
 }
 
@@ -3800,17 +3800,17 @@ nsBlockFrame::PushTruncatedLine(nsBlockR
 static const char* LineReflowStatusNames[] = {
   "LINE_REFLOW_OK", "LINE_REFLOW_STOP", "LINE_REFLOW_REDO_NO_PULL",
   "LINE_REFLOW_REDO_MORE_FLOATS",
   "LINE_REFLOW_REDO_NEXT_BAND", "LINE_REFLOW_TRUNCATED"
 };
 #endif
 
 void
-nsBlockFrame::DoReflowInlineFrames(nsBlockReflowState& aState,
+nsBlockFrame::DoReflowInlineFrames(BlockReflowInput& aState,
                                    nsLineLayout& aLineLayout,
                                    line_iterator aLine,
                                    nsFlowAreaRect& aFloatAvailableSpace,
                                    nscoord& aAvailableSpaceHeight,
                                    nsFloatManager::SavedState*
                                      aFloatStateBeforeLine,
                                    bool* aKeepReflowGoing,
                                    LineReflowStatus* aLineReflowStatus,
@@ -3967,17 +3967,17 @@ nsBlockFrame::DoReflowInlineFrames(nsBlo
     // the floats.
     //
     // What we do is to advance past the first float we find and
     // then reflow the line all over again.
     NS_ASSERTION(NS_UNCONSTRAINEDSIZE !=
                  aFloatAvailableSpace.mRect.BSize(outerWM),
                  "unconstrained block size on totally empty line");
 
-    // See the analogous code for blocks in nsBlockReflowState::ClearFloats.
+    // See the analogous code for blocks in BlockReflowInput::ClearFloats.
     if (aFloatAvailableSpace.mRect.BSize(outerWM) > 0) {
       NS_ASSERTION(aFloatAvailableSpace.mHasFloats,
                    "redo line on totally empty line with non-empty band...");
       // We should never hit this case if we've placed floats on the
       // line; if we have, then the GetFloatAvailableSpace call is wrong
       // and needs to happen after the caller pops the space manager
       // state.
       aState.mFloatManager->AssertStateMatches(aFloatStateBeforeLine);
@@ -4056,17 +4056,17 @@ nsBlockFrame::DoReflowInlineFrames(nsBlo
  * Reflow an inline frame. The reflow status is mapped from the frames
  * reflow status to the lines reflow status (not to our reflow status).
  * The line reflow status is simple: true means keep placing frames
  * on the line; false means don't (the line is done). If the line
  * has some sort of breaking affect then aLine's break-type will be set
  * to something other than NS_STYLE_CLEAR_NONE.
  */
 void
-nsBlockFrame::ReflowInlineFrame(nsBlockReflowState& aState,
+nsBlockFrame::ReflowInlineFrame(BlockReflowInput& aState,
                                 nsLineLayout& aLineLayout,
                                 line_iterator aLine,
                                 nsIFrame* aFrame,
                                 LineReflowStatus* aLineReflowStatus)
 {
   if (!aFrame) { // XXX change to MOZ_ASSERT(aFrame)
     NS_ERROR("why call me?");
     return;
@@ -4197,17 +4197,17 @@ nsBlockFrame::ReflowInlineFrame(nsBlockR
       // Split line after the current frame
       *aLineReflowStatus = LINE_REFLOW_STOP;
       SplitLine(aState, aLineLayout, aLine, aFrame->GetNextSibling(), aLineReflowStatus);
     }
   }
 }
 
 bool
-nsBlockFrame::CreateContinuationFor(nsBlockReflowState& aState,
+nsBlockFrame::CreateContinuationFor(BlockReflowInput& aState,
                                     nsLineBox*          aLine,
                                     nsIFrame*           aFrame)
 {
   nsIFrame* newFrame = nullptr;
 
   if (!aFrame->GetNextInFlow()) {
     newFrame = aState.mPresContext->PresShell()->FrameConstructor()->
       CreateContinuingFrame(aState.mPresContext, aFrame, this);
@@ -4220,17 +4220,17 @@ nsBlockFrame::CreateContinuationFor(nsBl
   }
 #ifdef DEBUG
   VerifyLines(false);
 #endif
   return !!newFrame;
 }
 
 nsresult
-nsBlockFrame::SplitFloat(nsBlockReflowState& aState,
+nsBlockFrame::SplitFloat(BlockReflowInput& aState,
                          nsIFrame*           aFloat,
                          nsReflowStatus      aFloatStatus)
 {
   MOZ_ASSERT(!NS_FRAME_IS_FULLY_COMPLETE(aFloatStatus),
              "why split the frame if it's fully complete?");
   MOZ_ASSERT(aState.mBlock == this);
 
   nsIFrame* nextInFlow = aFloat->GetNextInFlow();
@@ -4291,17 +4291,17 @@ CheckPlaceholderInLine(nsIFrame* aBlock,
     if (f->GetParent() == aBlock)
       return aLine->Contains(f);
   }
   NS_ASSERTION(false, "aBlock is not an ancestor of aFrame!");
   return true;
 }
 
 void
-nsBlockFrame::SplitLine(nsBlockReflowState& aState,
+nsBlockFrame::SplitLine(BlockReflowInput& aState,
                         nsLineLayout& aLineLayout,
                         line_iterator aLine,
                         nsIFrame* aFrame,
                         LineReflowStatus* aLineReflowStatus)
 {
   MOZ_ASSERT(aLine->IsInline(), "illegal SplitLine on block line");
 
   int32_t pushCount = aLine->GetChildCount() - aLineLayout.GetCurrentSpanCount();
@@ -4365,17 +4365,17 @@ nsBlockFrame::SplitLine(nsBlockReflowSta
 
 #ifdef DEBUG
     VerifyLines(true);
 #endif
   }
 }
 
 bool
-nsBlockFrame::IsLastLine(nsBlockReflowState& aState,
+nsBlockFrame::IsLastLine(BlockReflowInput& aState,
                          line_iterator aLine)
 {
   while (++aLine != end_lines()) {
     // There is another line
     if (0 != aLine->GetChildCount()) {
       // If the next line is a block line then this line is the last in a
       // group of inline lines.
       return aLine->IsBlock();
@@ -4398,17 +4398,17 @@ nsBlockFrame::IsLastLine(nsBlockReflowSt
     nextInFlow = (nsBlockFrame*) nextInFlow->GetNextInFlow();
   }
 
   // This is the last line - so don't allow justification
   return true;
 }
 
 bool
-nsBlockFrame::PlaceLine(nsBlockReflowState& aState,
+nsBlockFrame::PlaceLine(BlockReflowInput& aState,
                         nsLineLayout&       aLineLayout,
                         line_iterator       aLine,
                         nsFloatManager::SavedState *aFloatStateBeforeLine,
                         LogicalRect&        aFloatAvailableSpace,
                         nscoord&            aAvailableSpaceHeight,
                         bool*             aKeepReflowGoing)
 {
   // Trim extra white-space from the line before placing the frames
@@ -4610,17 +4610,17 @@ nsBlockFrame::PlaceLine(nsBlockReflowSta
   // This must stay in sync with |ReflowDirtyLines|.
   if (aLine->HasFloatBreakAfter()) {
     aState.mBCoord = aState.ClearFloats(aState.mBCoord, aLine->GetBreakTypeAfter());
   }
   return true;
 }
 
 void
-nsBlockFrame::PushLines(nsBlockReflowState&  aState,
+nsBlockFrame::PushLines(BlockReflowInput&  aState,
                         nsLineList::iterator aLineBefore)
 {
   // NOTE: aLineBefore is always a normal line, not an overflow line.
   // The following expression will assert otherwise.
   DebugOnly<bool> check = aLineBefore == mLines.begin();
 
   nsLineList::iterator overBegin(aLineBefore.next());
 
@@ -4804,17 +4804,17 @@ nsBlockFrame::DrainSelfOverflowList()
  * Temporarily, during reflow, they also live on the pushed floats list,
  * which only holds them between (a) when one continuation pushes them to
  * its pushed floats list because they don't fit and (b) when the next
  * continuation pulls them onto the beginning of its float list.
  *
  * DrainPushedFloats sets up pushed floats the way we need them at the
  * start of reflow; they are then reflowed by ReflowPushedFloats (which
  * might push some of them on).  Floats with placeholders in this block
- * are reflowed by (nsBlockReflowState/nsLineLayout)::AddFloat, which
+ * are reflowed by (BlockReflowInput/nsLineLayout)::AddFloat, which
  * also maintains these invariants.
  *
  * DrainSelfPushedFloats moves any pushed floats from this block's own
  * PushedFloats list back into mFloats.  DrainPushedFloats additionally
  * moves frames from its prev-in-flow's PushedFloats list into mFloats.
  */
 void
 nsBlockFrame::DrainSelfPushedFloats()
@@ -5367,17 +5367,17 @@ nsBlockFrame::RemoveFloat(nsIFrame* aFlo
 
   if (mFloats.StartRemoveFrame(aFloat)) {
     return;
   }
 
   nsFrameList* list = GetPushedFloats();
   if (list && list->ContinueRemoveFrame(aFloat)) {
 #if 0
-    // XXXmats not yet - need to investigate nsBlockReflowState::mPushedFloats
+    // XXXmats not yet - need to investigate BlockReflowInput::mPushedFloats
     // first so we don't leave it pointing to a deleted list.
     if (list->IsEmpty()) {
       delete RemovePushedFloats();
     }
 #endif
     return;
   }
 
@@ -6037,32 +6037,32 @@ nsBlockFrame::StyleTextForLineLayout()
   // Return the pointer to an unmodified style text
   return StyleText();
 }
 
 ////////////////////////////////////////////////////////////////////////
 // Float support
 
 LogicalRect
-nsBlockFrame::AdjustFloatAvailableSpace(nsBlockReflowState& aState,
+nsBlockFrame::AdjustFloatAvailableSpace(BlockReflowInput& aState,
                                         const LogicalRect& aFloatAvailableSpace,
                                         nsIFrame* aFloatFrame)
 {
   // Compute the available inline size. By default, assume the inline
   // size of the containing block.
   nscoord availISize;
   const nsStyleDisplay* floatDisplay = aFloatFrame->StyleDisplay();
   WritingMode wm = aState.mReflowState.GetWritingMode();
 
   if (NS_STYLE_DISPLAY_TABLE != floatDisplay->mDisplay ||
       eCompatibility_NavQuirks != aState.mPresContext->CompatibilityMode() ) {
     availISize = aState.ContentISize();
   }
   else {
-    // This quirk matches the one in nsBlockReflowState::FlowAndPlaceFloat
+    // This quirk matches the one in BlockReflowInput::FlowAndPlaceFloat
     // give tables only the available space
     // if they can shrink we may not be constrained to place
     // them in the next line
     availISize = aFloatAvailableSpace.ISize(wm);
   }
 
   nscoord availBSize = NS_UNCONSTRAINEDSIZE == aState.ContentBSize()
                        ? NS_UNCONSTRAINEDSIZE
@@ -6078,17 +6078,17 @@ nsBlockFrame::AdjustFloatAvailableSpace(
     availBSize = NS_UNCONSTRAINEDSIZE;
   }
 
   return LogicalRect(wm, aState.ContentIStart(), aState.ContentBStart(),
                      availISize, availBSize);
 }
 
 nscoord
-nsBlockFrame::ComputeFloatISize(nsBlockReflowState& aState,
+nsBlockFrame::ComputeFloatISize(BlockReflowInput& aState,
                                 const LogicalRect&  aFloatAvailableSpace,
                                 nsIFrame*           aFloat)
 {
   NS_PRECONDITION(aFloat->GetStateBits() & NS_FRAME_OUT_OF_FLOW,
                   "aFloat must be an out-of-flow frame");
   // Reflow the float.
   LogicalRect availSpace = AdjustFloatAvailableSpace(aState,
                                                      aFloatAvailableSpace,
@@ -6099,17 +6099,17 @@ nsBlockFrame::ComputeFloatISize(nsBlockR
   ReflowInput
     floatRS(aState.mPresContext, aState.mReflowState, aFloat,
             availSpace.Size(blockWM).ConvertTo(floatWM, blockWM));
 
   return floatRS.ComputedSizeWithMarginBorderPadding(blockWM).ISize(blockWM);
 }
 
 void
-nsBlockFrame::ReflowFloat(nsBlockReflowState& aState,
+nsBlockFrame::ReflowFloat(BlockReflowInput& aState,
                           const LogicalRect&  aAdjustedAvailableSpace,
                           nsIFrame*           aFloat,
                           LogicalMargin&      aFloatMargin,
                           LogicalMargin&      aFloatOffsets,
                           bool                aFloatPushedDown,
                           nsReflowStatus&     aReflowStatus)
 {
   NS_PRECONDITION(aFloat->GetStateBits() & NS_FRAME_OUT_OF_FLOW,
@@ -6204,17 +6204,17 @@ nsBlockFrame::ReflowFloat(nsBlockReflowS
   aFloatOffsets =
     floatRS.ComputedLogicalOffsets().ConvertTo(wm, floatRS.GetWritingMode());
 
   const nsHTMLReflowMetrics& metrics = brc.GetMetrics();
 
   // Set the rect, make sure the view is properly sized and positioned,
   // and tell the frame we're done reflowing it
   // XXXldb This seems like the wrong place to be doing this -- shouldn't
-  // we be doing this in nsBlockReflowState::FlowAndPlaceFloat after
+  // we be doing this in BlockReflowInput::FlowAndPlaceFloat after
   // we've positioned the float, and shouldn't we be doing the equivalent
   // of |PlaceFrameView| here?
   WritingMode metricsWM = metrics.GetWritingMode();
   aFloat->SetSize(metricsWM, metrics.Size(metricsWM));
   if (aFloat->HasView()) {
     nsContainerFrame::SyncFrameViewAfterReflow(aState.mPresContext, aFloat,
                                                aFloat->GetView(),
                                                metrics.VisualOverflow(),
@@ -6241,17 +6241,17 @@ nsBlockFrame::FindTrailingClear()
       --endLine;
       return endLine->GetBreakTypeAfter();
     }
   }
   return NS_STYLE_CLEAR_NONE;
 }
 
 void
-nsBlockFrame::ReflowPushedFloats(nsBlockReflowState& aState,
+nsBlockFrame::ReflowPushedFloats(BlockReflowInput& aState,
                                  nsOverflowAreas&    aOverflowAreas,
                                  nsReflowStatus&     aStatus)
 {
   // Pushed floats live at the start of our float list; see comment
   // above nsBlockFrame::DrainPushedFloats.
   nsIFrame* f = mFloats.FirstChild();
   nsIFrame* prev = nullptr;
   while (f && (f->GetStateBits() & NS_FRAME_IS_PUSHED_FLOAT)) {
@@ -7167,17 +7167,17 @@ nsBlockFrame::RenumberListsFor(nsPresCon
       }
     }
   }
   return kidRenumberedABullet;
 }
 
 void
 nsBlockFrame::ReflowBullet(nsIFrame* aBulletFrame,
-                           nsBlockReflowState& aState,
+                           BlockReflowInput& aState,
                            nsHTMLReflowMetrics& aMetrics,
                            nscoord aLineTop)
 {
   const ReflowInput &rs = aState.mReflowState;
 
   // Reflow the bullet now
   WritingMode bulletWM = aBulletFrame->GetWritingMode();
   LogicalSize availSize(bulletWM);
@@ -7272,17 +7272,17 @@ nsBlockFrame::DoCollectFloats(nsIFrame* 
     }
     if (!aCollectSiblings)
       break;
     aFrame = aFrame->GetNextSibling();
   }
 }
 
 void
-nsBlockFrame::CheckFloats(nsBlockReflowState& aState)
+nsBlockFrame::CheckFloats(BlockReflowInput& aState)
 {
 #ifdef DEBUG
   // If any line is still dirty, that must mean we're going to reflow this
   // block again soon (e.g. because we bailed out after noticing that
   // clearance was imposed), so don't worry if the floats are out of sync.
   bool anyLineDirty = false;
 
   // Check that the float list is what we would have built
@@ -7387,17 +7387,17 @@ nsBlockFrame::BlockCanIntersectFloats(ns
 }
 
 // Note that this width can vary based on the vertical position.
 // However, the cases where it varies are the cases where the width fits
 // in the available space given, which means that variation shouldn't
 // matter.
 /* static */
 nsBlockFrame::ReplacedElementISizeToClear
-nsBlockFrame::ISizeToClearPastFloats(const nsBlockReflowState& aState,
+nsBlockFrame::ISizeToClearPastFloats(const BlockReflowInput& aState,
                                      const LogicalRect& aFloatAvailableSpace,
                                      nsIFrame* aFrame)
 {
   nscoord inlineStartOffset, inlineEndOffset;
   WritingMode wm = aState.mReflowState.GetWritingMode();
   SizeComputationInput offsetState(aFrame, aState.mReflowState.rendContext,
                                wm, aState.mContentArea.ISize(wm));
 
--- a/layout/generic/nsBlockFrame.h
+++ b/layout/generic/nsBlockFrame.h
@@ -38,17 +38,17 @@ enum LineReflowStatus {
   // The line did not fit in the available vertical space. Try pushing it to
   // the next page or column if it's not the first line on the current page/column.
   LINE_REFLOW_TRUNCATED
 };
 
 class nsBlockInFlowLineIterator;
 class nsBulletFrame;
 namespace mozilla {
-class nsBlockReflowState;
+class BlockReflowInput;
 } // namespace mozilla
 
 /**
  * Some invariants:
  * -- The overflow out-of-flows list contains the out-of-
  * flow frames whose placeholders are in the overflow list.
  * -- A given piece of content has at most one placeholder
  * frame in a block's normal child list.
@@ -72,17 +72,17 @@ class nsBlockReflowState;
 
 /*
  * Base class for block and inline frames.
  * The block frame has an additional child list, kAbsoluteList, which
  * contains the absolutely positioned frames.
  */
 class nsBlockFrame : public nsContainerFrame
 {
-  using nsBlockReflowState = mozilla::nsBlockReflowState;
+  using BlockReflowInput = mozilla::BlockReflowInput;
 
 public:
   NS_DECL_QUERYFRAME_TARGET(nsBlockFrame)
   NS_DECL_FRAMEARENA_HELPERS
 
   typedef nsLineList::iterator                  line_iterator;
   typedef nsLineList::const_iterator            const_line_iterator;
   typedef nsLineList::reverse_iterator          reverse_line_iterator;
@@ -292,17 +292,17 @@ public:
 
   /**
    * Determines whether the collapsed margin carried out of the last
    * line includes the margin-top of a line with clearance (in which
    * case we must avoid collapsing that margin with our bottom margin)
    */
   bool CheckForCollapsedBEndMarginFromClearanceLine();
 
-  static nsresult GetCurrentLine(nsBlockReflowState *aState, nsLineBox **aOutCurrentLine);
+  static nsresult GetCurrentLine(BlockReflowInput *aState, nsLineBox **aOutCurrentLine);
 
   /**
    * Determine if this block is a margin root at the top/bottom edges.
    */
   void IsMarginRoot(bool* aBStartMarginRoot, bool* aBEndMarginRoot);
 
   static bool BlockNeedsFloatManager(nsIFrame* aBlock);
 
@@ -320,28 +320,28 @@ public:
    * care about (which need not be its current mBCoord)
    */
   struct ReplacedElementISizeToClear {
     // Note that we care about the inline-start margin but can ignore
     // the inline-end margin.
     nscoord marginIStart, borderBoxISize;
   };
   static ReplacedElementISizeToClear
-    ISizeToClearPastFloats(const nsBlockReflowState& aState,
+    ISizeToClearPastFloats(const BlockReflowInput& aState,
                            const mozilla::LogicalRect& aFloatAvailableSpace,
                            nsIFrame* aFrame);
 
   /**
    * Creates a contination for aFloat and adds it to the list of overflow floats.
    * Also updates aState.mReflowStatus to include the float's incompleteness.
    * Must only be called while this block frame is in reflow.
    * aFloatStatus must be the float's true, unmodified reflow status.
    * 
    */
-  nsresult SplitFloat(nsBlockReflowState& aState,
+  nsresult SplitFloat(BlockReflowInput& aState,
                       nsIFrame*           aFloat,
                       nsReflowStatus      aFloatStatus);
 
   /**
    * Walks up the frame tree, starting with aCandidate, and returns the first
    * block frame that it encounters.
    */
   static nsBlockFrame* GetNearestAncestorBlock(nsIFrame* aCandidate);
@@ -400,27 +400,27 @@ protected:
   void SetFlags(nsFrameState aFlags) {
     mState &= ~NS_BLOCK_FLAGS_MASK;
     mState |= aFlags;
   }
 
   /** move the frames contained by aLine by aDeltaBCoord
     * if aLine is a block, its child floats are added to the state manager
     */
-  void SlideLine(nsBlockReflowState& aState,
+  void SlideLine(BlockReflowInput& aState,
                  nsLineBox* aLine, nscoord aDeltaBCoord);
 
   void UpdateLineContainerSize(nsLineBox* aLine,
                                const nsSize& aNewContainerSize);
 
   // helper for SlideLine and UpdateLineContainerSize
   void MoveChildFramesOfLine(nsLineBox* aLine, nscoord aDeltaBCoord);
 
   void ComputeFinalSize(const ReflowInput& aReflowState,
-                        nsBlockReflowState&      aState,
+                        BlockReflowInput&      aState,
                         nsHTMLReflowMetrics&     aMetrics,
                         nscoord*                 aBottomEdgeOfChildren);
 
   void ComputeOverflowAreas(const nsRect&         aBounds,
                             const nsStyleDisplay* aDisplay,
                             nscoord               aBottomEdgeOfChildren,
                             nsOverflowAreas&      aOverflowAreas);
 
@@ -561,17 +561,17 @@ protected:
    *  Assumes float manager is in our own coordinate system.
    */
   void RecoverFloats(nsFloatManager&      aFloatManager,
                      mozilla::WritingMode aWM,
                      const nsSize&        aContainerSize);
 
   /** Reflow pushed floats
    */
-  void ReflowPushedFloats(nsBlockReflowState& aState,
+  void ReflowPushedFloats(BlockReflowInput& aState,
                           nsOverflowAreas&    aOverflowAreas,
                           nsReflowStatus&     aStatus);
 
   /** Find any trailing BR clear from the last line of the block (or its PIFs)
    */
   uint8_t FindTrailingClear();
 
   /**
@@ -593,41 +593,41 @@ protected:
                        bool aCollectFromSiblings);
 
   // Remove a float, abs, rel positioned frame from the appropriate block's list
   static void DoRemoveOutOfFlowFrame(nsIFrame* aFrame);
 
   /** set up the conditions necessary for an resize reflow
     * the primary task is to mark the minimumly sufficient lines dirty. 
     */
-  void PrepareResizeReflow(nsBlockReflowState& aState);
+  void PrepareResizeReflow(BlockReflowInput& aState);
 
   /** reflow all lines that have been marked dirty */
-  void ReflowDirtyLines(nsBlockReflowState& aState);
+  void ReflowDirtyLines(BlockReflowInput& aState);
 
   /** Mark a given line dirty due to reflow being interrupted on or before it */
   void MarkLineDirtyForInterrupt(nsLineBox* aLine);
 
   //----------------------------------------
   // Methods for line reflow
   /**
    * Reflow a line.  
    * @param aState           the current reflow state
    * @param aLine            the line to reflow.  can contain a single block frame
    *                         or contain 1 or more inline frames.
    * @param aKeepReflowGoing [OUT] indicates whether the caller should continue to reflow more lines
    */
-  void ReflowLine(nsBlockReflowState& aState,
+  void ReflowLine(BlockReflowInput& aState,
                   line_iterator aLine,
                   bool* aKeepReflowGoing);
 
   // Return false if it needs another reflow because of reduced space
   // between floats that are next to it (but not next to its top), and
   // return true otherwise.
-  bool PlaceLine(nsBlockReflowState&           aState,
+  bool PlaceLine(BlockReflowInput&           aState,
                    nsLineLayout&               aLineLayout,
                    line_iterator               aLine,
                    nsFloatManager::SavedState* aFloatStateBeforeLine,
                    mozilla::LogicalRect&       aFloatAvailableSpace, //in-out
                    nscoord&                    aAvailableSpaceHeight, // in-out
                    bool*                       aKeepReflowGoing);
 
   /**
@@ -642,69 +642,69 @@ protected:
    * on those lines because the text in the lines might have changed due to
    * addition/removal of frames.
    * @param aLine the line to mark dirty
    * @param aLineList the line list containing that line
    */
   void MarkLineDirty(line_iterator aLine, const nsLineList* aLineList);
 
   // XXX where to go
-  bool IsLastLine(nsBlockReflowState& aState,
+  bool IsLastLine(BlockReflowInput& aState,
                   line_iterator aLine);
 
-  void DeleteLine(nsBlockReflowState& aState,
+  void DeleteLine(BlockReflowInput& aState,
                   nsLineList::iterator aLine,
                   nsLineList::iterator aLineEnd);
 
   //----------------------------------------
   // Methods for individual frame reflow
 
-  bool ShouldApplyBStartMargin(nsBlockReflowState& aState,
+  bool ShouldApplyBStartMargin(BlockReflowInput& aState,
                                nsLineBox* aLine,
                                nsIFrame* aChildFrame);
 
-  void ReflowBlockFrame(nsBlockReflowState& aState,
+  void ReflowBlockFrame(BlockReflowInput& aState,
                         line_iterator aLine,
                         bool* aKeepGoing);
 
-  void ReflowInlineFrames(nsBlockReflowState& aState,
+  void ReflowInlineFrames(BlockReflowInput& aState,
                           line_iterator aLine,
                           bool* aKeepLineGoing);
 
-  void DoReflowInlineFrames(nsBlockReflowState& aState,
+  void DoReflowInlineFrames(BlockReflowInput& aState,
                             nsLineLayout& aLineLayout,
                             line_iterator aLine,
                             nsFlowAreaRect& aFloatAvailableSpace,
                             nscoord& aAvailableSpaceHeight,
                             nsFloatManager::SavedState*
                             aFloatStateBeforeLine,
                             bool* aKeepReflowGoing,
                             LineReflowStatus* aLineReflowStatus,
                             bool aAllowPullUp);
 
-  void ReflowInlineFrame(nsBlockReflowState& aState,
+  void ReflowInlineFrame(BlockReflowInput& aState,
                          nsLineLayout& aLineLayout,
                          line_iterator aLine,
                          nsIFrame* aFrame,
                          LineReflowStatus* aLineReflowStatus);
 
   // Compute the available inline size for a float.
   mozilla::LogicalRect AdjustFloatAvailableSpace(
-                         nsBlockReflowState&         aState,
+                         BlockReflowInput&         aState,
                          const mozilla::LogicalRect& aFloatAvailableSpace,
                          nsIFrame*                   aFloatFrame);
   // Computes the border-box inline size of the float
-  nscoord ComputeFloatISize(nsBlockReflowState&         aState,
+  nscoord ComputeFloatISize(BlockReflowInput&         aState,
                             const mozilla::LogicalRect& aFloatAvailableSpace,
                             nsIFrame*                   aFloat);
   // An incomplete aReflowStatus indicates the float should be split
   // but only if the available height is constrained.
   // aAdjustedAvailableSpace is the result of calling
   // nsBlockFrame::AdjustFloatAvailableSpace.
-  void ReflowFloat(nsBlockReflowState&         aState,
+  void ReflowFloat(BlockReflowInput&         aState,
                    const mozilla::LogicalRect& aAdjustedAvailableSpace,
                    nsIFrame*                   aFloat,
                    mozilla::LogicalMargin&     aFloatMargin,
                    mozilla::LogicalMargin&     aFloatOffsets,
                    // Whether the float's position
                    // (aAdjustedAvailableSpace) has been pushed down
                    // due to the presence of other floats.
                    bool                        aFloatPushedDown,
@@ -716,41 +716,41 @@ protected:
   /**
    * Create a next-in-flow, if necessary, for aFrame. If a new frame is
    * created, place it in aLine if aLine is not null.
    * @param aState the block reflow state
    * @param aLine where to put a new frame
    * @param aFrame the frame
    * @return true if a new frame was created, false if not
    */
-  bool CreateContinuationFor(nsBlockReflowState& aState,
+  bool CreateContinuationFor(BlockReflowInput& aState,
                              nsLineBox*          aLine,
                              nsIFrame*           aFrame);
 
   /**
    * Push aLine (and any after it), since it cannot be placed on this
    * page/column.  Set aKeepReflowGoing to false and set
    * flag aState.mReflowStatus as incomplete.
    */
-  void PushTruncatedLine(nsBlockReflowState& aState,
+  void PushTruncatedLine(BlockReflowInput& aState,
                          line_iterator       aLine,
                          bool*               aKeepReflowGoing);
 
-  void SplitLine(nsBlockReflowState& aState,
+  void SplitLine(BlockReflowInput& aState,
                  nsLineLayout& aLineLayout,
                  line_iterator aLine,
                  nsIFrame* aFrame,
                  LineReflowStatus* aLineReflowStatus);
 
   /**
    * Pull a frame from the next available location (one of our lines or
    * one of our next-in-flows lines).
    * @return the pulled frame or nullptr
    */
-  nsIFrame* PullFrame(nsBlockReflowState& aState,
+  nsIFrame* PullFrame(BlockReflowInput& aState,
                       line_iterator       aLine);
 
   /**
    * Try to pull a frame out of a line pointed at by aFromLine.
    *
    * Note: pulling a frame from a line that is a place-holder frame
    * doesn't automatically remove the corresponding float from the
    * line's float array. This happens indirectly: either the line gets
@@ -764,24 +764,24 @@ protected:
                           nsBlockFrame*        aFromContainer,
                           nsLineList::iterator aFromLine);
 
   /**
    * Push the line after aLineBefore to the overflow line list.
    * @param aLineBefore a line in 'mLines' (or begin_lines() when
    *        pushing the first line)
    */
-  void PushLines(nsBlockReflowState& aState,
+  void PushLines(BlockReflowInput& aState,
                  nsLineList::iterator aLineBefore);
 
-  void PropagateFloatDamage(nsBlockReflowState& aState,
+  void PropagateFloatDamage(BlockReflowInput& aState,
                             nsLineBox* aLine,
                             nscoord aDeltaBCoord);
 
-  void CheckFloats(nsBlockReflowState& aState);
+  void CheckFloats(BlockReflowInput& aState);
 
   //----------------------------------------
   // List handling kludge
 
   // If this returns true, the block it's called on should get the
   // NS_FRAME_HAS_DIRTY_CHILDREN bit set on it by the caller; either directly
   // if it's already in reflow, or via calling FrameNeedsReflow() to schedule a
   // reflow.
@@ -795,17 +795,17 @@ protected:
 
   static bool RenumberListsFor(nsPresContext* aPresContext, nsIFrame* aKid,
                                int32_t* aOrdinal, int32_t aDepth,
                                int32_t aIncrement);
 
   static bool FrameStartsCounterScope(nsIFrame* aFrame);
 
   void ReflowBullet(nsIFrame* aBulletFrame,
-                    nsBlockReflowState& aState,
+                    BlockReflowInput& aState,
                     nsHTMLReflowMetrics& aMetrics,
                     nscoord aLineTop);
 
   //----------------------------------------
 
   virtual nsILineIterator* GetLineIterator() override;
 
 public:
@@ -887,17 +887,17 @@ protected:
   nscoord mMinWidth, mPrefWidth;
 
   nsLineList mLines;
 
   // List of all floats in this block
   // XXXmats blocks rarely have floats, make it a frame property
   nsFrameList mFloats;
 
-  friend class mozilla::nsBlockReflowState;
+  friend class mozilla::BlockReflowInput;
   friend class nsBlockInFlowLineIterator;
 
 #ifdef DEBUG
 public:
   static bool gLamePaintMetrics;
   static bool gLameReflowMetrics;
   static bool gNoisy;
   static bool gNoisyDamageRepair;
--- a/layout/generic/nsBlockReflowContext.cpp
+++ b/layout/generic/nsBlockReflowContext.cpp
@@ -224,17 +224,17 @@ void
 nsBlockReflowContext::ReflowBlock(const LogicalRect&  aSpace,
                                   bool                aApplyBStartMargin,
                                   nsCollapsingMargin& aPrevMargin,
                                   nscoord             aClearance,
                                   bool                aIsAdjacentWithBStart,
                                   nsLineBox*          aLine,
                                   ReflowInput&  aFrameRS,
                                   nsReflowStatus&     aFrameReflowStatus,
-                                  nsBlockReflowState& aState)
+                                  BlockReflowInput& aState)
 {
   mFrame = aFrameRS.frame;
   mWritingMode = aState.mReflowState.GetWritingMode();
   mContainerSize = aState.ContainerSize();
   mSpace = aSpace;
 
   if (!aIsAdjacentWithBStart) {
     aFrameRS.mFlags.mIsTopOfPage = false;  // make sure this is cleared
--- a/layout/generic/nsBlockReflowContext.h
+++ b/layout/generic/nsBlockReflowContext.h
@@ -10,40 +10,40 @@
 #define nsBlockReflowContext_h___
 
 #include "nsIFrame.h"
 #include "nsHTMLReflowMetrics.h"
 
 class nsLineBox;
 class nsPresContext;
 namespace mozilla {
-class nsBlockReflowState;
+class BlockReflowInput;
 } // namespace mozilla
 
 /**
  * An encapsulation of the state and algorithm for reflowing block frames.
  */
 class nsBlockReflowContext {
-  using nsBlockReflowState = mozilla::nsBlockReflowState;
+  using BlockReflowInput = mozilla::BlockReflowInput;
   using ReflowInput = mozilla::ReflowInput;
 
 public:
   nsBlockReflowContext(nsPresContext* aPresContext,
                        const ReflowInput& aParentRS);
   ~nsBlockReflowContext() { }
 
   void ReflowBlock(const mozilla::LogicalRect& aSpace,
                    bool                        aApplyBStartMargin,
                    nsCollapsingMargin&         aPrevMargin,
                    nscoord                     aClearance,
                    bool                        aIsAdjacentWithBStart,
                    nsLineBox*                  aLine,
                    ReflowInput&          aReflowState,
                    nsReflowStatus&             aReflowStatus,
-                   nsBlockReflowState&         aState);
+                   BlockReflowInput&         aState);
 
   bool PlaceBlock(const ReflowInput& aReflowState,
                   bool                     aForceFit,
                   nsLineBox*               aLine,
                   nsCollapsingMargin&      aBEndMarginResult /* out */,
                   nsOverflowAreas&         aOverflowAreas,
                   nsReflowStatus           aReflowStatus);
 
--- a/layout/generic/nsFrameStateBits.h
+++ b/layout/generic/nsFrameStateBits.h
@@ -462,17 +462,17 @@ FRAME_STATE_BIT(Block, 20, NS_BLOCK_NEED
 FRAME_STATE_BIT(Block, 21, NS_BLOCK_HAS_PUSHED_FLOATS)
 
 // This indicates that this is a frame from which child margins can be
 // calculated. The absence of this flag implies that child margin calculations
 // should ignore the frame and look further up the parent chain. Used in
 // nsBlockReflowContext::ComputeCollapsedBStartMargin() via
 // nsBlockFrame::IsMarginRoot().
 //
-// This causes the nsBlockReflowState's constructor to set the
+// This causes the BlockReflowInput's constructor to set the
 // BRS_ISBSTARTMARGINROOT and BRS_ISBENDMARGINROOT flags.
 FRAME_STATE_BIT(Block, 22, NS_BLOCK_MARGIN_ROOT)
 
 // This indicates that a block frame should create its own float manager. This
 // is required by each block frame that can contain floats. The float manager is
 // used to reserve space for the floated frames.
 FRAME_STATE_BIT(Block, 23, NS_BLOCK_FLOAT_MGR)
 
--- a/layout/generic/nsLineLayout.h
+++ b/layout/generic/nsLineLayout.h
@@ -23,32 +23,32 @@
 #include "BlockReflowInput.h"
 #include "nsLineBox.h"
 #include "plarena.h"
 
 class nsFloatManager;
 struct nsStyleText;
 
 class nsLineLayout {
-  using nsBlockReflowState = mozilla::nsBlockReflowState;
+  using BlockReflowInput = mozilla::BlockReflowInput;
   using ReflowInput = mozilla::ReflowInput;
 
 public:
   /**
    * @param aBaseLineLayout the nsLineLayout for ruby base,
    * nullptr if no separate base nsLineLayout is needed.
    */
   nsLineLayout(nsPresContext* aPresContext,
                nsFloatManager* aFloatManager,
                const ReflowInput* aOuterReflowState,
                const nsLineList::iterator* aLine,
                nsLineLayout* aBaseLineLayout);
   ~nsLineLayout();
 
-  void Init(nsBlockReflowState* aState, nscoord aMinLineBSize,
+  void Init(BlockReflowInput* aState, nscoord aMinLineBSize,
             int32_t aLineNumber) {
     mBlockRS = aState;
     mMinLineBSize = aMinLineBSize;
     mLineNumber = aLineNumber;
   }
 
   int32_t GetLineNumber() const {
     return mLineNumber;
@@ -406,17 +406,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
-  nsBlockReflowState* mBlockRS;/* XXX hack! */
+  BlockReflowInput* mBlockRS;/* 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).