/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* 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/. */

/* struct containing the input to nsIFrame::Reflow */

#include "mozilla/ReflowInput.h"

#include "LayoutLogging.h"

#include "nsStyleConsts.h"

#include "nsCSSAnonBoxes.h"

#include "nsFrame.h"

#include "nsIContent.h"

#include "nsGkAtoms.h"

#include "nsPresContext.h"

#include "nsIPresShell.h"

#include "nsFontMetrics.h"

#include "nsBlockFrame.h"

#include "nsLineBox.h"

#include "nsImageFrame.h"

#include "nsTableFrame.h"

#include "nsTableCellFrame.h"

#include "nsIPercentBSizeObserver.h"

#include "nsLayoutUtils.h"

#include "mozilla/Preferences.h"

#include "nsFontInflationData.h"

#include "StickyScrollContainer.h"

#include "nsIFrameInlines.h"

#include "CounterStyleManager.h"

#include <algorithm>

#include "mozilla/dom/HTMLInputElement.h"

#ifdef DEBUG

#undef NOISY_VERTICAL_ALIGN

#else

#undef NOISY_VERTICAL_ALIGN

#endif

using namespace mozilla;

using namespace mozilla::css;

using namespace mozilla::dom;

using namespace mozilla::layout;

enum eNormalLineHeightControl {

  eUninitialized = -1,

  eNoExternalLeading = 0,   // does not include external leading

  eIncludeExternalLeading,  // use whatever value font vendor provides

  eCompensateLeading        // compensate leading if leading provided by font vendor is not enough

};

static eNormalLineHeightControl sNormalLineHeightControl = eUninitialized;

// Initialize a <b>root</b> reflow state with a rendering context to

// use for measuring things.

ReflowInput::ReflowInput(nsPresContext*       aPresContext,

                                     nsIFrame*            aFrame,

                                     gfxContext*          aRenderingContext,

                                     const LogicalSize&   aAvailableSpace,

                                     uint32_t             aFlags)

  : SizeComputationInput(aFrame, aRenderingContext)

  , mCBReflowInput(nullptr) // will be setup properly later in InitCBReflowInput

  , mBlockDelta(0)

  , mOrthogonalLimit(NS_UNCONSTRAINEDSIZE)

  , mAvailableWidth(0)

  , mAvailableHeight(0)

  , mContainingBlockSize(mWritingMode)

  , mReflowDepth(0)

{

  MOZ_ASSERT(aRenderingContext, "no rendering context");

  MOZ_ASSERT(aPresContext, "no pres context");

  MOZ_ASSERT(aFrame, "no frame");

  MOZ_ASSERT(aPresContext == aFrame->PresContext(), "wrong pres context");

  mParentReflowInput = nullptr;

  AvailableISize() = aAvailableSpace.ISize(mWritingMode);

  AvailableBSize() = aAvailableSpace.BSize(mWritingMode);

  mFloatManager = nullptr;

  mLineLayout = nullptr;

  mDiscoveredClearance = nullptr;

  mPercentBSizeObserver = nullptr;

  if (aFlags & DUMMY_PARENT_REFLOW_STATE) {

    mFlags.mDummyParentReflowInput = true;

  }

  if (aFlags & COMPUTE_SIZE_SHRINK_WRAP) {

    mFlags.mShrinkWrap = true;

  }

  if (aFlags & COMPUTE_SIZE_USE_AUTO_BSIZE) {

    mFlags.mUseAutoBSize = true;

  }

  if (aFlags & STATIC_POS_IS_CB_ORIGIN) {

    mFlags.mStaticPosIsCBOrigin = true;

  }

  if (aFlags & I_CLAMP_MARGIN_BOX_MIN_SIZE) {

    mFlags.mIClampMarginBoxMinSize = true;

  }

  if (aFlags & B_CLAMP_MARGIN_BOX_MIN_SIZE) {

    mFlags.mBClampMarginBoxMinSize = true;

  }

  if (aFlags & I_APPLY_AUTO_MIN_SIZE) {

    mFlags.mApplyAutoMinSize = true;

  }

  if (!(aFlags & CALLER_WILL_INIT)) {

    Init(aPresContext);

  }

}

static bool CheckNextInFlowParenthood(nsIFrame* aFrame, nsIFrame* aParent)

{

  nsIFrame* frameNext = aFrame->GetNextInFlow();

  nsIFrame* parentNext = aParent->GetNextInFlow();

  return frameNext && parentNext && frameNext->GetParent() == parentNext;

}

/**

 * Adjusts the margin for a list (ol, ul), if necessary, depending on

 * font inflation settings. Unfortunately, because bullets from a list are

 * placed in the margin area, we only have ~40px in which to place the

 * bullets. When they are inflated, however, this causes problems, since

 * the text takes up more space than is available in the margin.

 *

 * This method will return a small amount (in app units) by which the

 * margin can be adjusted, so that the space is available for list

 * bullets to be rendered with font inflation enabled.

 */

static  nscoord

FontSizeInflationListMarginAdjustment(const nsIFrame* aFrame)

{

  float inflation = nsLayoutUtils::FontSizeInflationFor(aFrame);

  if (aFrame->IsFrameOfType(nsIFrame::eBlockFrame)) {

    const nsBlockFrame* blockFrame = static_cast<const nsBlockFrame*>(aFrame);

    // We only want to adjust the margins if we're dealing with an ordered

    // list.

    if (inflation > 1.0f &&

        blockFrame->HasBullet() &&

        inflation > 1.0f) {

      auto listStyleType = aFrame->StyleList()->mCounterStyle->GetStyle();

      if (listStyleType != NS_STYLE_LIST_STYLE_NONE &&

          listStyleType != NS_STYLE_LIST_STYLE_DISC &&

          listStyleType != NS_STYLE_LIST_STYLE_CIRCLE &&

          listStyleType != NS_STYLE_LIST_STYLE_SQUARE &&

          listStyleType != NS_STYLE_LIST_STYLE_DISCLOSURE_CLOSED &&

          listStyleType != NS_STYLE_LIST_STYLE_DISCLOSURE_OPEN) {

        // The HTML spec states that the default padding for ordered lists

        // begins at 40px, indicating that we have 40px of space to place a

        // bullet. When performing font inflation calculations, we add space

        // equivalent to this, but simply inflated at the same amount as the

        // text, in app units.

        return nsPresContext::CSSPixelsToAppUnits(40) * (inflation - 1);

      }

    }

  }

  return 0;

}

SizeComputationInput::SizeComputationInput(nsIFrame *aFrame,

                                   gfxContext *aRenderingContext,

                                   WritingMode aContainingBlockWritingMode,

                                   nscoord aContainingBlockISize)

  : mFrame(aFrame)

  , mRenderingContext(aRenderingContext)

  , mWritingMode(aFrame->GetWritingMode())

{

  ReflowInputFlags flags;

  InitOffsets(aContainingBlockWritingMode, aContainingBlockISize,

              mFrame->Type(), flags);

}

// Initialize a reflow state for a child frame's reflow. Some state

// is copied from the parent reflow state; the remaining state is

// computed.

ReflowInput::ReflowInput(

                     nsPresContext*           aPresContext,

                     const ReflowInput& aParentReflowInput,

                     nsIFrame*                aFrame,

                     const LogicalSize&       aAvailableSpace,

                     const LogicalSize*       aContainingBlockSize,

                     uint32_t                 aFlags)

  : SizeComputationInput(aFrame, aParentReflowInput.mRenderingContext)

  , mCBReflowInput(nullptr) // will be setup properly later in InitCBReflowInput

  , mBlockDelta(0)

  , mOrthogonalLimit(NS_UNCONSTRAINEDSIZE)

  , mAvailableWidth(0)

  , mAvailableHeight(0)

  , mContainingBlockSize(mWritingMode)

  , mFlags(aParentReflowInput.mFlags)

  , mReflowDepth(aParentReflowInput.mReflowDepth + 1)

{

  MOZ_ASSERT(aPresContext, "no pres context");

  MOZ_ASSERT(aFrame, "no frame");

  MOZ_ASSERT(aPresContext == aFrame->PresContext(), "wrong pres context");

  MOZ_ASSERT(!mFlags.mSpecialBSizeReflow ||

                  !NS_SUBTREE_DIRTY(aFrame),

             "frame should be clean when getting special bsize reflow");

  mParentReflowInput = &aParentReflowInput;

  AvailableISize() = aAvailableSpace.ISize(mWritingMode);

  AvailableBSize() = aAvailableSpace.BSize(mWritingMode);

  if (mWritingMode.IsOrthogonalTo(aParentReflowInput.GetWritingMode())) {

    // If we're setting up for an orthogonal flow, and the parent reflow state

    // had a constrained ComputedBSize, we can use that as our AvailableISize

    // in preference to leaving it unconstrained.

    if (AvailableISize() == NS_UNCONSTRAINEDSIZE &&

        aParentReflowInput.ComputedBSize() != NS_UNCONSTRAINEDSIZE) {

      AvailableISize() = aParentReflowInput.ComputedBSize();

    }

  }

  mFloatManager = aParentReflowInput.mFloatManager;

  if (mFrame->IsFrameOfType(nsIFrame::eLineParticipant))

    mLineLayout = aParentReflowInput.mLineLayout;

  else

    mLineLayout = nullptr;

  // Note: mFlags was initialized as a copy of aParentReflowInput.mFlags up in

  // this constructor's init list, so the only flags that we need to explicitly

  // initialize here are those that may need a value other than our parent's.

  mFlags.mNextInFlowUntouched = aParentReflowInput.mFlags.mNextInFlowUntouched &&

    CheckNextInFlowParenthood(aFrame, aParentReflowInput.mFrame);

  mFlags.mAssumingHScrollbar = mFlags.mAssumingVScrollbar = false;

  mFlags.mIsColumnBalancing = false;

  mFlags.mIsFlexContainerMeasuringBSize = false;

  mFlags.mDummyParentReflowInput = false;

  mFlags.mShrinkWrap = !!(aFlags & COMPUTE_SIZE_SHRINK_WRAP);

  mFlags.mUseAutoBSize = !!(aFlags & COMPUTE_SIZE_USE_AUTO_BSIZE);

  mFlags.mStaticPosIsCBOrigin = !!(aFlags & STATIC_POS_IS_CB_ORIGIN);

  mFlags.mIOffsetsNeedCSSAlign = mFlags.mBOffsetsNeedCSSAlign = false;

  mFlags.mIClampMarginBoxMinSize = !!(aFlags & I_CLAMP_MARGIN_BOX_MIN_SIZE);

  mFlags.mBClampMarginBoxMinSize = !!(aFlags & B_CLAMP_MARGIN_BOX_MIN_SIZE);

  mFlags.mApplyAutoMinSize = !!(aFlags & I_APPLY_AUTO_MIN_SIZE);

  mDiscoveredClearance = nullptr;

  mPercentBSizeObserver = (aParentReflowInput.mPercentBSizeObserver &&

                            aParentReflowInput.mPercentBSizeObserver->NeedsToObserve(*this))

                           ? aParentReflowInput.mPercentBSizeObserver : nullptr;

  if ((aFlags & DUMMY_PARENT_REFLOW_STATE) ||

      (mParentReflowInput->mFlags.mDummyParentReflowInput &&

       mFrame->IsTableFrame())) {

    mFlags.mDummyParentReflowInput = true;

  }

  if (!(aFlags & CALLER_WILL_INIT)) {

    Init(aPresContext, aContainingBlockSize);

  }

}

inline nscoord

SizeComputationInput::ComputeISizeValue(nscoord aContainingBlockISize,

                                    nscoord aContentEdgeToBoxSizing,

                                    nscoord aBoxSizingToMarginEdge,

                                    const nsStyleCoord& aCoord) const

{

  return mFrame->ComputeISizeValue(mRenderingContext,

                                   aContainingBlockISize,

                                   aContentEdgeToBoxSizing,

                                   aBoxSizingToMarginEdge,

                                   aCoord);

}

nscoord

SizeComputationInput::ComputeISizeValue(nscoord aContainingBlockISize,

                                    StyleBoxSizing aBoxSizing,

                                    const nsStyleCoord& aCoord) const

{

  WritingMode wm = GetWritingMode();

  nscoord inside = 0, outside = ComputedLogicalBorderPadding().IStartEnd(wm) +

                                ComputedLogicalMargin().IStartEnd(wm);

  if (aBoxSizing == StyleBoxSizing::Border) {

    inside = ComputedLogicalBorderPadding().IStartEnd(wm);

  }

  outside -= inside;

  return ComputeISizeValue(aContainingBlockISize, inside,

                           outside, aCoord);

}

nscoord

SizeComputationInput::ComputeBSizeValue(nscoord aContainingBlockBSize,

                                    StyleBoxSizing aBoxSizing,

                                    const nsStyleCoord& aCoord) const

{

  WritingMode wm = GetWritingMode();

  nscoord inside = 0;

  if (aBoxSizing == StyleBoxSizing::Border) {

    inside = ComputedLogicalBorderPadding().BStartEnd(wm);

  }

  return nsLayoutUtils::ComputeBSizeValue(aContainingBlockBSize,

                                          inside, aCoord);

}

void

ReflowInput::SetComputedWidth(nscoord aComputedWidth)

{

  NS_ASSERTION(mFrame, "Must have a frame!");

  // It'd be nice to assert that |frame| is not in reflow, but this fails for

  // two reasons:

  //

  // 1) Viewport frames reset the computed width on a copy of their reflow

  //    state when reflowing fixed-pos kids.  In that case we actually don't

  //    want to mess with the resize flags, because comparing the frame's rect

  //    to the munged computed width is pointless.

  // 2) nsFrame::BoxReflow creates a reflow state for its parent.  This reflow

  //    state is not used to reflow the parent, but just as a parent for the

  //    frame's own reflow state.  So given a nsBoxFrame inside some non-XUL

  //    (like a text control, for example), we'll end up creating a reflow

  //    state for the parent while the parent is reflowing.

  MOZ_ASSERT(aComputedWidth >= 0, "Invalid computed width");

  if (ComputedWidth() != aComputedWidth) {

    ComputedWidth() = aComputedWidth;

    LayoutFrameType frameType = mFrame->Type();

    if (frameType != LayoutFrameType::Viewport || // Or check GetParent()?

        mWritingMode.IsVertical()) {

      InitResizeFlags(mFrame->PresContext(), frameType);

    }

  }

}

void

ReflowInput::SetComputedHeight(nscoord aComputedHeight)

{

  NS_ASSERTION(mFrame, "Must have a frame!");

  // It'd be nice to assert that |frame| is not in reflow, but this fails

  // because:

  //

  //    nsFrame::BoxReflow creates a reflow state for its parent.  This reflow

  //    state is not used to reflow the parent, but just as a parent for the

  //    frame's own reflow state.  So given a nsBoxFrame inside some non-XUL

  //    (like a text control, for example), we'll end up creating a reflow

  //    state for the parent while the parent is reflowing.

  MOZ_ASSERT(aComputedHeight >= 0, "Invalid computed height");

  if (ComputedHeight() != aComputedHeight) {

    ComputedHeight() = aComputedHeight;

    LayoutFrameType frameType = mFrame->Type();

    if (frameType != LayoutFrameType::Viewport || !mWritingMode.IsVertical()) {

      InitResizeFlags(mFrame->PresContext(), frameType);

    }

  }

}

void

ReflowInput::Init(nsPresContext*     aPresContext,

                        const LogicalSize* aContainingBlockSize,

                        const nsMargin*    aBorder,

                        const nsMargin*    aPadding)

{

  if ((mFrame->GetStateBits() & NS_FRAME_IS_DIRTY) &&

      !mFrame->IsXULBoxFrame()) {

    // Mark all child frames as dirty.

    //

    // We don't do this for XUL boxes because they handle their child

    // reflow separately.

    //

    // FIXME (bug 1376530): It would be better for memory locality if we

    // did this as we went.  However, we need to be careful not to do

    // this twice for any particular child if we reflow it twice.  The

    // easiest way to accomplish that is to do it at the start.

    for (nsIFrame::ChildListIterator childLists(mFrame);

         !childLists.IsDone(); childLists.Next()) {

      for (nsIFrame* childFrame : childLists.CurrentList()) {

        if (!childFrame->IsTableColGroupFrame()) {

          childFrame->AddStateBits(NS_FRAME_IS_DIRTY);

        }

      }

    }

  }

  if (AvailableISize() == NS_UNCONSTRAINEDSIZE) {

    // Look up the parent chain for an orthogonal inline limit,

    // and reset AvailableISize() if found.

    for (const ReflowInput *parent = mParentReflowInput;

         parent != nullptr; parent = parent->mParentReflowInput) {

      if (parent->GetWritingMode().IsOrthogonalTo(mWritingMode) &&

          parent->mOrthogonalLimit != NS_UNCONSTRAINEDSIZE) {

        AvailableISize() = parent->mOrthogonalLimit;

        break;

      }

    }

  }

  LAYOUT_WARN_IF_FALSE(AvailableISize() != NS_UNCONSTRAINEDSIZE,

                       "have unconstrained inline-size; this should only "

                       "result from very large sizes, not attempts at "

                       "intrinsic inline-size calculation");

  mStylePosition = mFrame->StylePosition();

  mStyleDisplay = mFrame->StyleDisplay();

  mStyleVisibility = mFrame->StyleVisibility();

  mStyleBorder = mFrame->StyleBorder();

  mStyleMargin = mFrame->StyleMargin();

  mStylePadding = mFrame->StylePadding();

  mStyleText = mFrame->StyleText();

  InitCBReflowInput();

  LayoutFrameType type = mFrame->Type();

  if (type == mozilla::LayoutFrameType::Placeholder) {

    // Placeholders have a no-op Reflow method that doesn't need the rest of

    // this initialization, so we bail out early.

    ComputedBSize() = ComputedISize() = 0;

    return;

  }

  InitFrameType(type);

  LogicalSize cbSize(mWritingMode, -1, -1);

  if (aContainingBlockSize) {

    cbSize = *aContainingBlockSize;

  }

  InitConstraints(aPresContext, cbSize, aBorder, aPadding, type);

  InitResizeFlags(aPresContext, type);

  nsIFrame *parent = mFrame->GetParent();

  if (parent &&

      (parent->GetStateBits() & NS_FRAME_IN_CONSTRAINED_BSIZE) &&

      !(parent->IsScrollFrame() &&

        parent->StyleDisplay()->mOverflowY != NS_STYLE_OVERFLOW_HIDDEN)) {

    mFrame->AddStateBits(NS_FRAME_IN_CONSTRAINED_BSIZE);

  } else if (type == LayoutFrameType::SVGForeignObject) {

    // An SVG foreignObject frame is inherently constrained block-size.

    mFrame->AddStateBits(NS_FRAME_IN_CONSTRAINED_BSIZE);

  } else {

    const nsStyleCoord& bSizeCoord = mStylePosition->BSize(mWritingMode);

    const nsStyleCoord& maxBSizeCoord = mStylePosition->MaxBSize(mWritingMode);

    if ((bSizeCoord.GetUnit() != eStyleUnit_Auto ||

         maxBSizeCoord.GetUnit() != eStyleUnit_None) &&

         // Don't set NS_FRAME_IN_CONSTRAINED_BSIZE on body or html elements.

         (mFrame->GetContent() &&

        !(mFrame->GetContent()->IsAnyOfHTMLElements(nsGkAtoms::body,

                                                   nsGkAtoms::html)))) {

      // If our block-size was specified as a percentage, then this could

      // actually resolve to 'auto', based on:

      // http://www.w3.org/TR/CSS21/visudet.html#the-height-property

      nsIFrame* containingBlk = mFrame;

      while (containingBlk) {

        const nsStylePosition* stylePos = containingBlk->StylePosition();

        const nsStyleCoord& bSizeCoord = stylePos->BSize(mWritingMode);

        const nsStyleCoord& maxBSizeCoord = stylePos->MaxBSize(mWritingMode);

        if ((bSizeCoord.IsCoordPercentCalcUnit() &&

             !bSizeCoord.HasPercent()) ||

            (maxBSizeCoord.IsCoordPercentCalcUnit() &&

             !maxBSizeCoord.HasPercent())) {

          mFrame->AddStateBits(NS_FRAME_IN_CONSTRAINED_BSIZE);

          break;

        } else if ((bSizeCoord.IsCoordPercentCalcUnit() &&

                    bSizeCoord.HasPercent()) ||

                   (maxBSizeCoord.IsCoordPercentCalcUnit() &&

                    maxBSizeCoord.HasPercent())) {

          if (!(containingBlk = containingBlk->GetContainingBlock())) {

            // If we've reached the top of the tree, then we don't have

            // a constrained block-size.

            mFrame->RemoveStateBits(NS_FRAME_IN_CONSTRAINED_BSIZE);

            break;

          }

          continue;

        } else {

          mFrame->RemoveStateBits(NS_FRAME_IN_CONSTRAINED_BSIZE);

          break;

        }

      }

    } else {

      mFrame->RemoveStateBits(NS_FRAME_IN_CONSTRAINED_BSIZE);

    }

  }

  if (mParentReflowInput &&

      mParentReflowInput->GetWritingMode().IsOrthogonalTo(mWritingMode)) {

    // Orthogonal frames are always reflowed with an unconstrained

    // dimension to avoid incomplete reflow across an orthogonal

    // boundary. Normally this is the block-size, but for column sets

    // with auto-height it's the inline-size, so that they can add

    // columns in the container's block direction

    if (type == LayoutFrameType::ColumnSet &&

        eStyleUnit_Auto == mStylePosition->ISize(mWritingMode).GetUnit()) {

      ComputedISize() = NS_UNCONSTRAINEDSIZE;

    } else {

      AvailableBSize() = NS_UNCONSTRAINEDSIZE;

    }

  }

  if (mStyleDisplay->IsContainSize()) {

    // In the case that a box is size contained, we want to ensure

    // that it is also monolithic. We do this by unsetting

    // AvailableBSize() to avoid fragmentaiton.

    AvailableBSize() = NS_UNCONSTRAINEDSIZE;

  }

  LAYOUT_WARN_IF_FALSE((mFrameType == NS_CSS_FRAME_TYPE_INLINE &&

                        !mFrame->IsFrameOfType(nsIFrame::eReplaced)) ||

                       type == LayoutFrameType::Text ||

                       ComputedISize() != NS_UNCONSTRAINEDSIZE,

                       "have unconstrained inline-size; this should only "

                       "result from very large sizes, not attempts at "

                       "intrinsic inline-size calculation");

}

void ReflowInput::InitCBReflowInput()

{

  if (!mParentReflowInput) {

    mCBReflowInput = nullptr;

    return;

  }

  if (mParentReflowInput->mFlags.mDummyParentReflowInput) {

    mCBReflowInput = mParentReflowInput;

    return;

  }

  if (mParentReflowInput->mFrame == mFrame->GetContainingBlock(0, mStyleDisplay)) {

    // Inner table frames need to use the containing block of the outer

    // table frame.

    if (mFrame->IsTableFrame()) {

      mCBReflowInput = mParentReflowInput->mCBReflowInput;

    } else {

      mCBReflowInput = mParentReflowInput;

    }

  } else {

    mCBReflowInput = mParentReflowInput->mCBReflowInput;

  }

}

/* Check whether CalcQuirkContainingBlockHeight would stop on the

 * given reflow state, using its block as a height.  (essentially

 * returns false for any case in which CalcQuirkContainingBlockHeight

 * has a "continue" in its main loop.)

 *

 * XXX Maybe refactor CalcQuirkContainingBlockHeight so it uses

 * this function as well

 */

static bool

IsQuirkContainingBlockHeight(const ReflowInput* rs, LayoutFrameType aFrameType)

{

  if (LayoutFrameType::Block == aFrameType ||

#ifdef MOZ_XUL

      LayoutFrameType::XULLabel == aFrameType ||

#endif

      LayoutFrameType::Scroll == aFrameType) {

    // Note: This next condition could change due to a style change,

    // but that would cause a style reflow anyway, which means we're ok.

    if (NS_AUTOHEIGHT == rs->ComputedHeight()) {

      if (!rs->mFrame->IsAbsolutelyPositioned(rs->mStyleDisplay)) {

        return false;

      }

    }

  }

  return true;

}

void

ReflowInput::InitResizeFlags(nsPresContext* aPresContext,

                             LayoutFrameType aFrameType)

{

  SetBResize(false);

  SetIResize(false);

  const WritingMode wm = mWritingMode; // just a shorthand

  // We should report that we have a resize in the inline dimension if

  // *either* the border-box size or the content-box size in that

  // dimension has changed.  It might not actually be necessary to do

  // this if the border-box size has changed and the content-box size

  // has not changed, but since we've historically used the flag to mean

  // border-box size change, continue to do that.  (It's possible for

  // the content-box size to change without a border-box size change or

  // a style change given (1) a fixed width (possibly fixed by max-width

  // or min-width), (2) box-sizing:border-box or padding-box, and

  // (3) percentage padding.)

  //

  // However, we don't actually have the information at this point to

  // tell whether the content-box size has changed, since both style

  // data and the UsedPaddingProperty() have already been updated.  So,

  // instead, we explicitly check for the case where it's possible for

  // the content-box size to have changed without either (a) a change in

  // the border-box size or (b) an nsChangeHint_NeedDirtyReflow change

  // hint due to change in border or padding.  Thus we test using the

  // conditions from the previous paragraph, except without testing (1)

  // since it's complicated to test properly and less likely to help

  // with optimizing cases away.

  bool isIResize =

    // is the border-box resizing?

    mFrame->ISize(wm) !=

      ComputedISize() + ComputedLogicalBorderPadding().IStartEnd(wm) ||

    // or is the content-box resizing?  (see comment above)

    (mStylePosition->mBoxSizing != StyleBoxSizing::Content &&

     mStylePadding->IsWidthDependent());

  if ((mFrame->GetStateBits() & NS_FRAME_FONT_INFLATION_FLOW_ROOT) &&

      nsLayoutUtils::FontSizeInflationEnabled(aPresContext)) {

    // Create our font inflation data if we don't have it already, and

    // give it our current width information.

    bool dirty = nsFontInflationData::UpdateFontInflationDataISizeFor(*this) &&

                 // Avoid running this at the box-to-block interface

                 // (where we shouldn't be inflating anyway, and where

                 // reflow state construction is probably to construct a

                 // dummy parent reflow state anyway).

                 !mFlags.mDummyParentReflowInput;

    if (dirty || (!mFrame->GetParent() && isIResize)) {

      // When font size inflation is enabled, a change in either:

      //  * the effective width of a font inflation flow root

      //  * the width of the frame

      // needs to cause a dirty reflow since they change the font size

      // inflation calculations, which in turn change the size of text,

      // line-heights, etc.  This is relatively similar to a classic

      // case of style change reflow, except that because inflation

      // doesn't affect the intrinsic sizing codepath, there's no need

      // to invalidate intrinsic sizes.

      //

      // Note that this makes horizontal resizing a good bit more

      // expensive.  However, font size inflation is targeted at a set of

      // devices (zoom-and-pan devices) where the main use case for

      // horizontal resizing needing to be efficient (window resizing) is

      // not present.  It does still increase the cost of dynamic changes

      // caused by script where a style or content change in one place

      // causes a resize in another (e.g., rebalancing a table).

      // FIXME: This isn't so great for the cases where

      // ReflowInput::SetComputedWidth is called, if the first time

      // we go through InitResizeFlags we set IsHResize() to true, and then

      // the second time we'd set it to false even without the

      // NS_FRAME_IS_DIRTY bit already set.

      if (mFrame->IsSVGForeignObjectFrame()) {

        // Foreign object frames use dirty bits in a special way.

        mFrame->AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN);

        nsIFrame *kid = mFrame->PrincipalChildList().FirstChild();

        if (kid) {

          kid->AddStateBits(NS_FRAME_IS_DIRTY);

        }

      } else {

        mFrame->AddStateBits(NS_FRAME_IS_DIRTY);

      }

      // Mark intrinsic widths on all descendants dirty.  We need to do

      // this (1) since we're changing the size of text and need to

      // clear text runs on text frames and (2) since we actually are

      // changing some intrinsic widths, but only those that live inside

      // of containers.

      // It makes sense to do this for descendants but not ancestors

      // (which is unusual) because we're only changing the unusual

      // inflation-dependent intrinsic widths (i.e., ones computed with

      // nsPresContext::mInflationDisabledForShrinkWrap set to false),

      // which should never affect anything outside of their inflation

      // flow root (or, for that matter, even their inflation

      // container).

      // This is also different from what PresShell::FrameNeedsReflow

      // does because it doesn't go through placeholders.  It doesn't

      // need to because we're actually doing something that cares about

      // frame tree geometry (the width on an ancestor) rather than

      // style.

      AutoTArray<nsIFrame*, 32> stack;

      stack.AppendElement(mFrame);

      do {

        nsIFrame *f = stack.PopLastElement();

        nsIFrame::ChildListIterator lists(f);

        for (; !lists.IsDone(); lists.Next()) {

          nsFrameList::Enumerator childFrames(lists.CurrentList());

          for (; !childFrames.AtEnd(); childFrames.Next()) {

            nsIFrame* kid = childFrames.get();

            kid->MarkIntrinsicISizesDirty();

            stack.AppendElement(kid);

          }

        }

      } while (stack.Length() != 0);

    }

  }

  SetIResize(!(mFrame->GetStateBits() & NS_FRAME_IS_DIRTY) &&

             isIResize);

  // XXX Should we really need to null check mCBReflowInput?  (We do for

  // at least nsBoxFrame).

  if (IsTableCell(aFrameType) &&

      (mFlags.mSpecialBSizeReflow ||

       (mFrame->FirstInFlow()->GetStateBits() &

         NS_TABLE_CELL_HAD_SPECIAL_REFLOW)) &&

      (mFrame->GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_BSIZE)) {

    // Need to set the bit on the cell so that

    // mCBReflowInput->IsBResize() is set correctly below when

    // reflowing descendant.

    SetBResize(true);

  } else if (mCBReflowInput && mFrame->IsBlockWrapper()) {

    // XXX Is this problematic for relatively positioned inlines acting

    // as containing block for absolutely positioned elements?

    // Possibly; in that case we should at least be checking

    // NS_SUBTREE_DIRTY, I'd think.

    SetBResize(mCBReflowInput->IsBResizeForWM(wm));

  } else if (mCBReflowInput && !nsLayoutUtils::GetAsBlock(mFrame)) {

    // Some non-block frames (e.g. table frames) aggressively optimize out their

    // BSize recomputation when they don't have the BResize flag set.  This

    // means that if they go from having a computed non-auto height to having an

    // auto height and don't have that flag set, they will not actually compute

    // their auto height and will just remain at whatever size they already

    // were.  We can end up in that situation if the child has a percentage

    // specified height and the parent changes from non-auto height to auto

    // height.  When that happens, the parent will typically have the BResize

    // flag set, and we want to propagate that flag to the kid.

    //

    // Ideally it seems like we'd do this for blocks too, of course... but we'd

    // really want to restrict it to the percentage height case or something, to

    // avoid extra reflows in common cases.  Maybe we should be examining

    // mStylePosition->BSize(wm).GetUnit() for that purpose?

    //

    // Note that we _also_ need to set the BResize flag if we have auto

    // ComputedBSize() and a dirty subtree, since that might require us to

    // change BSize due to kids having been added or removed.

    SetBResize(mCBReflowInput->IsBResizeForWM(wm));

    if (ComputedBSize() == NS_AUTOHEIGHT) {

      SetBResize(IsBResize() || NS_SUBTREE_DIRTY(mFrame));

    }

  } else if (ComputedBSize() == NS_AUTOHEIGHT) {

    if (eCompatibility_NavQuirks == aPresContext->CompatibilityMode() &&

        mCBReflowInput) {

      SetBResize(mCBReflowInput->IsBResizeForWM(wm));

    } else {

      SetBResize(IsIResize());

    }

    SetBResize(IsBResize() || NS_SUBTREE_DIRTY(mFrame));

  } else {

    // not 'auto' block-size

    SetBResize(mFrame->BSize(wm) !=

               ComputedBSize() + ComputedLogicalBorderPadding().BStartEnd(wm));

  }

  bool dependsOnCBBSize =

    (mStylePosition->BSizeDependsOnContainer(wm) &&

     // FIXME: condition this on not-abspos?

     mStylePosition->BSize(wm).GetUnit() != eStyleUnit_Auto) ||

    mStylePosition->MinBSizeDependsOnContainer(wm) ||

    mStylePosition->MaxBSizeDependsOnContainer(wm) ||

    mStylePosition->OffsetHasPercent(wm.PhysicalSide(eLogicalSideBStart)) ||

    mStylePosition->mOffset.GetBEndUnit(wm) != eStyleUnit_Auto ||

    mFrame->IsXULBoxFrame();

  if (mStyleText->mLineHeight.GetUnit() == eStyleUnit_Enumerated) {

    NS_ASSERTION(mStyleText->mLineHeight.GetIntValue() ==

                 NS_STYLE_LINE_HEIGHT_BLOCK_HEIGHT,

                 "bad line-height value");

    // line-height depends on block bsize

    mFrame->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);

    // but only on containing blocks if this frame is not a suitable block

    dependsOnCBBSize |= !nsLayoutUtils::IsNonWrapperBlock(mFrame);

  }

  // If we're the descendant of a table cell that performs special bsize

  // reflows and we could be the child that requires them, always set

  // the block-axis resize in case this is the first pass before the

  // special bsize reflow.  However, don't do this if it actually is

  // the special bsize reflow, since in that case it will already be

  // set correctly above if we need it set.

  if (!IsBResize() && mCBReflowInput &&

      (IsTableCell(mCBReflowInput->mFrame->Type()) ||

       mCBReflowInput->mFlags.mHeightDependsOnAncestorCell) &&

      !mCBReflowInput->mFlags.mSpecialBSizeReflow &&

      dependsOnCBBSize) {

    SetBResize(true);

    mFlags.mHeightDependsOnAncestorCell = true;

  }

  // Set NS_FRAME_CONTAINS_RELATIVE_BSIZE if it's needed.

  // It would be nice to check that |ComputedBSize != NS_AUTOHEIGHT|

  // &&ed with the percentage bsize check.  However, this doesn't get

  // along with table special bsize reflows, since a special bsize

  // reflow (a quirk that makes such percentage height work on children

  // of table cells) can cause not just a single percentage height to

  // become fixed, but an entire descendant chain of percentage height

  // to become fixed.

  if (dependsOnCBBSize && mCBReflowInput) {

    const ReflowInput *rs = this;

    bool hitCBReflowInput = false;

    do {

      rs = rs->mParentReflowInput;

      if (!rs) {

        break;

      }

      if (rs->mFrame->GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_BSIZE) {

        break; // no need to go further

      }

      rs->mFrame->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);

      // Keep track of whether we've hit the containing block, because

      // we need to go at least that far.

      if (rs == mCBReflowInput) {

        hitCBReflowInput = true;

      }

      // XXX What about orthogonal flows? It doesn't make sense to

      // keep propagating this bit across an orthogonal boundary,

      // where the meaning of BSize changes. Bug 1175517.

    } while (!hitCBReflowInput ||

             (eCompatibility_NavQuirks == aPresContext->CompatibilityMode() &&

              !IsQuirkContainingBlockHeight(rs, rs->mFrame->Type())));

    // Note: We actually don't need to set the

    // NS_FRAME_CONTAINS_RELATIVE_BSIZE bit for the cases

    // where we hit the early break statements in

    // CalcQuirkContainingBlockHeight. But it doesn't hurt

    // us to set the bit in these cases.

  }

  if (mFrame->GetStateBits() & NS_FRAME_IS_DIRTY) {

    // If we're reflowing everything, then we'll find out if we need

    // to re-set this.

    mFrame->RemoveStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);

  }

}

nscoord

ReflowInput::GetContainingBlockContentISize(WritingMode aWritingMode) const

{

  if (!mCBReflowInput) {

    return 0;

  }

  return mCBReflowInput->GetWritingMode().IsOrthogonalTo(aWritingMode)

    ? mCBReflowInput->ComputedBSize()

    : mCBReflowInput->ComputedISize();

}

void

ReflowInput::InitFrameType(LayoutFrameType aFrameType)

{

  const nsStyleDisplay *disp = mStyleDisplay;

  nsCSSFrameType frameType;

  DISPLAY_INIT_TYPE(mFrame, this);

  if (aFrameType == LayoutFrameType::Table) {

    mFrameType = NS_CSS_FRAME_TYPE_BLOCK;

    return;

  }

  NS_ASSERTION(mFrame->StyleDisplay()->IsAbsolutelyPositionedStyle() ==

                 disp->IsAbsolutelyPositionedStyle(),

               "Unexpected position style");

  NS_ASSERTION(mFrame->StyleDisplay()->IsFloatingStyle() ==

                 disp->IsFloatingStyle(), "Unexpected float style");

  if (mFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) {

    if (disp->IsAbsolutelyPositioned(mFrame)) {

      frameType = NS_CSS_FRAME_TYPE_ABSOLUTE;

      //XXXfr hack for making frames behave properly when in overflow container lists

      //      see bug 154892; need to revisit later

      if (mFrame->GetPrevInFlow())

        frameType = NS_CSS_FRAME_TYPE_BLOCK;

    }

    else if (disp->IsFloating(mFrame)) {

      frameType = NS_CSS_FRAME_TYPE_FLOATING;

    } else {

      NS_ASSERTION(disp->mDisplay == StyleDisplay::MozPopup,