The Tor Browser: comparison layout/generic/nsHTMLReflowState.cpp

--1:000000000000
+:e9e6c80e7201
+/* -*- 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/. */
+/* struct containing the input to nsIFrame::Reflow */
+#include "nsHTMLReflowState.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 "nsFlexContainerFrame.h"
+#include "nsImageFrame.h"
+#include "nsTableFrame.h"
+#include "nsTableCellFrame.h"
+#include "nsIPercentHeightObserver.h"
+#include "nsLayoutUtils.h"
+#include "mozilla/Preferences.h"
+#include "nsFontInflationData.h"
+#include "StickyScrollContainer.h"
+#include "nsIFrameInlines.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.
+nsHTMLReflowState::nsHTMLReflowState(nsPresContext*       aPresContext,
+nsIFrame*            aFrame,
+nsRenderingContext*  aRenderingContext,
+const nsSize&        aAvailableSpace,
+uint32_t             aFlags)
+: nsCSSOffsetState(aFrame, aRenderingContext)
+, mBlockDelta(0)
+, mReflowDepth(0)
+{
+NS_PRECONDITION(aRenderingContext, "no rendering context");
+MOZ_ASSERT(aPresContext, "no pres context");
+MOZ_ASSERT(aFrame, "no frame");
+MOZ_ASSERT(aPresContext == aFrame->PresContext(), "wrong pres context");
+parentReflowState = nullptr;
+AvailableWidth() = aAvailableSpace.width;
+AvailableHeight() = aAvailableSpace.height;
+mFloatManager = nullptr;
+mLineLayout = nullptr;
+memset(&mFlags, 0, sizeof(mFlags));
+mDiscoveredClearance = nullptr;
+mPercentHeightObserver = nullptr;
+if (aFlags & DUMMY_PARENT_REFLOW_STATE) {
+mFlags.mDummyParentReflowState = 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);
+const nsStyleList* styleList = aFrame->StyleList();
+// We only want to adjust the margins if we're dealing with an ordered
+// list.
+if (inflation > 1.0f &&
+blockFrame->HasBullet() &&
+styleList->mListStyleType != NS_STYLE_LIST_STYLE_NONE &&
+styleList->mListStyleType != NS_STYLE_LIST_STYLE_DISC &&
+styleList->mListStyleType != NS_STYLE_LIST_STYLE_CIRCLE &&
+styleList->mListStyleType != NS_STYLE_LIST_STYLE_SQUARE &&
+inflation > 1.0f) {
+// 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;
+}
+// NOTE: If we ever want to use nsCSSOffsetState for a flex item or a grid
+// item, we need to make it take the containing-block height as well as the
+// width, since flex items and grid items resolve vertical percent margins
+// and padding against the containing-block height, rather than its width.
+nsCSSOffsetState::nsCSSOffsetState(nsIFrame *aFrame,
+nsRenderingContext *aRenderingContext,
+nscoord aContainingBlockWidth)
+: frame(aFrame)
+, rendContext(aRenderingContext)
+, mWritingMode(aFrame->GetWritingMode())
+{
+MOZ_ASSERT(!aFrame->IsFlexItem(),
+"We're about to resolve vertical percent margin & padding "
+"values against CB width, which is incorrect for flex items");
+InitOffsets(aContainingBlockWidth, aContainingBlockWidth, frame->GetType());
+}
+// Initialize a reflow state for a child frame's reflow. Some state
+// is copied from the parent reflow state; the remaining state is
+// computed.
+nsHTMLReflowState::nsHTMLReflowState(nsPresContext*           aPresContext,
+const nsHTMLReflowState& aParentReflowState,
+nsIFrame*                aFrame,
+const nsSize&            aAvailableSpace,
+nscoord                  aContainingBlockWidth,
+nscoord                  aContainingBlockHeight,
+uint32_t                 aFlags)
+: nsCSSOffsetState(aFrame, aParentReflowState.rendContext)
+, mBlockDelta(0)
+, mReflowDepth(aParentReflowState.mReflowDepth + 1)
+, mFlags(aParentReflowState.mFlags)
+{
+MOZ_ASSERT(aPresContext, "no pres context");
+MOZ_ASSERT(aFrame, "no frame");
+MOZ_ASSERT(aPresContext == aFrame->PresContext(), "wrong pres context");
+NS_PRECONDITION((aContainingBlockWidth == -1) ==
+(aContainingBlockHeight == -1),
+"cb width and height should only be non-default together");
+NS_PRECONDITION(!mFlags.mSpecialHeightReflow ||
+!NS_SUBTREE_DIRTY(aFrame),
+"frame should be clean when getting special height reflow");
+parentReflowState = &aParentReflowState;
+// If the parent is dirty, then the child is as well.
+// XXX Are the other cases where the parent reflows a child a second
+// time, as a resize?
+if (!mFlags.mSpecialHeightReflow)
+frame->AddStateBits(parentReflowState->frame->GetStateBits() &
+NS_FRAME_IS_DIRTY);
+AvailableWidth() = aAvailableSpace.width;
+AvailableHeight() = aAvailableSpace.height;
+mFloatManager = aParentReflowState.mFloatManager;
+if (frame->IsFrameOfType(nsIFrame::eLineParticipant))
+mLineLayout = aParentReflowState.mLineLayout;
+else
+mLineLayout = nullptr;
+// Note: mFlags was initialized as a copy of aParentReflowState.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 = aParentReflowState.mFlags.mNextInFlowUntouched &&
+CheckNextInFlowParenthood(aFrame, aParentReflowState.frame);
+mFlags.mAssumingHScrollbar = mFlags.mAssumingVScrollbar = false;
+mFlags.mHasClearance = false;
+mFlags.mIsColumnBalancing = false;
+mFlags.mIsFlexContainerMeasuringHeight = false;
+mFlags.mDummyParentReflowState = false;
+mDiscoveredClearance = nullptr;
+mPercentHeightObserver = (aParentReflowState.mPercentHeightObserver &&
+aParentReflowState.mPercentHeightObserver->NeedsToObserve(*this))
+? aParentReflowState.mPercentHeightObserver : nullptr;
+if (aFlags & DUMMY_PARENT_REFLOW_STATE) {
+mFlags.mDummyParentReflowState = true;
+}
+if (!(aFlags & CALLER_WILL_INIT)) {
+Init(aPresContext, aContainingBlockWidth, aContainingBlockHeight);
+}
+}
+inline nscoord
+nsCSSOffsetState::ComputeWidthValue(nscoord aContainingBlockWidth,
+nscoord aContentEdgeToBoxSizing,
+nscoord aBoxSizingToMarginEdge,
+const nsStyleCoord& aCoord)
+{
+return nsLayoutUtils::ComputeWidthValue(rendContext, frame,
+aContainingBlockWidth,
+aContentEdgeToBoxSizing,
+aBoxSizingToMarginEdge,
+aCoord);
+}
+nscoord
+nsCSSOffsetState::ComputeWidthValue(nscoord aContainingBlockWidth,
+uint8_t aBoxSizing,
+const nsStyleCoord& aCoord)
+{
+nscoord inside = 0, outside = ComputedPhysicalBorderPadding().LeftRight() +
+ComputedPhysicalMargin().LeftRight();
+switch (aBoxSizing) {
+case NS_STYLE_BOX_SIZING_BORDER:
+inside = ComputedPhysicalBorderPadding().LeftRight();
+break;
+case NS_STYLE_BOX_SIZING_PADDING:
+inside = ComputedPhysicalPadding().LeftRight();
+break;
+}
+outside -= inside;
+return ComputeWidthValue(aContainingBlockWidth, inside,
+outside, aCoord);
+}
+nscoord
+nsCSSOffsetState::ComputeHeightValue(nscoord aContainingBlockHeight,
+uint8_t aBoxSizing,
+const nsStyleCoord& aCoord)
+{
+nscoord inside = 0;
+switch (aBoxSizing) {
+case NS_STYLE_BOX_SIZING_BORDER:
+inside = ComputedPhysicalBorderPadding().TopBottom();
+break;
+case NS_STYLE_BOX_SIZING_PADDING:
+inside = ComputedPhysicalPadding().TopBottom();
+break;
+}
+return nsLayoutUtils::ComputeHeightValue(aContainingBlockHeight,
+inside, aCoord);
+}
+void
+nsHTMLReflowState::SetComputedWidth(nscoord aComputedWidth)
+{
+NS_ASSERTION(frame, "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.
+NS_PRECONDITION(aComputedWidth >= 0, "Invalid computed width");
+if (ComputedWidth() != aComputedWidth) {
+ComputedWidth() = aComputedWidth;
+nsIAtom* frameType = frame->GetType();
+if (frameType != nsGkAtoms::viewportFrame) { // Or check GetParent()?
+InitResizeFlags(frame->PresContext(), frameType);
+}
+}
+}
+void
+nsHTMLReflowState::SetComputedHeight(nscoord aComputedHeight)
+{
+NS_ASSERTION(frame, "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.
+NS_PRECONDITION(aComputedHeight >= 0, "Invalid computed height");
+if (ComputedHeight() != aComputedHeight) {
+ComputedHeight() = aComputedHeight;
+InitResizeFlags(frame->PresContext(), frame->GetType());
+}
+}
+void
+nsHTMLReflowState::Init(nsPresContext* aPresContext,
+nscoord         aContainingBlockWidth,
+nscoord         aContainingBlockHeight,
+const nsMargin* aBorder,
+const nsMargin* aPadding)
+{
+NS_WARN_IF_FALSE(AvailableWidth() != NS_UNCONSTRAINEDSIZE,
+"have unconstrained width; this should only result from "
+"very large sizes, not attempts at intrinsic width "
+"calculation");
+mStylePosition = frame->StylePosition();
+mStyleDisplay = frame->StyleDisplay();
+mStyleVisibility = frame->StyleVisibility();
+mStyleBorder = frame->StyleBorder();
+mStyleMargin = frame->StyleMargin();
+mStylePadding = frame->StylePadding();
+mStyleText = frame->StyleText();
+nsIAtom* type = frame->GetType();
+InitFrameType(type);
+InitCBReflowState();
+InitConstraints(aPresContext, aContainingBlockWidth, aContainingBlockHeight,
+aBorder, aPadding, type);
+InitResizeFlags(aPresContext, type);
+nsIFrame *parent = frame->GetParent();
+if (parent &&
+(parent->GetStateBits() & NS_FRAME_IN_CONSTRAINED_HEIGHT) &&
+!(parent->GetType() == nsGkAtoms::scrollFrame &&
+parent->StyleDisplay()->mOverflowY != NS_STYLE_OVERFLOW_HIDDEN)) {
+frame->AddStateBits(NS_FRAME_IN_CONSTRAINED_HEIGHT);
+} else if (type == nsGkAtoms::svgForeignObjectFrame) {
+// An SVG foreignObject frame is inherently constrained height.
+frame->AddStateBits(NS_FRAME_IN_CONSTRAINED_HEIGHT);
+} else if ((mStylePosition->mHeight.GetUnit() != eStyleUnit_Auto ||
+mStylePosition->mMaxHeight.GetUnit() != eStyleUnit_None) &&
+// Don't set NS_FRAME_IN_CONSTRAINED_HEIGHT on body or html
+// elements.
+(frame->GetContent() &&
+!(frame->GetContent()->IsHTML(nsGkAtoms::body) ||
+frame->GetContent()->IsHTML(nsGkAtoms::html)))) {
+// If our height 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 = frame;
+while (containingBlk) {
+const nsStylePosition* stylePos = containingBlk->StylePosition();
+if ((stylePos->mHeight.IsCoordPercentCalcUnit() &&
+!stylePos->mHeight.HasPercent()) ||
+(stylePos->mMaxHeight.IsCoordPercentCalcUnit() &&
+!stylePos->mMaxHeight.HasPercent())) {
+frame->AddStateBits(NS_FRAME_IN_CONSTRAINED_HEIGHT);
+break;
+} else if ((stylePos->mHeight.IsCoordPercentCalcUnit() &&
+stylePos->mHeight.HasPercent()) ||
+(stylePos->mMaxHeight.IsCoordPercentCalcUnit() &&
+stylePos->mMaxHeight.HasPercent())) {
+if (!(containingBlk = containingBlk->GetContainingBlock())) {
+// If we've reached the top of the tree, then we don't have
+// a constrained height.
+frame->RemoveStateBits(NS_FRAME_IN_CONSTRAINED_HEIGHT);
+break;
+}
+continue;
+} else {
+frame->RemoveStateBits(NS_FRAME_IN_CONSTRAINED_HEIGHT);
+break;
+}
+}
+} else {
+frame->RemoveStateBits(NS_FRAME_IN_CONSTRAINED_HEIGHT);
+}
+NS_WARN_IF_FALSE((mFrameType == NS_CSS_FRAME_TYPE_INLINE &&
+!frame->IsFrameOfType(nsIFrame::eReplaced)) ||
+type == nsGkAtoms::textFrame ||
+ComputedWidth() != NS_UNCONSTRAINEDSIZE,
+"have unconstrained width; this should only result from "
+"very large sizes, not attempts at intrinsic width "
+"calculation");
+}
+void nsHTMLReflowState::InitCBReflowState()
+{
+if (!parentReflowState) {
+mCBReflowState = nullptr;
+return;
+}
+if (parentReflowState->frame == frame->GetContainingBlock()) {
+// Inner table frames need to use the containing block of the outer
+// table frame.
+if (frame->GetType() == nsGkAtoms::tableFrame) {
+mCBReflowState = parentReflowState->mCBReflowState;
+} else {
+mCBReflowState = parentReflowState;
+}
+} else {
+mCBReflowState = parentReflowState->mCBReflowState;
+}
+}
+/* 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 nsHTMLReflowState* rs, nsIAtom* aFrameType)
+{
+if (nsGkAtoms::blockFrame == aFrameType ||
+#ifdef MOZ_XUL
+nsGkAtoms::XULLabelFrame == aFrameType ||
+#endif
+nsGkAtoms::scrollFrame == 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->frame->IsAbsolutelyPositioned()) {
+return false;
+}
+}
+}
+return true;
+}
+void
+nsHTMLReflowState::InitResizeFlags(nsPresContext* aPresContext, nsIAtom* aFrameType)
+{
+bool isHResize = (frame->GetSize().width !=
+ComputedWidth() + ComputedPhysicalBorderPadding().LeftRight()) ||
+aPresContext->PresShell()->IsReflowOnZoomPending();
+if ((frame->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::UpdateFontInflationDataWidthFor(*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.mDummyParentReflowState;
+if (dirty || (!frame->GetParent() && isHResize)) {
+// 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
+// nsHTMLReflowState::SetComputedWidth is called, if the first time
+// we go through InitResizeFlags we set mHResize to true, and then
+// the second time we'd set it to false even without the
+// NS_FRAME_IS_DIRTY bit already set.
+if (frame->GetType() == nsGkAtoms::svgForeignObjectFrame) {
+// Foreign object frames use dirty bits in a special way.
+frame->AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN);
+nsIFrame *kid = frame->GetFirstPrincipalChild();
+if (kid) {
+kid->AddStateBits(NS_FRAME_IS_DIRTY);
+}
+} else {
+frame->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.
+nsAutoTArray<nsIFrame*, 32> stack;
+stack.AppendElement(frame);
+do {
+nsIFrame *f = stack.ElementAt(stack.Length() - 1);
+stack.RemoveElementAt(stack.Length() - 1);
+nsIFrame::ChildListIterator lists(f);
+for (; !lists.IsDone(); lists.Next()) {
+nsFrameList::Enumerator childFrames(lists.CurrentList());
+for (; !childFrames.AtEnd(); childFrames.Next()) {
+nsIFrame* kid = childFrames.get();
+kid->MarkIntrinsicWidthsDirty();
+stack.AppendElement(kid);
+}
+}
+} while (stack.Length() != 0);
+}
+}
+mFlags.mHResize = !(frame->GetStateBits() & NS_FRAME_IS_DIRTY) &&
+isHResize;
+// XXX Should we really need to null check mCBReflowState?  (We do for
+// at least nsBoxFrame).
+if (IS_TABLE_CELL(aFrameType) &&
+(mFlags.mSpecialHeightReflow ||
+(frame->FirstInFlow()->GetStateBits() &
+NS_TABLE_CELL_HAD_SPECIAL_REFLOW)) &&
+(frame->GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_HEIGHT)) {
+// Need to set the bit on the cell so that
+// mCBReflowState->mFlags.mVResize is set correctly below when
+// reflowing descendant.
+mFlags.mVResize = true;
+} else if (mCBReflowState && !nsLayoutUtils::IsNonWrapperBlock(frame)) {
+// 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.
+mFlags.mVResize = mCBReflowState->mFlags.mVResize;
+} else if (ComputedHeight() == NS_AUTOHEIGHT) {
+if (eCompatibility_NavQuirks == aPresContext->CompatibilityMode() &&
+mCBReflowState) {
+mFlags.mVResize = mCBReflowState->mFlags.mVResize;
+} else {
+mFlags.mVResize = mFlags.mHResize;
+}
+mFlags.mVResize = mFlags.mVResize || NS_SUBTREE_DIRTY(frame);
+} else {
+// not 'auto' height
+mFlags.mVResize = frame->GetSize().height !=
+ComputedHeight() + ComputedPhysicalBorderPadding().TopBottom();
+}
+bool dependsOnCBHeight =
+(mStylePosition->HeightDependsOnContainer() &&
+// FIXME: condition this on not-abspos?
+mStylePosition->mHeight.GetUnit() != eStyleUnit_Auto) ||
+mStylePosition->MinHeightDependsOnContainer() ||
+mStylePosition->MaxHeightDependsOnContainer() ||
+mStylePosition->OffsetHasPercent(NS_SIDE_TOP) ||
+mStylePosition->mOffset.GetBottomUnit() != eStyleUnit_Auto ||
+frame->IsBoxFrame();
+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 height
+frame->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_HEIGHT);
+// but only on containing blocks if this frame is not a suitable block
+dependsOnCBHeight |= !nsLayoutUtils::IsNonWrapperBlock(frame);
+}
+// If we're the descendant of a table cell that performs special height
+// reflows and we could be the child that requires them, always set
+// the vertical resize in case this is the first pass before the
+// special height reflow.  However, don't do this if it actually is
+// the special height reflow, since in that case it will already be
+// set correctly above if we need it set.
+if (!mFlags.mVResize && mCBReflowState &&
+(IS_TABLE_CELL(mCBReflowState->frame->GetType()) ||
+mCBReflowState->mFlags.mHeightDependsOnAncestorCell) &&
+!mCBReflowState->mFlags.mSpecialHeightReflow &&
+dependsOnCBHeight) {
+mFlags.mVResize = true;
+mFlags.mHeightDependsOnAncestorCell = true;
+}
+// Set NS_FRAME_CONTAINS_RELATIVE_HEIGHT if it's needed.
+// It would be nice to check that |mComputedHeight != NS_AUTOHEIGHT|
+// &&ed with the percentage height check.  However, this doesn't get
+// along with table special height reflows, since a special height
+// reflow (a quirk that makes such percentage heights work on children
+// of table cells) can cause not just a single percentage height to
+// become fixed, but an entire descendant chain of percentage heights
+// to become fixed.
+if (dependsOnCBHeight && mCBReflowState) {
+const nsHTMLReflowState *rs = this;
+bool hitCBReflowState = false;
+do {
+rs = rs->parentReflowState;
+if (!rs) {
+break;
+}
+if (rs->frame->GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_HEIGHT)
+break; // no need to go further
+rs->frame->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_HEIGHT);
+// Keep track of whether we've hit the containing block, because
+// we need to go at least that far.
+if (rs == mCBReflowState) {
+hitCBReflowState = true;
+}
+} while (!hitCBReflowState ||
+(eCompatibility_NavQuirks == aPresContext->CompatibilityMode() &&
+!IsQuirkContainingBlockHeight(rs, rs->frame->GetType())));
+// Note: We actually don't need to set the
+// NS_FRAME_CONTAINS_RELATIVE_HEIGHT 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 (frame->GetStateBits() & NS_FRAME_IS_DIRTY) {
+// If we're reflowing everything, then we'll find out if we need
+// to re-set this.
+frame->RemoveStateBits(NS_FRAME_CONTAINS_RELATIVE_HEIGHT);
+}
+}
+/* static */
+nscoord
+nsHTMLReflowState::GetContainingBlockContentWidth(const nsHTMLReflowState* aReflowState)
+{
+const nsHTMLReflowState* rs = aReflowState->mCBReflowState;
+if (!rs)
+return 0;
+return rs->ComputedWidth();
+}
+void
+nsHTMLReflowState::InitFrameType(nsIAtom* aFrameType)
+{
+const nsStyleDisplay *disp = mStyleDisplay;
+nsCSSFrameType frameType;
+// Section 9.7 of the CSS2 spec indicates that absolute position
+// takes precedence over float which takes precedence over display.
+// XXXldb nsRuleNode::ComputeDisplayData should take care of this, right?
+// Make sure the frame was actually moved out of the flow, and don't
+// just assume what the style says, because we might not have had a
+// useful float/absolute containing block
+DISPLAY_INIT_TYPE(frame, this);
+if (aFrameType == nsGkAtoms::tableFrame) {
+mFrameType = NS_CSS_FRAME_TYPE_BLOCK;
+return;
+}
+NS_ASSERTION(frame->StyleDisplay()->IsAbsolutelyPositionedStyle() ==
+disp->IsAbsolutelyPositionedStyle(),
+"Unexpected position style");
+NS_ASSERTION(frame->StyleDisplay()->IsFloatingStyle() ==
+disp->IsFloatingStyle(), "Unexpected float style");
+if (frame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) {
+if (disp->IsAbsolutelyPositioned(frame)) {
+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 (frame->GetPrevInFlow())
+frameType = NS_CSS_FRAME_TYPE_BLOCK;
+}
+else if (disp->IsFloating(frame)) {
+frameType = NS_CSS_FRAME_TYPE_FLOATING;
+} else {
+NS_ASSERTION(disp->mDisplay == NS_STYLE_DISPLAY_POPUP,
+"unknown out of flow frame type");
+frameType = NS_CSS_FRAME_TYPE_UNKNOWN;
+}
+}
+else {
+switch (GetDisplay()) {
+case NS_STYLE_DISPLAY_BLOCK:
+case NS_STYLE_DISPLAY_LIST_ITEM:
+case NS_STYLE_DISPLAY_TABLE:
+case NS_STYLE_DISPLAY_TABLE_CAPTION:
+case NS_STYLE_DISPLAY_FLEX:
+frameType = NS_CSS_FRAME_TYPE_BLOCK;
+break;
+case NS_STYLE_DISPLAY_INLINE:
+case NS_STYLE_DISPLAY_INLINE_BLOCK:
+case NS_STYLE_DISPLAY_INLINE_TABLE:
+case NS_STYLE_DISPLAY_INLINE_BOX:
+case NS_STYLE_DISPLAY_INLINE_XUL_GRID:
+case NS_STYLE_DISPLAY_INLINE_STACK:
+case NS_STYLE_DISPLAY_INLINE_FLEX:
+frameType = NS_CSS_FRAME_TYPE_INLINE;
+break;
+case NS_STYLE_DISPLAY_TABLE_CELL:
+case NS_STYLE_DISPLAY_TABLE_ROW_GROUP:
+case NS_STYLE_DISPLAY_TABLE_COLUMN:
+case NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP:
+case NS_STYLE_DISPLAY_TABLE_HEADER_GROUP:
+case NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP:
+case NS_STYLE_DISPLAY_TABLE_ROW:
+frameType = NS_CSS_FRAME_TYPE_INTERNAL_TABLE;
+break;
+case NS_STYLE_DISPLAY_NONE:
+default:
+frameType = NS_CSS_FRAME_TYPE_UNKNOWN;
+break;
+}
+}
+// See if the frame is replaced
+if (frame->IsFrameOfType(nsIFrame::eReplacedContainsBlock)) {
+frameType = NS_FRAME_REPLACED_CONTAINS_BLOCK(frameType);
+} else if (frame->IsFrameOfType(nsIFrame::eReplaced)) {
+frameType = NS_FRAME_REPLACED(frameType);
+}
+mFrameType = frameType;
+}
+/* static */ void
+nsHTMLReflowState::ComputeRelativeOffsets(uint8_t aCBDirection,
+nsIFrame* aFrame,
+nscoord aContainingBlockWidth,
+nscoord aContainingBlockHeight,
+nsMargin& aComputedOffsets)
+{
+const nsStylePosition* position = aFrame->StylePosition();
+// Compute the 'left' and 'right' values. 'Left' moves the boxes to the right,
+// and 'right' moves the boxes to the left. The computed values are always:
+// left=-right
+bool    leftIsAuto = eStyleUnit_Auto == position->mOffset.GetLeftUnit();
+bool    rightIsAuto = eStyleUnit_Auto == position->mOffset.GetRightUnit();
+// If neither 'left' not 'right' are auto, then we're over-constrained and
+// we ignore one of them
+if (!leftIsAuto && !rightIsAuto) {
+if (aCBDirection == NS_STYLE_DIRECTION_RTL) {
+leftIsAuto = true;
+} else {
+rightIsAuto = true;
+}
+}
+if (leftIsAuto) {
+if (rightIsAuto) {
+// If both are 'auto' (their initial values), the computed values are 0
+aComputedOffsets.left = aComputedOffsets.right = 0;
+} else {
+// 'Right' isn't 'auto' so compute its value
+aComputedOffsets.right = nsLayoutUtils::
+ComputeCBDependentValue(aContainingBlockWidth,
+position->mOffset.GetRight());
+// Computed value for 'left' is minus the value of 'right'
+aComputedOffsets.left = -aComputedOffsets.right;
+}
+} else {
+NS_ASSERTION(rightIsAuto, "unexpected specified constraint");
+// 'Left' isn't 'auto' so compute its value
+aComputedOffsets.left = nsLayoutUtils::
+ComputeCBDependentValue(aContainingBlockWidth,
+position->mOffset.GetLeft());
+// Computed value for 'right' is minus the value of 'left'
+aComputedOffsets.right = -aComputedOffsets.left;
+}
+// Compute the 'top' and 'bottom' values. The 'top' and 'bottom' properties
+// move relatively positioned elements up and down. They also must be each
+// other's negative
+bool    topIsAuto = eStyleUnit_Auto == position->mOffset.GetTopUnit();
+bool    bottomIsAuto = eStyleUnit_Auto == position->mOffset.GetBottomUnit();
+// Check for percentage based values and a containing block height that
+// depends on the content height. Treat them like 'auto'
+if (NS_AUTOHEIGHT == aContainingBlockHeight) {
+if (position->OffsetHasPercent(NS_SIDE_TOP)) {
+topIsAuto = true;
+}
+if (position->OffsetHasPercent(NS_SIDE_BOTTOM)) {
+bottomIsAuto = true;
+}
+}
+// If neither is 'auto', 'bottom' is ignored
+if (!topIsAuto && !bottomIsAuto) {
+bottomIsAuto = true;
+}
+if (topIsAuto) {
+if (bottomIsAuto) {
+// If both are 'auto' (their initial values), the computed values are 0
+aComputedOffsets.top = aComputedOffsets.bottom = 0;
+} else {
+// 'Bottom' isn't 'auto' so compute its value
+aComputedOffsets.bottom = nsLayoutUtils::
+ComputeHeightDependentValue(aContainingBlockHeight,
+position->mOffset.GetBottom());
+// Computed value for 'top' is minus the value of 'bottom'
+aComputedOffsets.top = -aComputedOffsets.bottom;
+}
+} else {
+NS_ASSERTION(bottomIsAuto, "unexpected specified constraint");
+// 'Top' isn't 'auto' so compute its value
+aComputedOffsets.top = nsLayoutUtils::
+ComputeHeightDependentValue(aContainingBlockHeight,
+position->mOffset.GetTop());
+// Computed value for 'bottom' is minus the value of 'top'
+aComputedOffsets.bottom = -aComputedOffsets.top;
+}
+// Store the offset
+FrameProperties props = aFrame->Properties();
+nsMargin* offsets = static_cast<nsMargin*>
+(props.Get(nsIFrame::ComputedOffsetProperty()));
+if (offsets) {
+*offsets = aComputedOffsets;
+} else {
+props.Set(nsIFrame::ComputedOffsetProperty(),
+new nsMargin(aComputedOffsets));
+}
+}
+/* static */ void
+nsHTMLReflowState::ApplyRelativePositioning(nsIFrame* aFrame,
+const nsMargin& aComputedOffsets,
+nsPoint* aPosition)
+{
+if (!aFrame->IsRelativelyPositioned()) {
+NS_ASSERTION(!aFrame->Properties().Get(nsIFrame::NormalPositionProperty()),
+"We assume that changing the 'position' property causes "
+"frame reconstruction.  If that ever changes, this code "
+"should call "
+"props.Delete(nsIFrame::NormalPositionProperty())");
+return;
+}
+// Store the normal position
+FrameProperties props = aFrame->Properties();
+nsPoint* normalPosition = static_cast<nsPoint*>
+(props.Get(nsIFrame::NormalPositionProperty()));
+if (normalPosition) {
+*normalPosition = *aPosition;
+} else {
+props.Set(nsIFrame::NormalPositionProperty(), new nsPoint(*aPosition));
+}
+const nsStyleDisplay* display = aFrame->StyleDisplay();
+if (NS_STYLE_POSITION_RELATIVE == display->mPosition) {
+*aPosition += nsPoint(aComputedOffsets.left, aComputedOffsets.top);
+} else if (NS_STYLE_POSITION_STICKY == display->mPosition &&
+!aFrame->GetNextContinuation() &&
+!aFrame->GetPrevContinuation() &&
+!(aFrame->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT)) {
+// Sticky positioning for elements with multiple frames needs to be
+// computed all at once. We can't safely do that here because we might be
+// partway through (re)positioning the frames, so leave it until the scroll
+// container reflows and calls StickyScrollContainer::UpdatePositions.
+// For single-frame sticky positioned elements, though, go ahead and apply
+// it now to avoid unnecessary overflow updates later.
+StickyScrollContainer* ssc =
+StickyScrollContainer::GetStickyScrollContainerForFrame(aFrame);
+if (ssc) {
+*aPosition = ssc->ComputePosition(aFrame);
+}
+}
+}
+nsIFrame*
+nsHTMLReflowState::GetHypotheticalBoxContainer(nsIFrame* aFrame,
+nscoord& aCBLeftEdge,
+nscoord& aCBWidth)
+{
+aFrame = aFrame->GetContainingBlock();
+NS_ASSERTION(aFrame != frame, "How did that happen?");
+/* Now aFrame is the containing block we want */
+/* Check whether the containing block is currently being reflowed.
+If so, use the info from the reflow state. */
+const nsHTMLReflowState* state;
+if (aFrame->GetStateBits() & NS_FRAME_IN_REFLOW) {
+for (state = parentReflowState; state && state->frame != aFrame;
+state = state->parentReflowState) {
+/* do nothing */
+}
+} else {
+state = nullptr;
+}
+if (state) {
+aCBLeftEdge = state->ComputedPhysicalBorderPadding().left;
+aCBWidth = state->ComputedWidth();
+} else {
+/* Didn't find a reflow state for aFrame.  Just compute the information we
+want, on the assumption that aFrame already knows its size.  This really
+ought to be true by now. */
+NS_ASSERTION(!(aFrame->GetStateBits() & NS_FRAME_IN_REFLOW),
+"aFrame shouldn't be in reflow; we'll lie if it is");
+nsMargin borderPadding = aFrame->GetUsedBorderAndPadding();
+aCBLeftEdge = borderPadding.left;
+aCBWidth = aFrame->GetSize().width - borderPadding.LeftRight();
+}
+return aFrame;
+}
+// When determining the hypothetical box that would have been if the element
+// had been in the flow we may not be able to exactly determine both the left
+// and right edges. For example, if the element is a non-replaced inline-level
+// element we would have to reflow it in order to determine it desired width.
+// In that case depending on the progression direction either the left or
+// right edge would be marked as not being exact
+struct nsHypotheticalBox {
+// offsets from left edge of containing block (which is a padding edge)
+nscoord       mLeft, mRight;
+// offset from top edge of containing block (which is a padding edge)
+nscoord       mTop;
+#ifdef DEBUG
+bool          mLeftIsExact, mRightIsExact;
+#endif
+nsHypotheticalBox() {
+#ifdef DEBUG
+mLeftIsExact = mRightIsExact = false;
+#endif
+}
+};
+static bool
+GetIntrinsicSizeFor(nsIFrame* aFrame, nsSize& aIntrinsicSize, nsIAtom* aFrameType)
+{
+// See if it is an image frame
+bool success = false;
+// Currently the only type of replaced frame that we can get the intrinsic
+// size for is an image frame
+// XXX We should add back the GetReflowMetrics() function and one of the
+// things should be the intrinsic size...
+if (aFrameType == nsGkAtoms::imageFrame) {
+nsImageFrame* imageFrame = (nsImageFrame*)aFrame;
+if (NS_SUCCEEDED(imageFrame->GetIntrinsicImageSize(aIntrinsicSize))) {
+success = (aIntrinsicSize != nsSize(0, 0));
+}
+}
+return success;
+}
+/**
+* aInsideBoxSizing returns the part of the horizontal padding, border,
+* and margin that goes inside the edge given by box-sizing;
+* aOutsideBoxSizing returns the rest.
+*/
+void
+nsHTMLReflowState::CalculateHorizBorderPaddingMargin(
+nscoord aContainingBlockWidth,
+nscoord* aInsideBoxSizing,
+nscoord* aOutsideBoxSizing)
+{
+const nsMargin& border = mStyleBorder->GetComputedBorder();
+nsMargin padding, margin;
+// See if the style system can provide us the padding directly
+if (!mStylePadding->GetPadding(padding)) {
+// We have to compute the left and right values
+padding.left = nsLayoutUtils::
+ComputeCBDependentValue(aContainingBlockWidth,
+mStylePadding->mPadding.GetLeft());
+padding.right = nsLayoutUtils::
+ComputeCBDependentValue(aContainingBlockWidth,
+mStylePadding->mPadding.GetRight());
+}
+// See if the style system can provide us the margin directly
+if (!mStyleMargin->GetMargin(margin)) {
+// We have to compute the left and right values
+if (eStyleUnit_Auto == mStyleMargin->mMargin.GetLeftUnit()) {
+// XXX FIXME (or does CalculateBlockSideMargins do this?)
+margin.left = 0;  // just ignore
+} else {
+margin.left = nsLayoutUtils::
+ComputeCBDependentValue(aContainingBlockWidth,
+mStyleMargin->mMargin.GetLeft());
+}
+if (eStyleUnit_Auto == mStyleMargin->mMargin.GetRightUnit()) {
+// XXX FIXME (or does CalculateBlockSideMargins do this?)
+margin.right = 0;  // just ignore
+} else {
+margin.right = nsLayoutUtils::
+ComputeCBDependentValue(aContainingBlockWidth,
+mStyleMargin->mMargin.GetRight());
+}
+}
+nscoord outside =
+padding.LeftRight() + border.LeftRight() + margin.LeftRight();
+nscoord inside = 0;
+switch (mStylePosition->mBoxSizing) {
+case NS_STYLE_BOX_SIZING_BORDER:
+inside += border.LeftRight();
+// fall through
+case NS_STYLE_BOX_SIZING_PADDING:
+inside += padding.LeftRight();
+}
+outside -= inside;
+*aInsideBoxSizing = inside;
+*aOutsideBoxSizing = outside;
+return;
+}
+/**
+* Returns true iff a pre-order traversal of the normal child
+* frames rooted at aFrame finds no non-empty frame before aDescendant.
+*/
+static bool AreAllEarlierInFlowFramesEmpty(nsIFrame* aFrame,
+nsIFrame* aDescendant, bool* aFound) {
+if (aFrame == aDescendant) {
+*aFound = true;
+return true;
+}
+if (!aFrame->IsSelfEmpty()) {
+*aFound = false;
+return false;
+}
+for (nsIFrame* f = aFrame->GetFirstPrincipalChild(); f; f = f->GetNextSibling()) {
+bool allEmpty = AreAllEarlierInFlowFramesEmpty(f, aDescendant, aFound);
+if (*aFound || !allEmpty) {
+return allEmpty;
+}
+}
+*aFound = false;
+return true;
+}
+// Calculate the hypothetical box that the element would have if it were in
+// the flow. The values returned are relative to the padding edge of the
+// absolute containing block
+// aContainingBlock is the placeholder's containing block (XXX rename it?)
+// cbrs->frame is the actual containing block
+void
+nsHTMLReflowState::CalculateHypotheticalBox(nsPresContext*    aPresContext,
+nsIFrame*         aPlaceholderFrame,
+nsIFrame*         aContainingBlock,
+nscoord           aBlockLeftContentEdge,
+nscoord           aBlockContentWidth,
+const nsHTMLReflowState* cbrs,
+nsHypotheticalBox& aHypotheticalBox,
+nsIAtom*          aFrameType)
+{
+NS_ASSERTION(mStyleDisplay->mOriginalDisplay != NS_STYLE_DISPLAY_NONE,
+"mOriginalDisplay has not been properly initialized");
+// If it's a replaced element and it has a 'auto' value for 'width', see if we
+// can get the intrinsic size. This will allow us to exactly determine both the
+// left and right edges
+bool isAutoWidth = mStylePosition->mWidth.GetUnit() == eStyleUnit_Auto;
+nsSize      intrinsicSize;
+bool        knowIntrinsicSize = false;
+if (NS_FRAME_IS_REPLACED(mFrameType) && isAutoWidth) {
+// See if we can get the intrinsic size of the element
+knowIntrinsicSize = GetIntrinsicSizeFor(frame, intrinsicSize, aFrameType);
+}
+// See if we can calculate what the box width would have been if the
+// element had been in the flow
+nscoord boxWidth;
+bool    knowBoxWidth = false;
+if ((NS_STYLE_DISPLAY_INLINE == mStyleDisplay->mOriginalDisplay) &&
+!NS_FRAME_IS_REPLACED(mFrameType)) {
+// For non-replaced inline-level elements the 'width' property doesn't apply,
+// so we don't know what the width would have been without reflowing it
+} else {
+// It's either a replaced inline-level element or a block-level element
+// Determine the total amount of horizontal border/padding/margin that
+// the element would have had if it had been in the flow. Note that we
+// ignore any 'auto' and 'inherit' values
+nscoord insideBoxSizing, outsideBoxSizing;
+CalculateHorizBorderPaddingMargin(aBlockContentWidth,
+&insideBoxSizing, &outsideBoxSizing);
+if (NS_FRAME_IS_REPLACED(mFrameType) && isAutoWidth) {
+// It's a replaced element with an 'auto' width so the box width is
+// its intrinsic size plus any border/padding/margin
+if (knowIntrinsicSize) {
+boxWidth = intrinsicSize.width + outsideBoxSizing + insideBoxSizing;
+knowBoxWidth = true;
+}
+} else if (isAutoWidth) {
+// The box width is the containing block width
+boxWidth = aBlockContentWidth;
+knowBoxWidth = true;
+} else {
+// We need to compute it. It's important we do this, because if it's
+// percentage based this computed value may be different from the computed
+// value calculated using the absolute containing block width
+boxWidth = ComputeWidthValue(aBlockContentWidth,
+insideBoxSizing, outsideBoxSizing,
+mStylePosition->mWidth) +
+insideBoxSizing + outsideBoxSizing;
+knowBoxWidth = true;
+}
+}
+// Get the 'direction' of the block
+const nsStyleVisibility* blockVis = aContainingBlock->StyleVisibility();
+// Get the placeholder x-offset and y-offset in the coordinate
+// space of its containing block
+// XXXbz the placeholder is not fully reflowed yet if our containing block is
+// relatively positioned...
+nsPoint placeholderOffset = aPlaceholderFrame->GetOffsetTo(aContainingBlock);
+// First, determine the hypothetical box's mTop.  We want to check the
+// content insertion frame of aContainingBlock for block-ness, but make
+// sure to compute all coordinates in the coordinate system of
+// aContainingBlock.
+nsBlockFrame* blockFrame =
+nsLayoutUtils::GetAsBlock(aContainingBlock->GetContentInsertionFrame());
+if (blockFrame) {
+nscoord blockYOffset = blockFrame->GetOffsetTo(aContainingBlock).y;
+bool isValid;
+nsBlockInFlowLineIterator iter(blockFrame, aPlaceholderFrame, &isValid);
+if (!isValid) {
+// Give up.  We're probably dealing with somebody using
+// position:absolute inside native-anonymous content anyway.
+aHypotheticalBox.mTop = placeholderOffset.y;
+} else {
+NS_ASSERTION(iter.GetContainer() == blockFrame,
+"Found placeholder in wrong block!");
+nsBlockFrame::line_iterator lineBox = iter.GetLine();
+// How we determine the hypothetical box depends on whether the element
+// would have been inline-level or block-level
+if (mStyleDisplay->IsOriginalDisplayInlineOutsideStyle()) {
+// Use the top of the inline box which the placeholder lives in
+// as the hypothetical box's top.
+aHypotheticalBox.mTop = lineBox->GetPhysicalBounds().y + blockYOffset;
+} else {
+// The element would have been block-level which means it would
+// be below the line containing the placeholder frame, unless
+// all the frames before it are empty.  In that case, it would
+// have been just before this line.
+// XXXbz the line box is not fully reflowed yet if our
+// containing block is relatively positioned...
+if (lineBox != iter.End()) {
+nsIFrame * firstFrame = lineBox->mFirstChild;
+bool found = false;
+bool allEmpty = true;
+while (firstFrame) { // See bug 223064
+allEmpty = AreAllEarlierInFlowFramesEmpty(firstFrame,
+aPlaceholderFrame, &found);
+if (found || !allEmpty)
+break;
+firstFrame = firstFrame->GetNextSibling();
+}
+NS_ASSERTION(firstFrame, "Couldn't find placeholder!");
+if (allEmpty) {
+// The top of the hypothetical box is the top of the line
+// containing the placeholder, since there is nothing in the
+// line before our placeholder except empty frames.
+aHypotheticalBox.mTop = lineBox->GetPhysicalBounds().y + blockYOffset;
+} else {
+// The top of the hypothetical box is just below the line
+// containing the placeholder.
+aHypotheticalBox.mTop = lineBox->GetPhysicalBounds().YMost() + blockYOffset;
+}
+} else {
+// Just use the placeholder's y-offset wrt the containing block
+aHypotheticalBox.mTop = placeholderOffset.y;
+}
+}
+}
+} else {
+// The containing block is not a block, so it's probably something
+// like a XUL box, etc.
+// Just use the placeholder's y-offset
+aHypotheticalBox.mTop = placeholderOffset.y;
+}
+// Second, determine the hypothetical box's mLeft & mRight
+// To determine the left and right offsets we need to look at the block's 'direction'
+if (NS_STYLE_DIRECTION_LTR == blockVis->mDirection) {
+// How we determine the hypothetical box depends on whether the element
+// would have been inline-level or block-level
+if (mStyleDisplay->IsOriginalDisplayInlineOutsideStyle()) {
+// The placeholder represents the left edge of the hypothetical box
+aHypotheticalBox.mLeft = placeholderOffset.x;
+} else {
+aHypotheticalBox.mLeft = aBlockLeftContentEdge;
+}
+#ifdef DEBUG
+aHypotheticalBox.mLeftIsExact = true;
+#endif
+if (knowBoxWidth) {
+aHypotheticalBox.mRight = aHypotheticalBox.mLeft + boxWidth;
+#ifdef DEBUG
+aHypotheticalBox.mRightIsExact = true;
+#endif
+} else {
+// We can't compute the right edge because we don't know the desired
+// width. So instead use the right content edge of the block parent,
+// but remember it's not exact
+aHypotheticalBox.mRight = aBlockLeftContentEdge + aBlockContentWidth;
+#ifdef DEBUG
+aHypotheticalBox.mRightIsExact = false;
+#endif
+}
+} else {
+// The placeholder represents the right edge of the hypothetical box
+if (mStyleDisplay->IsOriginalDisplayInlineOutsideStyle()) {
+aHypotheticalBox.mRight = placeholderOffset.x;
+} else {
+aHypotheticalBox.mRight = aBlockLeftContentEdge + aBlockContentWidth;
+}
+#ifdef DEBUG
+aHypotheticalBox.mRightIsExact = true;
+#endif
+if (knowBoxWidth) {
+aHypotheticalBox.mLeft = aHypotheticalBox.mRight - boxWidth;
+#ifdef DEBUG
+aHypotheticalBox.mLeftIsExact = true;
+#endif
+} else {
+// We can't compute the left edge because we don't know the desired
+// width. So instead use the left content edge of the block parent,
+// but remember it's not exact
+aHypotheticalBox.mLeft = aBlockLeftContentEdge;
+#ifdef DEBUG
+aHypotheticalBox.mLeftIsExact = false;
+#endif
+}
+}
+// The current coordinate space is that of the nearest block to the placeholder.
+// Convert to the coordinate space of the absolute containing block
+// One weird thing here is that for fixed-positioned elements we want to do
+// the conversion incorrectly; specifically we want to ignore any scrolling
+// that may have happened;
+nsPoint cbOffset;
+if (mStyleDisplay->mPosition == NS_STYLE_POSITION_FIXED &&
+// Exclude cases inside -moz-transform where fixed is like absolute.
+nsLayoutUtils::IsReallyFixedPos(frame)) {
+// In this case, cbrs->frame will always be an ancestor of
+// aContainingBlock, so can just walk our way up the frame tree.
+// Make sure to not add positions of frames whose parent is a
+// scrollFrame, since we're doing fixed positioning, which assumes
+// everything is scrolled to (0,0).
+cbOffset.MoveTo(0, 0);
+do {
+NS_ASSERTION(aContainingBlock,
+"Should hit cbrs->frame before we run off the frame tree!");
+cbOffset += aContainingBlock->GetPositionIgnoringScrolling();
+aContainingBlock = aContainingBlock->GetParent();
+} while (aContainingBlock != cbrs->frame);
+} else {
+// XXXldb We need to either ignore scrolling for the absolute
+// positioning case too (and take the incompatibility) or figure out
+// how to make these positioned elements actually *move* when we
+// scroll, and thus avoid the resulting incremental reflow bugs.
+cbOffset = aContainingBlock->GetOffsetTo(cbrs->frame);
+}
+aHypotheticalBox.mLeft += cbOffset.x;
+aHypotheticalBox.mTop += cbOffset.y;
+aHypotheticalBox.mRight += cbOffset.x;
+// The specified offsets are relative to the absolute containing block's
+// padding edge and our current values are relative to the border edge, so
+// translate.
+nsMargin border = cbrs->ComputedPhysicalBorderPadding() - cbrs->ComputedPhysicalPadding();
+aHypotheticalBox.mLeft -= border.left;
+aHypotheticalBox.mRight -= border.left;
+aHypotheticalBox.mTop -= border.top;
+}
+void
+nsHTMLReflowState::InitAbsoluteConstraints(nsPresContext* aPresContext,
+const nsHTMLReflowState* cbrs,
+nscoord containingBlockWidth,
+nscoord containingBlockHeight,
+nsIAtom* aFrameType)
+{
+NS_PRECONDITION(containingBlockHeight != NS_AUTOHEIGHT,
+"containing block height must be constrained");
+NS_ASSERTION(aFrameType != nsGkAtoms::tableFrame,
+"InitAbsoluteConstraints should not be called on table frames");
+NS_ASSERTION(frame->GetStateBits() & NS_FRAME_OUT_OF_FLOW,
+"Why are we here?");
+// Get the placeholder frame
+nsIFrame*     placeholderFrame;
+placeholderFrame = aPresContext->PresShell()->GetPlaceholderFrameFor(frame);
+NS_ASSERTION(nullptr != placeholderFrame, "no placeholder frame");
+// If both 'left' and 'right' are 'auto' or both 'top' and 'bottom' are
+// 'auto', then compute the hypothetical box of where the element would
+// have been if it had been in the flow
+nsHypotheticalBox hypotheticalBox;
+if (((eStyleUnit_Auto == mStylePosition->mOffset.GetLeftUnit()) &&
+(eStyleUnit_Auto == mStylePosition->mOffset.GetRightUnit())) ||
+((eStyleUnit_Auto == mStylePosition->mOffset.GetTopUnit()) &&
+(eStyleUnit_Auto == mStylePosition->mOffset.GetBottomUnit()))) {
+// Find the nearest containing block frame to the placeholder frame,
+// and return its left edge and width.
+nscoord cbLeftEdge, cbWidth;
+nsIFrame* cbFrame = GetHypotheticalBoxContainer(placeholderFrame,
+cbLeftEdge,
+cbWidth);
+CalculateHypotheticalBox(aPresContext, placeholderFrame, cbFrame,
+cbLeftEdge, cbWidth, cbrs, hypotheticalBox, aFrameType);
+}
+// Initialize the 'left' and 'right' computed offsets
+// XXX Handle new 'static-position' value...
+bool          leftIsAuto = false, rightIsAuto = false;
+if (eStyleUnit_Auto == mStylePosition->mOffset.GetLeftUnit()) {
+ComputedPhysicalOffsets().left = 0;
+leftIsAuto = true;
+} else {
+ComputedPhysicalOffsets().left = nsLayoutUtils::
+ComputeCBDependentValue(containingBlockWidth,
+mStylePosition->mOffset.GetLeft());
+}
+if (eStyleUnit_Auto == mStylePosition->mOffset.GetRightUnit()) {
+ComputedPhysicalOffsets().right = 0;
+rightIsAuto = true;
+} else {
+ComputedPhysicalOffsets().right = nsLayoutUtils::
+ComputeCBDependentValue(containingBlockWidth,
+mStylePosition->mOffset.GetRight());
+}
+// Use the horizontal component of the hypothetical box in the cases
+// where it's needed.
+if (leftIsAuto && rightIsAuto) {
+// Use the direction of the original ("static-position") containing block
+// to dictate whether 'left' or 'right' is treated like 'static-position'.
+if (NS_STYLE_DIRECTION_LTR == placeholderFrame->GetContainingBlock()
+->StyleVisibility()->mDirection) {
+NS_ASSERTION(hypotheticalBox.mLeftIsExact, "should always have "
+"exact value on containing block's start side");
+ComputedPhysicalOffsets().left = hypotheticalBox.mLeft;
+leftIsAuto = false;
+} else {
+NS_ASSERTION(hypotheticalBox.mRightIsExact, "should always have "
+"exact value on containing block's start side");
+ComputedPhysicalOffsets().right = containingBlockWidth - hypotheticalBox.mRight;
+rightIsAuto = false;
+}
+}
+// Initialize the 'top' and 'bottom' computed offsets
+bool        topIsAuto = false, bottomIsAuto = false;
+if (eStyleUnit_Auto == mStylePosition->mOffset.GetTopUnit()) {
+ComputedPhysicalOffsets().top = 0;
+topIsAuto = true;
+} else {
+ComputedPhysicalOffsets().top = nsLayoutUtils::
+ComputeHeightDependentValue(containingBlockHeight,
+mStylePosition->mOffset.GetTop());
+}
+if (eStyleUnit_Auto == mStylePosition->mOffset.GetBottomUnit()) {
+ComputedPhysicalOffsets().bottom = 0;
+bottomIsAuto = true;
+} else {
+ComputedPhysicalOffsets().bottom = nsLayoutUtils::
+ComputeHeightDependentValue(containingBlockHeight,
+mStylePosition->mOffset.GetBottom());
+}
+if (topIsAuto && bottomIsAuto) {
+// Treat 'top' like 'static-position'
+ComputedPhysicalOffsets().top = hypotheticalBox.mTop;
+topIsAuto = false;
+}
+bool widthIsAuto = eStyleUnit_Auto == mStylePosition->mWidth.GetUnit();
+bool heightIsAuto = eStyleUnit_Auto == mStylePosition->mHeight.GetUnit();
+uint32_t computeSizeFlags = 0;
+if (leftIsAuto || rightIsAuto) {
+computeSizeFlags |= nsIFrame::eShrinkWrap;
+}
+{
+AutoMaybeDisableFontInflation an(frame);
+nsSize size =
+frame->ComputeSize(rendContext,
+nsSize(containingBlockWidth,
+containingBlockHeight),
+containingBlockWidth, // XXX or mAvailableWidth?
+nsSize(ComputedPhysicalMargin().LeftRight() +
+ComputedPhysicalOffsets().LeftRight(),
+ComputedPhysicalMargin().TopBottom() +
+ComputedPhysicalOffsets().TopBottom()),
+nsSize(ComputedPhysicalBorderPadding().LeftRight() -
+ComputedPhysicalPadding().LeftRight(),
+ComputedPhysicalBorderPadding().TopBottom() -
+ComputedPhysicalPadding().TopBottom()),
+nsSize(ComputedPhysicalPadding().LeftRight(),
+ComputedPhysicalPadding().TopBottom()),
+computeSizeFlags);
+ComputedWidth() = size.width;
+ComputedHeight() = size.height;
+}
+NS_ASSERTION(ComputedWidth() >= 0, "Bogus width");
+NS_ASSERTION(ComputedHeight() == NS_UNCONSTRAINEDSIZE ||
+ComputedHeight() >= 0, "Bogus height");
+// XXX Now that we have ComputeSize, can we condense many of the
+// branches off of widthIsAuto?
+if (leftIsAuto) {
+// We know 'right' is not 'auto' anymore thanks to the hypothetical
+// box code above.
+// Solve for 'left'.
+if (widthIsAuto) {
+// XXXldb This, and the corresponding code in
+// nsAbsoluteContainingBlock.cpp, could probably go away now that
+// we always compute widths.
+ComputedPhysicalOffsets().left = NS_AUTOOFFSET;
+} else {
+ComputedPhysicalOffsets().left = containingBlockWidth - ComputedPhysicalMargin().left -
+ComputedPhysicalBorderPadding().left - ComputedWidth() - ComputedPhysicalBorderPadding().right -
+ComputedPhysicalMargin().right - ComputedPhysicalOffsets().right;
+}
+} else if (rightIsAuto) {
+// We know 'left' is not 'auto' anymore thanks to the hypothetical
+// box code above.
+// Solve for 'right'.
+if (widthIsAuto) {
+// XXXldb This, and the corresponding code in
+// nsAbsoluteContainingBlock.cpp, could probably go away now that
+// we always compute widths.
+ComputedPhysicalOffsets().right = NS_AUTOOFFSET;
+} else {
+ComputedPhysicalOffsets().right = containingBlockWidth - ComputedPhysicalOffsets().left -
+ComputedPhysicalMargin().left - ComputedPhysicalBorderPadding().left - ComputedWidth() -
+ComputedPhysicalBorderPadding().right - ComputedPhysicalMargin().right;
+}
+} else {
+// Neither 'left' nor 'right' is 'auto'.  However, the width might
+// still not fill all the available space (even though we didn't
+// shrink-wrap) in case:
+//  * width was specified
+//  * we're dealing with a replaced element
+//  * width was constrained by min-width or max-width.
+nscoord availMarginSpace = containingBlockWidth -
+ComputedPhysicalOffsets().LeftRight() -
+ComputedPhysicalMargin().LeftRight() -
+ComputedPhysicalBorderPadding().LeftRight() -
+ComputedWidth();
+bool marginLeftIsAuto =
+eStyleUnit_Auto == mStyleMargin->mMargin.GetLeftUnit();
+bool marginRightIsAuto =
+eStyleUnit_Auto == mStyleMargin->mMargin.GetRightUnit();
+if (marginLeftIsAuto) {
+if (marginRightIsAuto) {
+if (availMarginSpace < 0) {
+// Note that this case is different from the neither-'auto'
+// case below, where the spec says to ignore 'left'/'right'.
+if (cbrs &&
+NS_STYLE_DIRECTION_RTL == cbrs->mStyleVisibility->mDirection) {
+// Ignore the specified value for 'margin-left'.
+ComputedPhysicalMargin().left = availMarginSpace;
+} else {
+// Ignore the specified value for 'margin-right'.
+ComputedPhysicalMargin().right = availMarginSpace;
+}
+} else {
+// Both 'margin-left' and 'margin-right' are 'auto', so they get
+// equal values
+ComputedPhysicalMargin().left = availMarginSpace / 2;
+ComputedPhysicalMargin().right = availMarginSpace - ComputedPhysicalMargin().left;
+}
+} else {
+// Just 'margin-left' is 'auto'
+ComputedPhysicalMargin().left = availMarginSpace;
+}
+} else {
+if (marginRightIsAuto) {
+// Just 'margin-right' is 'auto'
+ComputedPhysicalMargin().right = availMarginSpace;
+} else {
+// We're over-constrained so use the direction of the containing
+// block to dictate which value to ignore.  (And note that the
+// spec says to ignore 'left' or 'right' rather than
+// 'margin-left' or 'margin-right'.)
+// Note that this case is different from the both-'auto' case
+// above, where the spec says to ignore
+// 'margin-left'/'margin-right'.
+if (cbrs &&
+NS_STYLE_DIRECTION_RTL == cbrs->mStyleVisibility->mDirection) {
+// Ignore the specified value for 'left'.
+ComputedPhysicalOffsets().left += availMarginSpace;
+} else {
+// Ignore the specified value for 'right'.
+ComputedPhysicalOffsets().right += availMarginSpace;
+}
+}
+}
+}
+if (topIsAuto) {
+// solve for 'top'
+if (heightIsAuto) {
+ComputedPhysicalOffsets().top = NS_AUTOOFFSET;
+} else {
+ComputedPhysicalOffsets().top = containingBlockHeight - ComputedPhysicalMargin().top -
+ComputedPhysicalBorderPadding().top - ComputedHeight() - ComputedPhysicalBorderPadding().bottom -
+ComputedPhysicalMargin().bottom - ComputedPhysicalOffsets().bottom;
+}
+} else if (bottomIsAuto) {
+// solve for 'bottom'
+if (heightIsAuto) {
+ComputedPhysicalOffsets().bottom = NS_AUTOOFFSET;
+} else {
+ComputedPhysicalOffsets().bottom = containingBlockHeight - ComputedPhysicalOffsets().top -
+ComputedPhysicalMargin().top - ComputedPhysicalBorderPadding().top - ComputedHeight() -
+ComputedPhysicalBorderPadding().bottom - ComputedPhysicalMargin().bottom;
+}
+} else {
+// Neither 'top' nor 'bottom' is 'auto'.
+nscoord autoHeight = containingBlockHeight -
+ComputedPhysicalOffsets().TopBottom() -
+ComputedPhysicalMargin().TopBottom() -
+ComputedPhysicalBorderPadding().TopBottom();
+if (autoHeight < 0) {
+autoHeight = 0;
+}
+if (ComputedHeight() == NS_UNCONSTRAINEDSIZE) {
+// For non-replaced elements with 'height' auto, the 'height'
+// fills the remaining space.
+ComputedHeight() = autoHeight;
+// XXX Do these need box-sizing adjustments?
+if (ComputedHeight() > ComputedMaxHeight())
+ComputedHeight() = ComputedMaxHeight();
+if (ComputedHeight() < ComputedMinHeight())
+ComputedHeight() = ComputedMinHeight();
+}
+// The height might still not fill all the available space in case:
+//  * height was specified
+//  * we're dealing with a replaced element
+//  * height was constrained by min-height or max-height.
+nscoord availMarginSpace = autoHeight - ComputedHeight();
+bool marginTopIsAuto =
+eStyleUnit_Auto == mStyleMargin->mMargin.GetTopUnit();
+bool marginBottomIsAuto =
+eStyleUnit_Auto == mStyleMargin->mMargin.GetBottomUnit();
+if (marginTopIsAuto) {
+if (marginBottomIsAuto) {
+if (availMarginSpace < 0) {
+// FIXME: Note that the spec doesn't actually say we should do this!
+ComputedPhysicalMargin().bottom = availMarginSpace;
+} else {
+// Both 'margin-top' and 'margin-bottom' are 'auto', so they get
+// equal values
+ComputedPhysicalMargin().top = availMarginSpace / 2;
+ComputedPhysicalMargin().bottom = availMarginSpace - ComputedPhysicalMargin().top;
+}
+} else {
+// Just 'margin-top' is 'auto'
+ComputedPhysicalMargin().top = availMarginSpace;
+}
+} else {
+if (marginBottomIsAuto) {
+// Just 'margin-bottom' is 'auto'
+ComputedPhysicalMargin().bottom = availMarginSpace;
+} else {
+// We're over-constrained so ignore the specified value for
+// 'bottom'.  (And note that the spec says to ignore 'bottom'
+// rather than 'margin-bottom'.)
+ComputedPhysicalOffsets().bottom += availMarginSpace;
+}
+}
+}
+}
+nscoord
+GetVerticalMarginBorderPadding(const nsHTMLReflowState* aReflowState)
+{
+nscoord result = 0;
+if (!aReflowState) return result;
+// zero auto margins
+nsMargin margin = aReflowState->ComputedPhysicalMargin();
+if (NS_AUTOMARGIN == margin.top)
+margin.top = 0;
+if (NS_AUTOMARGIN == margin.bottom)
+margin.bottom = 0;
+result += margin.top + margin.bottom;
+result += aReflowState->ComputedPhysicalBorderPadding().top +
+aReflowState->ComputedPhysicalBorderPadding().bottom;
+return result;
+}
+/* Get the height based on the viewport of the containing block specified
+* in aReflowState when the containing block has mComputedHeight == NS_AUTOHEIGHT
+* This will walk up the chain of containing blocks looking for a computed height
+* until it finds the canvas frame, or it encounters a frame that is not a block,
+* area, or scroll frame. This handles compatibility with IE (see bug 85016 and bug 219693)
+*
+*  When we encounter scrolledContent block frames, we skip over them, since they are guaranteed to not be useful for computing the containing block.
+*
+* See also IsQuirkContainingBlockHeight.
+*/
+static nscoord
+CalcQuirkContainingBlockHeight(const nsHTMLReflowState* aCBReflowState)
+{
+const nsHTMLReflowState* firstAncestorRS = nullptr; // a candidate for html frame
+const nsHTMLReflowState* secondAncestorRS = nullptr; // a candidate for body frame
+// initialize the default to NS_AUTOHEIGHT as this is the containings block
+// computed height when this function is called. It is possible that we
+// don't alter this height especially if we are restricted to one level
+nscoord result = NS_AUTOHEIGHT;
+const nsHTMLReflowState* rs = aCBReflowState;
+for (; rs; rs = rs->parentReflowState) {
+nsIAtom* frameType = rs->frame->GetType();
+// if the ancestor is auto height then skip it and continue up if it
+// is the first block frame and possibly the body/html
+if (nsGkAtoms::blockFrame == frameType ||
+#ifdef MOZ_XUL
+nsGkAtoms::XULLabelFrame == frameType ||
+#endif
+nsGkAtoms::scrollFrame == frameType) {
+secondAncestorRS = firstAncestorRS;
+firstAncestorRS = rs;
+// If the current frame we're looking at is positioned, we don't want to
+// go any further (see bug 221784).  The behavior we want here is: 1) If
+// not auto-height, use this as the percentage base.  2) If auto-height,
+// keep looking, unless the frame is positioned.
+if (NS_AUTOHEIGHT == rs->ComputedHeight()) {
+if (rs->frame->IsAbsolutelyPositioned()) {
+break;
+} else {
+continue;
+}
+}
+}
+else if (nsGkAtoms::canvasFrame == frameType) {
+// Always continue on to the height calculation
+}
+else if (nsGkAtoms::pageContentFrame == frameType) {
+nsIFrame* prevInFlow = rs->frame->GetPrevInFlow();
+// only use the page content frame for a height basis if it is the first in flow
+if (prevInFlow)
+break;
+}
+else {
+break;
+}
+// if the ancestor is the page content frame then the percent base is
+// the avail height, otherwise it is the computed height
+result = (nsGkAtoms::pageContentFrame == frameType)
+? rs->AvailableHeight() : rs->ComputedHeight();
+// if unconstrained - don't sutract borders - would result in huge height
+if (NS_AUTOHEIGHT == result) return result;
+// if we got to the canvas or page content frame, then subtract out
+// margin/border/padding for the BODY and HTML elements
+if ((nsGkAtoms::canvasFrame == frameType) ||
+(nsGkAtoms::pageContentFrame == frameType)) {
+result -= GetVerticalMarginBorderPadding(firstAncestorRS);
+result -= GetVerticalMarginBorderPadding(secondAncestorRS);
+#ifdef DEBUG
+// make sure the first ancestor is the HTML and the second is the BODY
+if (firstAncestorRS) {
+nsIContent* frameContent = firstAncestorRS->frame->GetContent();
+if (frameContent) {
+nsIAtom *contentTag = frameContent->Tag();
+NS_ASSERTION(contentTag == nsGkAtoms::html, "First ancestor is not HTML");
+}
+}
+if (secondAncestorRS) {
+nsIContent* frameContent = secondAncestorRS->frame->GetContent();
+if (frameContent) {
+nsIAtom *contentTag = frameContent->Tag();
+NS_ASSERTION(contentTag == nsGkAtoms::body, "Second ancestor is not BODY");
+}
+}
+#endif
+}
+// if we got to the html frame (a block child of the canvas) ...
+else if (nsGkAtoms::blockFrame == frameType &&
+rs->parentReflowState &&
+nsGkAtoms::canvasFrame ==
+rs->parentReflowState->frame->GetType()) {
+// ... then subtract out margin/border/padding for the BODY element
+result -= GetVerticalMarginBorderPadding(secondAncestorRS);
+}
+break;
+}
+// Make sure not to return a negative height here!
+return std::max(result, 0);
+}
+// Called by InitConstraints() to compute the containing block rectangle for
+// the element. Handles the special logic for absolutely positioned elements
+void
+nsHTMLReflowState::ComputeContainingBlockRectangle(nsPresContext*          aPresContext,
+const nsHTMLReflowState* aContainingBlockRS,
+nscoord&                 aContainingBlockWidth,
+nscoord&                 aContainingBlockHeight)
+{
+// Unless the element is absolutely positioned, the containing block is
+// formed by the content edge of the nearest block-level ancestor
+aContainingBlockWidth = aContainingBlockRS->ComputedWidth();
+aContainingBlockHeight = aContainingBlockRS->ComputedHeight();
+// mFrameType for abs-pos tables is NS_CSS_FRAME_TYPE_BLOCK, so we need to
+// special case them here.
+if (NS_FRAME_GET_TYPE(mFrameType) == NS_CSS_FRAME_TYPE_ABSOLUTE ||
+(frame->GetType() == nsGkAtoms::tableFrame &&
+frame->IsAbsolutelyPositioned() &&
+(frame->GetParent()->GetStateBits() & NS_FRAME_OUT_OF_FLOW))) {
+// See if the ancestor is block-level or inline-level
+if (NS_FRAME_GET_TYPE(aContainingBlockRS->mFrameType) == NS_CSS_FRAME_TYPE_INLINE) {
+// Base our size on the actual size of the frame.  In cases when this is
+// completely bogus (eg initial reflow), this code shouldn't even be
+// called, since the code in nsInlineFrame::Reflow will pass in
+// the containing block dimensions to our constructor.
+// XXXbz we should be taking the in-flows into account too, but
+// that's very hard.
+nsMargin computedBorder = aContainingBlockRS->ComputedPhysicalBorderPadding() -
+aContainingBlockRS->ComputedPhysicalPadding();
+aContainingBlockWidth = aContainingBlockRS->frame->GetRect().width -
+computedBorder.LeftRight();
+NS_ASSERTION(aContainingBlockWidth >= 0,
+"Negative containing block width!");
+aContainingBlockHeight = aContainingBlockRS->frame->GetRect().height -
+computedBorder.TopBottom();
+NS_ASSERTION(aContainingBlockHeight >= 0,
+"Negative containing block height!");
+} else {
+// If the ancestor is block-level, the containing block is formed by the
+// padding edge of the ancestor
+aContainingBlockWidth += aContainingBlockRS->ComputedPhysicalPadding().LeftRight();
+aContainingBlockHeight += aContainingBlockRS->ComputedPhysicalPadding().TopBottom();
+}
+} else {
+// an element in quirks mode gets a containing block based on looking for a
+// parent with a non-auto height if the element has a percent height
+// Note: We don't emulate this quirk for percents in calc().
+if (NS_AUTOHEIGHT == aContainingBlockHeight) {
+if (eCompatibility_NavQuirks == aPresContext->CompatibilityMode() &&
+mStylePosition->mHeight.GetUnit() == eStyleUnit_Percent) {
+aContainingBlockHeight = CalcQuirkContainingBlockHeight(aContainingBlockRS);
+}
+}
+}
+}
+static eNormalLineHeightControl GetNormalLineHeightCalcControl(void)
+{
+if (sNormalLineHeightControl == eUninitialized) {
+// browser.display.normal_lineheight_calc_control is not user
+// changeable, so no need to register callback for it.
+int32_t val =
+Preferences::GetInt("browser.display.normal_lineheight_calc_control",
+eNoExternalLeading);
+sNormalLineHeightControl = static_cast<eNormalLineHeightControl>(val);
+}
+return sNormalLineHeightControl;
+}
+static inline bool
+IsSideCaption(nsIFrame* aFrame, const nsStyleDisplay* aStyleDisplay)
+{
+if (aStyleDisplay->mDisplay != NS_STYLE_DISPLAY_TABLE_CAPTION)
+return false;
+uint8_t captionSide = aFrame->StyleTableBorder()->mCaptionSide;
+return captionSide == NS_STYLE_CAPTION_SIDE_LEFT ||
+captionSide == NS_STYLE_CAPTION_SIDE_RIGHT;
+}
+static nsFlexContainerFrame*
+GetFlexContainer(nsIFrame* aFrame)
+{
+nsIFrame* parent = aFrame->GetParent();
+if (!parent ||
+parent->GetType() != nsGkAtoms::flexContainerFrame) {
+return nullptr;
+}
+return static_cast<nsFlexContainerFrame*>(parent);
+}
+// Flex items resolve percentage margin & padding against the flex
+// container's height (which is the containing block height).
+// For everything else: the CSS21 spec requires that margin and padding
+// percentage values are calculated with respect to the *width* of the
+// containing block, even for margin & padding in the vertical axis.
+static nscoord
+VerticalOffsetPercentBasis(const nsIFrame* aFrame,
+nscoord aContainingBlockWidth,
+nscoord aContainingBlockHeight)
+{
+if (!aFrame->IsFlexItem()) {
+return aContainingBlockWidth;
+}
+if (aContainingBlockHeight == NS_AUTOHEIGHT) {
+return 0;
+}
+return aContainingBlockHeight;
+}
+// XXX refactor this code to have methods for each set of properties
+// we are computing: width,height,line-height; margin; offsets
+void
+nsHTMLReflowState::InitConstraints(nsPresContext* aPresContext,
+nscoord         aContainingBlockWidth,
+nscoord         aContainingBlockHeight,
+const nsMargin* aBorder,
+const nsMargin* aPadding,
+nsIAtom* aFrameType)
+{
+DISPLAY_INIT_CONSTRAINTS(frame, this,
+aContainingBlockWidth, aContainingBlockHeight,
+aBorder, aPadding);
+// If this is a reflow root, then set the computed width and
+// height equal to the available space
+if (nullptr == parentReflowState || mFlags.mDummyParentReflowState) {
+// XXXldb This doesn't mean what it used to!
+InitOffsets(aContainingBlockWidth,
+VerticalOffsetPercentBasis(frame, aContainingBlockWidth,
+aContainingBlockHeight),
+aFrameType, aBorder, aPadding);
+// Override mComputedMargin since reflow roots start from the
+// frame's boundary, which is inside the margin.
+ComputedPhysicalMargin().SizeTo(0, 0, 0, 0);
+ComputedPhysicalOffsets().SizeTo(0, 0, 0, 0);
+ComputedWidth() = AvailableWidth() - ComputedPhysicalBorderPadding().LeftRight();
+if (ComputedWidth() < 0)
+ComputedWidth() = 0;
+if (AvailableHeight() != NS_UNCONSTRAINEDSIZE) {
+ComputedHeight() = AvailableHeight() - ComputedPhysicalBorderPadding().TopBottom();
+if (ComputedHeight() < 0)
+ComputedHeight() = 0;
+} else {
+ComputedHeight() = NS_UNCONSTRAINEDSIZE;
+}
+ComputedMinWidth() = ComputedMinHeight() = 0;
+ComputedMaxWidth() = ComputedMaxHeight() = NS_UNCONSTRAINEDSIZE;
+} else {
+// Get the containing block reflow state
+const nsHTMLReflowState* cbrs = mCBReflowState;
+NS_ASSERTION(nullptr != cbrs, "no containing block");
+// If we weren't given a containing block width and height, then
+// compute one
+if (aContainingBlockWidth == -1) {
+ComputeContainingBlockRectangle(aPresContext, cbrs, aContainingBlockWidth,
+aContainingBlockHeight);
+}
+// See if the containing block height is based on the size of its
+// content
+nsIAtom* fType;
+if (NS_AUTOHEIGHT == aContainingBlockHeight) {
+// See if the containing block is a cell frame which needs
+// to use the mComputedHeight of the cell instead of what the cell block passed in.
+// XXX It seems like this could lead to bugs with min-height and friends
+if (cbrs->parentReflowState) {
+fType = cbrs->frame->GetType();
+if (IS_TABLE_CELL(fType)) {
+// use the cell's computed height
+aContainingBlockHeight = cbrs->ComputedHeight();
+}
+}
+}
+// XXX Might need to also pass the CB height (not width) for page boxes,
+// too, if we implement them.
+InitOffsets(aContainingBlockWidth,
+VerticalOffsetPercentBasis(frame, aContainingBlockWidth,
+aContainingBlockHeight),
+aFrameType, aBorder, aPadding);
+const nsStyleCoord &height = mStylePosition->mHeight;
+nsStyleUnit heightUnit = height.GetUnit();
+// Check for a percentage based height and a containing block height
+// that depends on the content height
+// XXX twiddling heightUnit doesn't help anymore
+// FIXME Shouldn't we fix that?
+if (height.HasPercent()) {
+if (NS_AUTOHEIGHT == aContainingBlockHeight) {
+// this if clause enables %-height on replaced inline frames,
+// such as images.  See bug 54119.  The else clause "heightUnit = eStyleUnit_Auto;"
+// used to be called exclusively.
+if (NS_FRAME_REPLACED(NS_CSS_FRAME_TYPE_INLINE) == mFrameType ||
+NS_FRAME_REPLACED_CONTAINS_BLOCK(
+NS_CSS_FRAME_TYPE_INLINE) == mFrameType) {
+// Get the containing block reflow state
+NS_ASSERTION(nullptr != cbrs, "no containing block");
+// in quirks mode, get the cb height using the special quirk method
+if (eCompatibility_NavQuirks == aPresContext->CompatibilityMode()) {
+if (!IS_TABLE_CELL(fType)) {
+aContainingBlockHeight = CalcQuirkContainingBlockHeight(cbrs);
+if (aContainingBlockHeight == NS_AUTOHEIGHT) {
+heightUnit = eStyleUnit_Auto;
+}
+}
+else {
+heightUnit = eStyleUnit_Auto;
+}
+}
+// in standard mode, use the cb height.  if it's "auto", as will be the case
+// by default in BODY, use auto height as per CSS2 spec.
+else
+{
+if (NS_AUTOHEIGHT != cbrs->ComputedHeight())
+aContainingBlockHeight = cbrs->ComputedHeight();
+else
+heightUnit = eStyleUnit_Auto;
+}
+}
+else {
+// default to interpreting the height like 'auto'
+heightUnit = eStyleUnit_Auto;
+}
+}
+}
+// Compute our offsets if the element is relatively positioned.  We need
+// the correct containing block width and height here, which is why we need
+// to do it after all the quirks-n-such above. (If the element is sticky
+// positioned, we need to wait until the scroll container knows its size,
+// so we compute offsets from StickyScrollContainer::UpdatePositions.)
+if (mStyleDisplay->IsRelativelyPositioned(frame) &&
+NS_STYLE_POSITION_RELATIVE == mStyleDisplay->mPosition) {
+uint8_t direction = NS_STYLE_DIRECTION_LTR;
+if (cbrs && NS_STYLE_DIRECTION_RTL == cbrs->mStyleVisibility->mDirection) {
+direction = NS_STYLE_DIRECTION_RTL;
+}
+ComputeRelativeOffsets(direction, frame, aContainingBlockWidth,
+aContainingBlockHeight, ComputedPhysicalOffsets());
+} else {
+// Initialize offsets to 0
+ComputedPhysicalOffsets().SizeTo(0, 0, 0, 0);
+}
+// Calculate the computed values for min and max properties.  Note that
+// this MUST come after we've computed our border and padding.
+ComputeMinMaxValues(aContainingBlockWidth, aContainingBlockHeight, cbrs);
+// Calculate the computed width and height. This varies by frame type
+if (NS_CSS_FRAME_TYPE_INTERNAL_TABLE == mFrameType) {
+// Internal table elements. The rules vary depending on the type.
+// Calculate the computed width
+bool rowOrRowGroup = false;
+const nsStyleCoord &width = mStylePosition->mWidth;
+nsStyleUnit widthUnit = width.GetUnit();
+if ((NS_STYLE_DISPLAY_TABLE_ROW == mStyleDisplay->mDisplay) ||
+(NS_STYLE_DISPLAY_TABLE_ROW_GROUP == mStyleDisplay->mDisplay)) {
+// 'width' property doesn't apply to table rows and row groups
+widthUnit = eStyleUnit_Auto;
+rowOrRowGroup = true;
+}
+// calc() with percentages acts like auto on internal table elements
+if (eStyleUnit_Auto == widthUnit ||
+(width.IsCalcUnit() && width.CalcHasPercent())) {
+ComputedWidth() = AvailableWidth();
+if ((ComputedWidth() != NS_UNCONSTRAINEDSIZE) && !rowOrRowGroup){
+// Internal table elements don't have margins. Only tables and
+// cells have border and padding
+ComputedWidth() -= ComputedPhysicalBorderPadding().left +
+ComputedPhysicalBorderPadding().right;
+if (ComputedWidth() < 0)
+ComputedWidth() = 0;
+}
+NS_ASSERTION(ComputedWidth() >= 0, "Bogus computed width");
+} else {
+NS_ASSERTION(widthUnit == mStylePosition->mWidth.GetUnit(),
+"unexpected width unit change");
+ComputedWidth() = ComputeWidthValue(aContainingBlockWidth,
+mStylePosition->mBoxSizing,
+mStylePosition->mWidth);
+}
+// Calculate the computed height
+if ((NS_STYLE_DISPLAY_TABLE_COLUMN == mStyleDisplay->mDisplay) ||
+(NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP == mStyleDisplay->mDisplay)) {
+// 'height' property doesn't apply to table columns and column groups
+heightUnit = eStyleUnit_Auto;
+}
+// calc() with percentages acts like 'auto' on internal table elements
+if (eStyleUnit_Auto == heightUnit ||
+(height.IsCalcUnit() && height.CalcHasPercent())) {
+ComputedHeight() = NS_AUTOHEIGHT;
+} else {
+NS_ASSERTION(heightUnit == mStylePosition->mHeight.GetUnit(),
+"unexpected height unit change");
+ComputedHeight() = ComputeHeightValue(aContainingBlockHeight,
+mStylePosition->mBoxSizing,
+mStylePosition->mHeight);
+}
+// Doesn't apply to table elements
+ComputedMinWidth() = ComputedMinHeight() = 0;
+ComputedMaxWidth() = ComputedMaxHeight() = NS_UNCONSTRAINEDSIZE;
+} else if (NS_FRAME_GET_TYPE(mFrameType) == NS_CSS_FRAME_TYPE_ABSOLUTE) {
+// XXX not sure if this belongs here or somewhere else - cwk
+InitAbsoluteConstraints(aPresContext, cbrs, aContainingBlockWidth,
+aContainingBlockHeight, aFrameType);
+} else {
+AutoMaybeDisableFontInflation an(frame);
+bool isBlock = NS_CSS_FRAME_TYPE_BLOCK == NS_FRAME_GET_TYPE(mFrameType);
+uint32_t computeSizeFlags = isBlock ? 0 : nsIFrame::eShrinkWrap;
+// Make sure legend frames with display:block and width:auto still
+// shrink-wrap.
+if (isBlock &&
+((aFrameType == nsGkAtoms::legendFrame &&
+frame->StyleContext()->GetPseudo() != nsCSSAnonBoxes::scrolledContent) ||
+(aFrameType == nsGkAtoms::scrollFrame &&
+frame->GetContentInsertionFrame()->GetType() == nsGkAtoms::legendFrame))) {
+computeSizeFlags |= nsIFrame::eShrinkWrap;
+}
+const nsFlexContainerFrame* flexContainerFrame = GetFlexContainer(frame);
+if (flexContainerFrame) {
+computeSizeFlags |= nsIFrame::eShrinkWrap;
+// If we're inside of a flex container that needs to measure our
+// auto height, pass that information along to ComputeSize().
+if (mFlags.mIsFlexContainerMeasuringHeight) {
+computeSizeFlags |= nsIFrame::eUseAutoHeight;
+}
+} else {
+MOZ_ASSERT(!mFlags.mIsFlexContainerMeasuringHeight,
+"We're not in a flex container, so the flag "
+"'mIsFlexContainerMeasuringHeight' shouldn't be set");
+}
+nsSize size =
+frame->ComputeSize(rendContext,
+nsSize(aContainingBlockWidth,
+aContainingBlockHeight),
+AvailableWidth(),
+nsSize(ComputedPhysicalMargin().LeftRight(),
+ComputedPhysicalMargin().TopBottom()),
+nsSize(ComputedPhysicalBorderPadding().LeftRight() -
+ComputedPhysicalPadding().LeftRight(),
+ComputedPhysicalBorderPadding().TopBottom() -
+ComputedPhysicalPadding().TopBottom()),
+nsSize(ComputedPhysicalPadding().LeftRight(),
+ComputedPhysicalPadding().TopBottom()),
+computeSizeFlags);
+ComputedWidth() = size.width;
+ComputedHeight() = size.height;
+NS_ASSERTION(ComputedWidth() >= 0, "Bogus width");
+NS_ASSERTION(ComputedHeight() == NS_UNCONSTRAINEDSIZE ||
+ComputedHeight() >= 0, "Bogus height");
+// Exclude inline tables and flex items from the block margin calculations
+if (isBlock &&
+!IsSideCaption(frame, mStyleDisplay) &&
+mStyleDisplay->mDisplay != NS_STYLE_DISPLAY_INLINE_TABLE &&
+!flexContainerFrame) {
+CalculateBlockSideMargins(AvailableWidth(), ComputedWidth(), aFrameType);
+}
+}
+}
+}
+static void
+UpdateProp(FrameProperties& aProps,
+const FramePropertyDescriptor* aProperty,
+bool aNeeded,
+nsMargin& aNewValue)
+{
+if (aNeeded) {
+nsMargin* propValue = static_cast<nsMargin*>(aProps.Get(aProperty));
+if (propValue) {
+*propValue = aNewValue;
+} else {
+aProps.Set(aProperty, new nsMargin(aNewValue));
+}
+} else {
+aProps.Delete(aProperty);
+}
+}
+void
+nsCSSOffsetState::InitOffsets(nscoord aHorizontalPercentBasis,
+nscoord aVerticalPercentBasis,
+nsIAtom* aFrameType,
+const nsMargin *aBorder,
+const nsMargin *aPadding)
+{
+DISPLAY_INIT_OFFSETS(frame, this,
+aHorizontalPercentBasis,
+aVerticalPercentBasis,
+aBorder, aPadding);
+// Since we are in reflow, we don't need to store these properties anymore
+// unless they are dependent on width, in which case we store the new value.
+nsPresContext *presContext = frame->PresContext();
+FrameProperties props(presContext->PropertyTable(), frame);
+props.Delete(nsIFrame::UsedBorderProperty());
+// Compute margins from the specified margin style information. These
+// become the default computed values, and may be adjusted below
+// XXX fix to provide 0,0 for the top&bottom margins for
+// inline-non-replaced elements
+bool needMarginProp = ComputeMargin(aHorizontalPercentBasis,
+aVerticalPercentBasis);
+// XXX We need to include 'auto' horizontal margins in this too!
+// ... but if we did that, we'd need to fix nsFrame::GetUsedMargin
+// to use it even when the margins are all zero (since sometimes
+// they get treated as auto)
+::UpdateProp(props, nsIFrame::UsedMarginProperty(), needMarginProp,
+ComputedPhysicalMargin());
+const nsStyleDisplay *disp = frame->StyleDisplay();
+bool isThemed = frame->IsThemed(disp);
+bool needPaddingProp;
+nsIntMargin widget;
+if (isThemed &&
+presContext->GetTheme()->GetWidgetPadding(presContext->DeviceContext(),
+frame, disp->mAppearance,
+&widget)) {
+ComputedPhysicalPadding().top = presContext->DevPixelsToAppUnits(widget.top);
+ComputedPhysicalPadding().right = presContext->DevPixelsToAppUnits(widget.right);
+ComputedPhysicalPadding().bottom = presContext->DevPixelsToAppUnits(widget.bottom);
+ComputedPhysicalPadding().left = presContext->DevPixelsToAppUnits(widget.left);
+needPaddingProp = false;
+}
+else if (frame->IsSVGText()) {
+ComputedPhysicalPadding().SizeTo(0, 0, 0, 0);
+needPaddingProp = false;
+}
+else if (aPadding) { // padding is an input arg
+ComputedPhysicalPadding() = *aPadding;
+needPaddingProp = frame->StylePadding()->IsWidthDependent() ||
+	  (frame->GetStateBits() & NS_FRAME_REFLOW_ROOT);
+}
+else {
+needPaddingProp = ComputePadding(aHorizontalPercentBasis,
+aVerticalPercentBasis, aFrameType);
+}
+if (isThemed) {
+nsIntMargin widget;
+presContext->GetTheme()->GetWidgetBorder(presContext->DeviceContext(),
+frame, disp->mAppearance,
+&widget);
+ComputedPhysicalBorderPadding().top =
+presContext->DevPixelsToAppUnits(widget.top);
+ComputedPhysicalBorderPadding().right =
+presContext->DevPixelsToAppUnits(widget.right);
+ComputedPhysicalBorderPadding().bottom =
+presContext->DevPixelsToAppUnits(widget.bottom);
+ComputedPhysicalBorderPadding().left =
+presContext->DevPixelsToAppUnits(widget.left);
+}
+else if (frame->IsSVGText()) {
+ComputedPhysicalBorderPadding().SizeTo(0, 0, 0, 0);
+}
+else if (aBorder) {  // border is an input arg
+ComputedPhysicalBorderPadding() = *aBorder;
+}
+else {
+ComputedPhysicalBorderPadding() = frame->StyleBorder()->GetComputedBorder();
+}
+ComputedPhysicalBorderPadding() += ComputedPhysicalPadding();
+if (aFrameType == nsGkAtoms::tableFrame) {
+nsTableFrame *tableFrame = static_cast<nsTableFrame*>(frame);
+if (tableFrame->IsBorderCollapse()) {
+// border-collapsed tables don't use any of their padding, and
+// only part of their border.  We need to do this here before we
+// try to do anything like handling 'auto' widths,
+// 'box-sizing', or 'auto' margins.
+ComputedPhysicalPadding().SizeTo(0,0,0,0);
+ComputedPhysicalBorderPadding() = tableFrame->GetIncludedOuterBCBorder();
+}
+// The margin is inherited to the outer table frame via
+// the ::-moz-table-outer rule in ua.css.
+ComputedPhysicalMargin().SizeTo(0, 0, 0, 0);
+} else if (aFrameType == nsGkAtoms::scrollbarFrame) {
+// scrollbars may have had their width or height smashed to zero
+// by the associated scrollframe, in which case we must not report
+// any padding or border.
+nsSize size(frame->GetSize());
+if (size.width == 0 || size.height == 0) {
+ComputedPhysicalPadding().SizeTo(0,0,0,0);
+ComputedPhysicalBorderPadding().SizeTo(0,0,0,0);
+}
+}
+::UpdateProp(props, nsIFrame::UsedPaddingProperty(), needPaddingProp,
+ComputedPhysicalPadding());
+}
+// This code enforces section 10.3.3 of the CSS2 spec for this formula:
+//
+// 'margin-left' + 'border-left-width' + 'padding-left' + 'width' +
+//   'padding-right' + 'border-right-width' + 'margin-right'
+//   = width of containing block
+//
+// Note: the width unit is not auto when this is called
+void
+nsHTMLReflowState::CalculateBlockSideMargins(nscoord aAvailWidth,
+nscoord aComputedWidth,
+nsIAtom* aFrameType)
+{
+NS_WARN_IF_FALSE(NS_UNCONSTRAINEDSIZE != aComputedWidth &&
+NS_UNCONSTRAINEDSIZE != aAvailWidth,
+"have unconstrained width; this should only result from "
+"very large sizes, not attempts at intrinsic width "
+"calculation");
+nscoord sum = ComputedPhysicalMargin().left + ComputedPhysicalBorderPadding().left +
+aComputedWidth + ComputedPhysicalBorderPadding().right + ComputedPhysicalMargin().right;
+if (sum == aAvailWidth)
+// The sum is already correct
+return;
+// Determine the left and right margin values. The width value
+// remains constant while we do this.
+// Calculate how much space is available for margins
+nscoord availMarginSpace = aAvailWidth - sum;
+// If the available margin space is negative, then don't follow the
+// usual overconstraint rules.
+if (availMarginSpace < 0) {
+if (mCBReflowState &&
+mCBReflowState->mStyleVisibility->mDirection == NS_STYLE_DIRECTION_RTL) {
+ComputedPhysicalMargin().left += availMarginSpace;
+} else {
+ComputedPhysicalMargin().right += availMarginSpace;
+}
+return;
+}
+// The css2 spec clearly defines how block elements should behave
+// in section 10.3.3.
+bool isAutoLeftMargin =
+eStyleUnit_Auto == mStyleMargin->mMargin.GetLeftUnit();
+bool isAutoRightMargin =
+eStyleUnit_Auto == mStyleMargin->mMargin.GetRightUnit();
+if (!isAutoLeftMargin && !isAutoRightMargin) {
+// Neither margin is 'auto' so we're over constrained. Use the
+// 'direction' property of the parent to tell which margin to
+// ignore
+// First check if there is an HTML alignment that we should honor
+const nsHTMLReflowState* prs = parentReflowState;
+if (aFrameType == nsGkAtoms::tableFrame) {
+NS_ASSERTION(prs->frame->GetType() == nsGkAtoms::tableOuterFrame,
+"table not inside outer table");
+// Center the table within the outer table based on the alignment
+// of the outer table's parent.
+prs = prs->parentReflowState;
+}
+if (prs &&
+(prs->mStyleText->mTextAlign == NS_STYLE_TEXT_ALIGN_MOZ_LEFT ||
+prs->mStyleText->mTextAlign == NS_STYLE_TEXT_ALIGN_MOZ_CENTER ||
+prs->mStyleText->mTextAlign == NS_STYLE_TEXT_ALIGN_MOZ_RIGHT)) {
+isAutoLeftMargin =
+prs->mStyleText->mTextAlign != NS_STYLE_TEXT_ALIGN_MOZ_LEFT;
+isAutoRightMargin =
+prs->mStyleText->mTextAlign != NS_STYLE_TEXT_ALIGN_MOZ_RIGHT;
+}
+// Otherwise apply the CSS rules, and ignore one margin by forcing
+// it to 'auto', depending on 'direction'.
+else if (mCBReflowState &&
+NS_STYLE_DIRECTION_RTL == mCBReflowState->mStyleVisibility->mDirection) {
+isAutoLeftMargin = true;
+}
+else {
+isAutoRightMargin = true;
+}
+}
+// Logic which is common to blocks and tables
+// The computed margins need not be zero because the 'auto' could come from
+// overconstraint or from HTML alignment so values need to be accumulated
+if (isAutoLeftMargin) {
+if (isAutoRightMargin) {
+// Both margins are 'auto' so the computed addition should be equal
+nscoord forLeft = availMarginSpace / 2;
+ComputedPhysicalMargin().left  += forLeft;
+ComputedPhysicalMargin().right += availMarginSpace - forLeft;
+} else {
+ComputedPhysicalMargin().left += availMarginSpace;
+}
+} else if (isAutoRightMargin) {
+ComputedPhysicalMargin().right += availMarginSpace;
+}
+}
+#define NORMAL_LINE_HEIGHT_FACTOR 1.2f    // in term of emHeight
+// For "normal" we use the font's normal line height (em height + leading).
+// If both internal leading and  external leading specified by font itself
+// are zeros, we should compensate this by creating extra (external) leading
+// in eCompensateLeading mode. This is necessary because without this
+// compensation, normal line height might looks too tight.
+// For risk management, we use preference to control the behavior, and
+// eNoExternalLeading is the old behavior.
+static nscoord
+GetNormalLineHeight(nsFontMetrics* aFontMetrics)
+{
+NS_PRECONDITION(nullptr != aFontMetrics, "no font metrics");
+nscoord normalLineHeight;
+nscoord externalLeading = aFontMetrics->ExternalLeading();
+nscoord internalLeading = aFontMetrics->InternalLeading();
+nscoord emHeight = aFontMetrics->EmHeight();
+switch (GetNormalLineHeightCalcControl()) {
+case eIncludeExternalLeading:
+normalLineHeight = emHeight+ internalLeading + externalLeading;
+break;
+case eCompensateLeading:
+if (!internalLeading && !externalLeading)
+normalLineHeight = NSToCoordRound(emHeight * NORMAL_LINE_HEIGHT_FACTOR);
+else
+normalLineHeight = emHeight+ internalLeading + externalLeading;
+break;
+default:
+//case eNoExternalLeading:
+normalLineHeight = emHeight + internalLeading;
+}
+return normalLineHeight;
+}
+static inline nscoord
+ComputeLineHeight(nsStyleContext* aStyleContext,
+nscoord aBlockHeight,
+float aFontSizeInflation)
+{
+const nsStyleCoord& lhCoord = aStyleContext->StyleText()->mLineHeight;
+if (lhCoord.GetUnit() == eStyleUnit_Coord) {
+nscoord result = lhCoord.GetCoordValue();
+if (aFontSizeInflation != 1.0f) {
+result = NSToCoordRound(result * aFontSizeInflation);
+}
+return result;
+}
+if (lhCoord.GetUnit() == eStyleUnit_Factor)
+// For factor units the computed value of the line-height property
+// is found by multiplying the factor by the font's computed size
+// (adjusted for min-size prefs and text zoom).
+return NSToCoordRound(lhCoord.GetFactorValue() * aFontSizeInflation *
+aStyleContext->StyleFont()->mFont.size);
+NS_ASSERTION(lhCoord.GetUnit() == eStyleUnit_Normal ||
+lhCoord.GetUnit() == eStyleUnit_Enumerated,
+"bad line-height unit");
+if (lhCoord.GetUnit() == eStyleUnit_Enumerated) {
+NS_ASSERTION(lhCoord.GetIntValue() == NS_STYLE_LINE_HEIGHT_BLOCK_HEIGHT,
+"bad line-height value");
+if (aBlockHeight != NS_AUTOHEIGHT) {
+return aBlockHeight;
+}
+}
+nsRefPtr<nsFontMetrics> fm;
+nsLayoutUtils::GetFontMetricsForStyleContext(aStyleContext,
+getter_AddRefs(fm),
+aFontSizeInflation);
+return GetNormalLineHeight(fm);
+}
+nscoord
+nsHTMLReflowState::CalcLineHeight() const
+{
+nscoord blockHeight =
+nsLayoutUtils::IsNonWrapperBlock(frame) ? ComputedHeight() :
+(mCBReflowState ? mCBReflowState->ComputedHeight() : NS_AUTOHEIGHT);
+return CalcLineHeight(frame->GetContent(), frame->StyleContext(), blockHeight,
+nsLayoutUtils::FontSizeInflationFor(frame));
+}
+/* static */ nscoord
+nsHTMLReflowState::CalcLineHeight(nsIContent* aContent,
+nsStyleContext* aStyleContext,
+nscoord aBlockHeight,
+float aFontSizeInflation)
+{
+NS_PRECONDITION(aStyleContext, "Must have a style context");
+nscoord lineHeight =
+ComputeLineHeight(aStyleContext, aBlockHeight, aFontSizeInflation);
+NS_ASSERTION(lineHeight >= 0, "ComputeLineHeight screwed up");
+HTMLInputElement* input = HTMLInputElement::FromContentOrNull(aContent);
+if (input && input->IsSingleLineTextControl()) {
+// For Web-compatibility, single-line text input elements cannot
+// have a line-height smaller than one.
+nscoord lineHeightOne =
+aFontSizeInflation * aStyleContext->StyleFont()->mFont.size;
+if (lineHeight < lineHeightOne) {
+lineHeight = lineHeightOne;
+}
+}
+return lineHeight;
+}
+bool
+nsCSSOffsetState::ComputeMargin(nscoord aHorizontalPercentBasis,
+nscoord aVerticalPercentBasis)
+{
+// SVG text frames have no margin.
+if (frame->IsSVGText()) {
+return false;
+}
+// If style style can provide us the margin directly, then use it.
+const nsStyleMargin *styleMargin = frame->StyleMargin();
+bool isCBDependent = !styleMargin->GetMargin(ComputedPhysicalMargin());
+if (isCBDependent) {
+// We have to compute the value
+ComputedPhysicalMargin().left = nsLayoutUtils::
+ComputeCBDependentValue(aHorizontalPercentBasis,
+styleMargin->mMargin.GetLeft());
+ComputedPhysicalMargin().right = nsLayoutUtils::
+ComputeCBDependentValue(aHorizontalPercentBasis,
+styleMargin->mMargin.GetRight());
+ComputedPhysicalMargin().top = nsLayoutUtils::
+ComputeCBDependentValue(aVerticalPercentBasis,
+styleMargin->mMargin.GetTop());
+ComputedPhysicalMargin().bottom = nsLayoutUtils::
+ComputeCBDependentValue(aVerticalPercentBasis,
+styleMargin->mMargin.GetBottom());
+}
+nscoord marginAdjustment = FontSizeInflationListMarginAdjustment(frame);
+if (marginAdjustment > 0) {
+const nsStyleVisibility* visibility = frame->StyleVisibility();
+if (visibility->mDirection == NS_STYLE_DIRECTION_RTL) {
+ComputedPhysicalMargin().right = ComputedPhysicalMargin().right + marginAdjustment;
+} else {
+ComputedPhysicalMargin().left = ComputedPhysicalMargin().left + marginAdjustment;
+}
+}
+return isCBDependent;
+}
+bool
+nsCSSOffsetState::ComputePadding(nscoord aHorizontalPercentBasis,
+nscoord aVerticalPercentBasis,
+nsIAtom* aFrameType)
+{
+// If style can provide us the padding directly, then use it.
+const nsStylePadding *stylePadding = frame->StylePadding();
+bool isCBDependent = !stylePadding->GetPadding(ComputedPhysicalPadding());
+// a table row/col group, row/col doesn't have padding
+// XXXldb Neither do border-collapse tables.
+if (nsGkAtoms::tableRowGroupFrame == aFrameType ||
+nsGkAtoms::tableColGroupFrame == aFrameType ||
+nsGkAtoms::tableRowFrame      == aFrameType ||
+nsGkAtoms::tableColFrame      == aFrameType) {
+ComputedPhysicalPadding().SizeTo(0,0,0,0);
+}
+else if (isCBDependent) {
+// We have to compute the value
+// clamp negative calc() results to 0
+ComputedPhysicalPadding().left = std::max(0, nsLayoutUtils::
+ComputeCBDependentValue(aHorizontalPercentBasis,
+stylePadding->mPadding.GetLeft()));
+ComputedPhysicalPadding().right = std::max(0, nsLayoutUtils::
+ComputeCBDependentValue(aHorizontalPercentBasis,
+stylePadding->mPadding.GetRight()));
+ComputedPhysicalPadding().top = std::max(0, nsLayoutUtils::
+ComputeCBDependentValue(aVerticalPercentBasis,
+stylePadding->mPadding.GetTop()));
+ComputedPhysicalPadding().bottom = std::max(0, nsLayoutUtils::
+ComputeCBDependentValue(aVerticalPercentBasis,
+stylePadding->mPadding.GetBottom()));
+}
+return isCBDependent;
+}
+void
+nsHTMLReflowState::ComputeMinMaxValues(nscoord aContainingBlockWidth,
+nscoord aContainingBlockHeight,
+const nsHTMLReflowState* aContainingBlockRS)
+{
+ComputedMinWidth() = ComputeWidthValue(aContainingBlockWidth,
+mStylePosition->mBoxSizing,
+mStylePosition->mMinWidth);
+if (eStyleUnit_None == mStylePosition->mMaxWidth.GetUnit()) {
+// Specified value of 'none'
+ComputedMaxWidth() = NS_UNCONSTRAINEDSIZE;  // no limit
+} else {
+ComputedMaxWidth() = ComputeWidthValue(aContainingBlockWidth,
+mStylePosition->mBoxSizing,
+mStylePosition->mMaxWidth);
+}
+// If the computed value of 'min-width' is greater than the value of
+// 'max-width', 'max-width' is set to the value of 'min-width'
+if (ComputedMinWidth() > ComputedMaxWidth()) {
+ComputedMaxWidth() = ComputedMinWidth();
+}
+// Check for percentage based values and a containing block height that
+// depends on the content height. Treat them like 'auto'
+// Likewise, check for calc() with percentages on internal table elements;
+// that's treated as 'auto' too.
+// Likewise, if we're a child of a flex container who's measuring our
+// intrinsic height, then we want to disregard our min-height.
+const nsStyleCoord &minHeight = mStylePosition->mMinHeight;
+if ((NS_AUTOHEIGHT == aContainingBlockHeight &&
+minHeight.HasPercent()) ||
+(mFrameType == NS_CSS_FRAME_TYPE_INTERNAL_TABLE &&
+minHeight.IsCalcUnit() && minHeight.CalcHasPercent()) ||
+mFlags.mIsFlexContainerMeasuringHeight) {
+ComputedMinHeight() = 0;
+} else {
+ComputedMinHeight() = ComputeHeightValue(aContainingBlockHeight,
+mStylePosition->mBoxSizing,
+minHeight);
+}
+const nsStyleCoord &maxHeight = mStylePosition->mMaxHeight;
+nsStyleUnit maxHeightUnit = maxHeight.GetUnit();
+if (eStyleUnit_None == maxHeightUnit) {
+// Specified value of 'none'
+ComputedMaxHeight() = NS_UNCONSTRAINEDSIZE;  // no limit
+} else {
+// Check for percentage based values and a containing block height that
+// depends on the content height. Treat them like 'none'
+// Likewise, check for calc() with percentages on internal table elements;
+// that's treated as 'auto' too.
+// Likewise, if we're a child of a flex container who's measuring our
+// intrinsic height, then we want to disregard our max-height.
+if ((NS_AUTOHEIGHT == aContainingBlockHeight &&
+maxHeight.HasPercent()) ||
+(mFrameType == NS_CSS_FRAME_TYPE_INTERNAL_TABLE &&
+maxHeight.IsCalcUnit() && maxHeight.CalcHasPercent()) ||
+mFlags.mIsFlexContainerMeasuringHeight) {
+ComputedMaxHeight() = NS_UNCONSTRAINEDSIZE;
+} else {
+ComputedMaxHeight() = ComputeHeightValue(aContainingBlockHeight,
+mStylePosition->mBoxSizing,
+maxHeight);
+}
+}
+// If the computed value of 'min-height' is greater than the value of
+// 'max-height', 'max-height' is set to the value of 'min-height'
+if (ComputedMinHeight() > ComputedMaxHeight()) {
+ComputedMaxHeight() = ComputedMinHeight();
+}
+}
+void
+nsHTMLReflowState::SetTruncated(const nsHTMLReflowMetrics& aMetrics,
+nsReflowStatus* aStatus) const
+{
+if (AvailableHeight() != NS_UNCONSTRAINEDSIZE &&
+AvailableHeight() < aMetrics.Height() &&
+!mFlags.mIsTopOfPage) {
+*aStatus |= NS_FRAME_TRUNCATED;
+} else {
+*aStatus &= ~NS_FRAME_TRUNCATED;
+}
+}
+bool
+nsHTMLReflowState::IsFloating() const
+{
+return mStyleDisplay->IsFloating(frame);
+}
+uint8_t
+nsHTMLReflowState::GetDisplay() const
+{
+return mStyleDisplay->GetDisplay(frame);
+}

The Tor Browser / file comparison

comparison: layout/generic/nsHTMLReflowState.cpp

layout/generic/nsHTMLReflowState.cpp