--- a/layout/base/PresShell.cpp
+++ b/layout/base/PresShell.cpp
@@ -9212,17 +9212,17 @@ PresShell::DoReflow(nsIFrame* target, bo
"non-root frame's desired size changed during an "
"incremental reflow");
NS_ASSERTION(target == rootFrame ||
desiredSize.VisualOverflow().IsEqualInterior(boundsRelativeToTarget),
"non-root reflow roots must not have visible overflow");
NS_ASSERTION(target == rootFrame ||
desiredSize.ScrollableOverflow().IsEqualEdges(boundsRelativeToTarget),
"non-root reflow roots must not have scrollable overflow");
- NS_ASSERTION(status == NS_FRAME_COMPLETE,
+ NS_ASSERTION(status.IsEmpty(),
"reflow roots should never split");
target->SetSize(boundsRelativeToTarget.Size());
// Always use boundsRelativeToTarget here, not desiredSize.GetVisualOverflowArea(),
// because for root frames (where they could be different, since root frames
// are allowed to have overflow) the root view bounds need to match the
// viewport bounds; the view manager "window dimensions" code depends on it.
--- a/layout/forms/nsComboboxControlFrame.cpp
+++ b/layout/forms/nsComboboxControlFrame.cpp
@@ -896,17 +896,17 @@ nsComboboxControlFrame::Reflow(nsPresCon
this->GetLogicalUsedPadding(wm).BStartEnd(wm);
mButtonFrame->SetRect(buttonRect, containerSize);
if (!aStatus.IsInlineBreakBefore() &&
!aStatus.IsFullyComplete()) {
// This frame didn't fit inside a fragmentation container. Splitting
// a nsComboboxControlFrame makes no sense, so we override the status here.
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
}
}
//--------------------------------------------------------------
nsIAtom*
nsComboboxControlFrame::GetType() const
{
@@ -1323,17 +1323,17 @@ nsComboboxDisplayFrame::Reflow(nsPresCon
WritingMode wm = aReflowInput.GetWritingMode();
nscoord computedISize = mComboBox->mDisplayISize -
state.ComputedLogicalBorderPadding().IStartEnd(wm);
if (computedISize < 0) {
computedISize = 0;
}
state.SetComputedISize(computedISize);
nsBlockFrame::Reflow(aPresContext, aDesiredSize, state, aStatus);
- aStatus = NS_FRAME_COMPLETE; // this type of frame can't be split
+ aStatus.Reset(); // this type of frame can't be split
}
void
nsComboboxDisplayFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists)
{
nsDisplayListCollection set;
--- a/layout/forms/nsDateTimeControlFrame.cpp
+++ b/layout/forms/nsDateTimeControlFrame.cpp
@@ -288,17 +288,17 @@ nsDateTimeControlFrame::Reflow(nsPresCon
aDesiredSize.SetOverflowAreasToDesiredBounds();
if (inputAreaFrame) {
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, inputAreaFrame);
}
FinishAndStoreOverflow(&aDesiredSize);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
("exit nsDateTimeControlFrame::Reflow: size=%d,%d",
aDesiredSize.Width(), aDesiredSize.Height()));
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
nsresult
--- a/layout/forms/nsFieldSetFrame.cpp
+++ b/layout/forms/nsFieldSetFrame.cpp
@@ -334,20 +334,20 @@ nsFieldSetFrame::Reflow(nsPresContext*
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsFieldSetFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
NS_PRECONDITION(aReflowInput.ComputedISize() != NS_INTRINSICSIZE,
"Should have a precomputed inline-size!");
// Initialize OUT parameter
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
nsOverflowAreas ocBounds;
- nsReflowStatus ocStatus = NS_FRAME_COMPLETE;
+ nsReflowStatus ocStatus;
if (GetPrevInFlow()) {
ReflowOverflowContainerChildren(aPresContext, aReflowInput, ocBounds, 0,
ocStatus);
}
//------------ Handle Incremental Reflow -----------------
bool reflowInner;
bool reflowLegend;
--- a/layout/forms/nsFormControlFrame.cpp
+++ b/layout/forms/nsFormControlFrame.cpp
@@ -126,17 +126,17 @@ nsFormControlFrame::Reflow(nsPresContext
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
("enter nsFormControlFrame::Reflow: aMaxSize=%d,%d",
aReflowInput.AvailableWidth(), aReflowInput.AvailableHeight()));
if (mState & NS_FRAME_FIRST_REFLOW) {
RegUnRegAccessKey(static_cast<nsIFrame*>(this), true);
}
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
aDesiredSize.SetSize(aReflowInput.GetWritingMode(),
aReflowInput.ComputedSizeWithBorderPadding());
if (nsLayoutUtils::FontSizeInflationEnabled(aPresContext)) {
float inflation = nsLayoutUtils::FontSizeInflationFor(this);
aDesiredSize.Width() *= inflation;
aDesiredSize.Height() *= inflation;
}
--- a/layout/forms/nsHTMLButtonControlFrame.cpp
+++ b/layout/forms/nsHTMLButtonControlFrame.cpp
@@ -209,23 +209,23 @@ nsHTMLButtonControlFrame::Reflow(nsPresC
aReflowInput, firstKid);
if (!ShouldClipPaintingToBorderBox()) {
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, firstKid);
}
// else, we ignore child overflow -- anything that overflows beyond our
// own border-box will get clipped when painting.
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize,
aReflowInput, aStatus);
// We're always complete and we don't support overflow containers
// so we shouldn't have a next-in-flow ever.
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
MOZ_ASSERT(!GetNextInFlow());
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
void
nsHTMLButtonControlFrame::ReflowButtonContents(nsPresContext* aPresContext,
ReflowOutput& aButtonDesiredSize,
--- a/layout/forms/nsMeterFrame.cpp
+++ b/layout/forms/nsMeterFrame.cpp
@@ -123,17 +123,17 @@ nsMeterFrame::Reflow(nsPresContext*
aDesiredSize.SetSize(aReflowInput.GetWritingMode(),
aReflowInput.ComputedSizeWithBorderPadding());
aDesiredSize.SetOverflowAreasToDesiredBounds();
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, barFrame);
FinishAndStoreOverflow(&aDesiredSize);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
void
nsMeterFrame::ReflowBarFrame(nsIFrame* aBarFrame,
nsPresContext* aPresContext,
const ReflowInput& aReflowInput,
--- a/layout/forms/nsNumberControlFrame.cpp
+++ b/layout/forms/nsNumberControlFrame.cpp
@@ -237,17 +237,17 @@ nsNumberControlFrame::Reflow(nsPresConte
aDesiredSize.SetOverflowAreasToDesiredBounds();
if (outerWrapperFrame) {
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, outerWrapperFrame);
}
FinishAndStoreOverflow(&aDesiredSize);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
void
nsNumberControlFrame::SyncDisabledState()
{
EventStates eventStates = mContent->AsElement()->State();
--- a/layout/forms/nsProgressFrame.cpp
+++ b/layout/forms/nsProgressFrame.cpp
@@ -132,17 +132,17 @@ nsProgressFrame::Reflow(nsPresContext*
for (auto childFrame : PrincipalChildList()) {
ReflowChildFrame(childFrame, aPresContext, aReflowInput, aStatus);
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, childFrame);
}
FinishAndStoreOverflow(&aDesiredSize);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
void
nsProgressFrame::ReflowChildFrame(nsIFrame* aChild,
nsPresContext* aPresContext,
const ReflowInput& aReflowInput,
--- a/layout/forms/nsRangeFrame.cpp
+++ b/layout/forms/nsRangeFrame.cpp
@@ -358,17 +358,17 @@ nsRangeFrame::Reflow(nsPresContext*
nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame();
if (thumbFrame) {
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, thumbFrame);
}
FinishAndStoreOverflow(&aDesiredSize);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
void
nsRangeFrame::ReflowAnonymousContent(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput)
--- a/layout/forms/nsTextControlFrame.cpp
+++ b/layout/forms/nsTextControlFrame.cpp
@@ -536,17 +536,17 @@ nsTextControlFrame::Reflow(nsPresContext
while (kid) {
ReflowTextControlChild(kid, aPresContext, aReflowInput, aStatus, aDesiredSize);
kid = kid->GetNextSibling();
}
// take into account css properties that affect overflow handling
FinishAndStoreOverflow(&aDesiredSize);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
void
nsTextControlFrame::ReflowTextControlChild(nsIFrame* aKid,
nsPresContext* aPresContext,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus,
--- a/layout/generic/BRFrame.cpp
+++ b/layout/generic/BRFrame.cpp
@@ -154,17 +154,17 @@ BRFrame::Reflow(nsPresContext* aPresCont
breakType = StyleClear::Line;
}
aStatus.Reset();
aStatus.SetInlineLineBreakAfter(breakType);
ll->SetLineEndsInBR(true);
}
else {
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
}
aMetrics.SetSize(wm, finalSize);
aMetrics.SetOverflowAreasToDesiredBounds();
mAscent = aMetrics.BlockStartAscent();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aMetrics);
--- a/layout/generic/BlockReflowInput.cpp
+++ b/layout/generic/BlockReflowInput.cpp
@@ -99,17 +99,17 @@ BlockReflowInput::BlockReflowInput(const
MOZ_ASSERT(FloatManager(),
"Float manager should be valid when creating BlockReflowInput!");
// Save the coordinate system origin for later.
FloatManager()->GetTranslation(mFloatManagerI, mFloatManagerB);
FloatManager()->PushState(&mFloatManagerStateBefore); // never popped
- mReflowStatus = NS_FRAME_COMPLETE;
+ mReflowStatus.Reset();
mNextInFlow = static_cast<nsBlockFrame*>(mBlock->GetNextInFlow());
LAYOUT_WARN_IF_FALSE(NS_UNCONSTRAINEDSIZE != aReflowInput.ComputedISize(),
"have unconstrained width; this should only result "
"from very large sizes, not attempts at intrinsic "
"width calculation");
mContentArea.ISize(wm) = aReflowInput.ComputedISize();
--- a/layout/generic/ViewportFrame.cpp
+++ b/layout/generic/ViewportFrame.cpp
@@ -285,17 +285,17 @@ ViewportFrame::Reflow(nsPresContext*
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("ViewportFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
NS_FRAME_TRACE_REFLOW_IN("ViewportFrame::Reflow");
// Initialize OUT parameters
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
// Because |Reflow| sets ComputedBSize() on the child to our
// ComputedBSize().
AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);
// Set our size up front, since some parts of reflow depend on it
// being already set. Note that the computed height may be
// unconstrained; that's ok. Consumers should watch out for that.
--- a/layout/generic/nsAbsoluteContainingBlock.cpp
+++ b/layout/generic/nsAbsoluteContainingBlock.cpp
@@ -114,30 +114,30 @@ void
nsAbsoluteContainingBlock::Reflow(nsContainerFrame* aDelegatingFrame,
nsPresContext* aPresContext,
const ReflowInput& aReflowInput,
nsReflowStatus& aReflowStatus,
const nsRect& aContainingBlock,
AbsPosReflowFlags aFlags,
nsOverflowAreas* aOverflowAreas)
{
- nsReflowStatus reflowStatus = NS_FRAME_COMPLETE;
+ nsReflowStatus reflowStatus;
const bool reflowAll = aReflowInput.ShouldReflowAllKids();
const bool isGrid = !!(aFlags & AbsPosReflowFlags::eIsGridContainerCB);
nsIFrame* kidFrame;
nsOverflowContinuationTracker tracker(aDelegatingFrame, true);
for (kidFrame = mAbsoluteFrames.FirstChild(); kidFrame; kidFrame = kidFrame->GetNextSibling()) {
bool kidNeedsReflow = reflowAll || NS_SUBTREE_DIRTY(kidFrame) ||
FrameDependsOnContainer(kidFrame,
!!(aFlags & AbsPosReflowFlags::eCBWidthChanged),
!!(aFlags & AbsPosReflowFlags::eCBHeightChanged));
if (kidNeedsReflow && !aPresContext->HasPendingInterrupt()) {
// Reflow the frame
- nsReflowStatus kidStatus = NS_FRAME_COMPLETE;
+ nsReflowStatus kidStatus;
const nsRect& cb = isGrid ? nsGridContainerFrame::GridItemCB(kidFrame)
: aContainingBlock;
ReflowAbsoluteFrame(aDelegatingFrame, aPresContext, aReflowInput, cb,
aFlags, kidFrame, kidStatus, aOverflowAreas);
nsIFrame* nextFrame = kidFrame->GetNextInFlow();
if (!kidStatus.IsFullyComplete() &&
aDelegatingFrame->IsFrameOfType(nsIFrame::eCanContainOverflowContainers)) {
// Need a continuation
--- a/layout/generic/nsBackdropFrame.cpp
+++ b/layout/generic/nsBackdropFrame.cpp
@@ -87,10 +87,10 @@ nsBackdropFrame::Reflow(nsPresContext* a
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
// Note that this frame is a child of the viewport frame.
WritingMode wm = aReflowInput.GetWritingMode();
LogicalMargin borderPadding = aReflowInput.ComputedLogicalBorderPadding();
nscoord isize = aReflowInput.ComputedISize() + borderPadding.IStartEnd(wm);
nscoord bsize = aReflowInput.ComputedBSize() + borderPadding.BStartEnd(wm);
aDesiredSize.SetSize(wm, LogicalSize(wm, isize, bsize));
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
}
--- a/layout/generic/nsBlockFrame.cpp
+++ b/layout/generic/nsBlockFrame.cpp
@@ -1190,31 +1190,31 @@ nsBlockFrame::Reflow(nsPresContext*
static_cast<nsBlockFrame*>(FirstContinuation())->ResolveBidi();
if (RenumberList()) {
AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN);
}
// Handle paginated overflow (see nsContainerFrame.h)
nsOverflowAreas ocBounds;
- nsReflowStatus ocStatus = NS_FRAME_COMPLETE;
+ nsReflowStatus ocStatus;
if (GetPrevInFlow()) {
ReflowOverflowContainerChildren(aPresContext, *reflowInput, ocBounds, 0,
ocStatus);
}
// Now that we're done cleaning up our overflow container lists, we can
// give |state| its nsOverflowContinuationTracker.
nsOverflowContinuationTracker tracker(this, false);
state.mOverflowTracker = &tracker;
// Drain & handle pushed floats
DrainPushedFloats();
nsOverflowAreas fcBounds;
- nsReflowStatus fcStatus = NS_FRAME_COMPLETE;
+ nsReflowStatus fcStatus;
ReflowPushedFloats(state, fcBounds, fcStatus);
// If we're not dirty (which means we'll mark everything dirty later)
// and our inline-size has changed, mark the lines dirty that we need to
// mark dirty for a resize reflow.
if (!(GetStateBits() & NS_FRAME_IS_DIRTY) && reflowInput->IsIResize()) {
PrepareResizeReflow(state);
}
@@ -3453,17 +3453,17 @@ nsBlockFrame::ReflowBlockFrame(BlockRefl
if (mayNeedRetry) {
blockHtmlRI->mDiscoveredClearance = &clearanceFrame;
} else if (!applyBStartMargin) {
blockHtmlRI->mDiscoveredClearance =
aState.mReflowInput.mDiscoveredClearance;
}
- frameReflowStatus = NS_FRAME_COMPLETE;
+ frameReflowStatus.Reset();
brc.ReflowBlock(availSpace, applyBStartMargin, aState.mPrevBEndMargin,
clearance, aState.IsAdjacentWithTop(),
aLine.get(), *blockHtmlRI, frameReflowStatus, aState);
// Now the block has a height. Using that height, get the
// available space again and call ComputeBlockAvailSpace again.
// If ComputeBlockAvailSpace gives a different result, we need to
// reflow again.
@@ -6210,17 +6210,17 @@ nsBlockFrame::ReflowFloat(BlockReflowInp
LogicalMargin& aFloatMargin,
LogicalMargin& aFloatOffsets,
bool aFloatPushedDown,
nsReflowStatus& aReflowStatus)
{
NS_PRECONDITION(aFloat->GetStateBits() & NS_FRAME_OUT_OF_FLOW,
"aFloat must be an out-of-flow frame");
// Reflow the float.
- aReflowStatus = NS_FRAME_COMPLETE;
+ aReflowStatus.Reset();
WritingMode wm = aState.mReflowInput.GetWritingMode();
#ifdef NOISY_FLOAT
printf("Reflow Float %p in parent %p, availSpace(%d,%d,%d,%d)\n",
aFloat, this,
aAdjustedAvailableSpace.IStart(wm), aAdjustedAvailableSpace.BStart(wm),
aAdjustedAvailableSpace.ISize(wm), aAdjustedAvailableSpace.BSize(wm)
);
@@ -6277,29 +6277,29 @@ nsBlockFrame::ReflowFloat(BlockReflowInp
if (!aReflowStatus.IsFullyComplete() &&
ShouldAvoidBreakInside(floatRS)) {
aReflowStatus.SetInlineLineBreakBeforeAndReset();
} else if (aReflowStatus.IsIncomplete() &&
(NS_UNCONSTRAINEDSIZE == aAdjustedAvailableSpace.BSize(wm))) {
// An incomplete reflow status means we should split the float
// if the height is constrained (bug 145305).
- aReflowStatus = NS_FRAME_COMPLETE;
+ aReflowStatus.Reset();
}
if (aReflowStatus.NextInFlowNeedsReflow()) {
aState.mReflowStatus.SetNextInFlowNeedsReflow();
}
if (aFloat->GetType() == nsGkAtoms::letterFrame) {
// We never split floating first letters; an incomplete state for
// such frames simply means that there is more content to be
// reflowed on the line.
if (aReflowStatus.IsIncomplete())
- aReflowStatus = NS_FRAME_COMPLETE;
+ aReflowStatus.Reset();
}
// Capture the margin and offsets information for the caller
aFloatMargin =
// float margins don't collapse
floatRS.ComputedLogicalMargin().ConvertTo(wm, floatRS.GetWritingMode());
aFloatOffsets =
floatRS.ComputedLogicalOffsets().ConvertTo(wm, floatRS.GetWritingMode());
--- a/layout/generic/nsBulletFrame.cpp
+++ b/layout/generic/nsBulletFrame.cpp
@@ -1058,17 +1058,17 @@ nsBulletFrame::Reflow(nsPresContext* aPr
linePadding.BStart(lineWM));
// XXX this is a bit of a hack, we're assuming that no glyphs used for bullets
// overflow their font-boxes. It'll do for now; to fix it for real, we really
// should rewrite all the text-handling code here to use gfxTextRun (bug
// 397294).
aMetrics.SetOverflowAreasToDesiredBounds();
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aMetrics);
}
/* virtual */ nscoord
nsBulletFrame::GetMinISize(nsRenderingContext *aRenderingContext)
{
WritingMode wm = GetWritingMode();
ReflowOutput reflowOutput(wm);
--- a/layout/generic/nsCanvasFrame.cpp
+++ b/layout/generic/nsCanvasFrame.cpp
@@ -644,17 +644,17 @@ nsCanvasFrame::Reflow(nsPresContext*
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsCanvasFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
NS_FRAME_TRACE_REFLOW_IN("nsCanvasFrame::Reflow");
// Initialize OUT parameter
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
nsCanvasFrame* prevCanvasFrame = static_cast<nsCanvasFrame*>
(GetPrevInFlow());
if (prevCanvasFrame) {
AutoFrameListPtr overflow(aPresContext,
prevCanvasFrame->StealOverflowFrames());
if (overflow) {
NS_ASSERTION(overflow->OnlyChild(),
--- a/layout/generic/nsColumnSetFrame.cpp
+++ b/layout/generic/nsColumnSetFrame.cpp
@@ -27,18 +27,18 @@ NS_NewColumnSetFrame(nsIPresShell* aPres
nsColumnSetFrame* it = new (aPresShell) nsColumnSetFrame(aContext);
it->AddStateBits(aStateFlags | NS_BLOCK_MARGIN_ROOT);
return it;
}
NS_IMPL_FRAMEARENA_HELPERS(nsColumnSetFrame)
nsColumnSetFrame::nsColumnSetFrame(nsStyleContext* aContext)
- : nsContainerFrame(aContext), mLastBalanceBSize(NS_INTRINSICSIZE),
- mLastFrameStatus(NS_FRAME_COMPLETE)
+ : nsContainerFrame(aContext)
+ , mLastBalanceBSize(NS_INTRINSICSIZE)
{
}
nsIAtom*
nsColumnSetFrame::GetType() const
{
return nsGkAtoms::columnSetFrame;
}
@@ -1031,17 +1031,17 @@ nsColumnSetFrame::Reflow(nsPresContext*
MarkInReflow();
// Don't support interruption in columns
nsPresContext::InterruptPreventer noInterrupts(aPresContext);
DO_GLOBAL_REFLOW_COUNT("nsColumnSetFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
// Initialize OUT parameter
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
// Our children depend on our block-size if we have a fixed block-size.
if (aReflowInput.ComputedBSize() != NS_AUTOHEIGHT) {
AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);
} else {
RemoveStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);
}
@@ -1052,17 +1052,17 @@ nsColumnSetFrame::Reflow(nsPresContext*
}
nsFrameList::Enumerator eoc(GetChildList(kExcessOverflowContainersList));
for (; !eoc.AtEnd(); eoc.Next()) {
MOZ_ASSERT(!IS_TRUE_OVERFLOW_CONTAINER(eoc.get()));
}
#endif
nsOverflowAreas ocBounds;
- nsReflowStatus ocStatus = NS_FRAME_COMPLETE;
+ nsReflowStatus ocStatus;
if (GetPrevInFlow()) {
ReflowOverflowContainerChildren(aPresContext, aReflowInput, ocBounds, 0,
ocStatus);
}
//------------ Handle Incremental Reflow -----------------
// If inline size is unconstrained, set aForceAuto to true to allow
@@ -1097,17 +1097,17 @@ nsColumnSetFrame::Reflow(nsPresContext*
aDesiredSize, carriedOutBottomMargin,
unboundedLastColumn, feasible, aStatus);
}
if (aPresContext->HasPendingInterrupt() &&
aReflowInput.AvailableBSize() == NS_UNCONSTRAINEDSIZE) {
// In this situation, we might be lying about our reflow status, because
// our last kid (the one that got interrupted) was incomplete. Fix that.
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
}
NS_ASSERTION(aStatus.IsFullyComplete() ||
aReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE,
"Column set should be complete if the available block-size is unconstrained");
// Merge overflow container bounds and status.
aDesiredSize.mOverflowAreas.UnionWith(ocBounds);
--- a/layout/generic/nsFlexContainerFrame.cpp
+++ b/layout/generic/nsFlexContainerFrame.cpp
@@ -4324,17 +4324,17 @@ nsFlexContainerFrame::DoFlexLayout(nsPre
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus,
nscoord aContentBoxMainSize,
nscoord aAvailableBSizeForContent,
nsTArray<StrutInfo>& aStruts,
const FlexboxAxisTracker& aAxisTracker)
{
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
LinkedList<FlexLine> lines;
nsTArray<nsIFrame*> placeholderKids;
AutoFlexLineListClearer cleanupLines(lines);
GenerateFlexLines(aPresContext, aReflowInput,
aContentBoxMainSize,
aAvailableBSizeForContent,
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -5719,17 +5719,17 @@ void
nsFrame::Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsFrame");
aDesiredSize.ClearSize();
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
nsresult
nsFrame::CharacterDataChanged(CharacterDataChangeInfo* aInfo)
{
NS_NOTREACHED("should only be called for text frames");
return NS_OK;
@@ -9735,17 +9735,17 @@ nsFrame::DoXULLayout(nsBoxLayoutState& a
aState.GetRenderingContext(),
LogicalSize(ourWM, ISize(),
NS_UNCONSTRAINEDSIZE),
ReflowInput::DUMMY_PARENT_REFLOW_STATE);
AddStateBits(NS_FRAME_IN_REFLOW);
// Set up a |reflowStatus| to pass into ReflowAbsoluteFrames
// (just a dummy value; hopefully that's OK)
- nsReflowStatus reflowStatus = NS_FRAME_COMPLETE;
+ nsReflowStatus reflowStatus;
ReflowAbsoluteFrames(aState.PresContext(), desiredSize,
reflowInput, reflowStatus);
RemoveStateBits(NS_FRAME_IN_REFLOW);
}
nsSize oldSize(ourRect.Size());
FinishAndStoreOverflow(desiredSize.mOverflowAreas,
size.GetPhysicalSize(outerWM), &oldSize);
@@ -9772,17 +9772,17 @@ nsFrame::BoxReflow(nsBoxLayoutState&
nsAdaptorAddIndents();
printf("Reflowing: ");
nsFrame::ListTag(stdout, mFrame);
printf("\n");
gIndent2++;
#endif
nsBoxLayoutMetrics *metrics = BoxMetrics();
- nsReflowStatus status = NS_FRAME_COMPLETE;
+ nsReflowStatus status;
WritingMode wm = aDesiredSize.GetWritingMode();
bool needsReflow = NS_SUBTREE_DIRTY(this);
// if we don't need a reflow then
// lets see if we are already that size. Yes? then don't even reflow. We are done.
if (!needsReflow) {
--- a/layout/generic/nsFrameSetFrame.cpp
+++ b/layout/generic/nsFrameSetFrame.cpp
@@ -844,17 +844,17 @@ nsHTMLFramesetFrame::Reflow(nsPresContex
const nsFramesetSpec* colSpecs = nullptr;
int32_t rows = 0;
int32_t cols = 0;
ourContent->GetRowSpec(&rows, &rowSpecs);
ourContent->GetColSpec(&cols, &colSpecs);
// If the number of cols or rows has changed, the frame for the frameset
// will be re-created.
if (mNumRows != rows || mNumCols != cols) {
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
mDrag.UnSet();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
return;
}
CalculateRowCol(aPresContext, width, mNumCols, colSpecs, mColSizes.get());
CalculateRowCol(aPresContext, height, mNumRows, rowSpecs, mRowSizes.get());
@@ -1079,17 +1079,17 @@ nsHTMLFramesetFrame::Reflow(nsPresContex
mHorBorders[horX]->SetColor(childColor);
}
}
mChildFrameborder.reset();
mChildBorderColors.reset();
}
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
mDrag.UnSet();
aDesiredSize.SetOverflowAreasToDesiredBounds();
FinishAndStoreOverflow(&aDesiredSize);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
@@ -1389,17 +1389,17 @@ nsHTMLFramesetBorderFrame::Reflow(nsPres
DO_GLOBAL_REFLOW_COUNT("nsHTMLFramesetBorderFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
// Override Reflow(), since we don't want to deal with what our
// computed values are.
SizeToAvailSize(aReflowInput, aDesiredSize);
aDesiredSize.SetOverflowAreasToDesiredBounds();
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
}
class nsDisplayFramesetBorder : public nsDisplayItem {
public:
nsDisplayFramesetBorder(nsDisplayListBuilder* aBuilder,
nsHTMLFramesetBorderFrame* aFrame)
: nsDisplayItem(aBuilder, aFrame) {
MOZ_COUNT_CTOR(nsDisplayFramesetBorder);
@@ -1604,17 +1604,17 @@ nsHTMLFramesetBlankFrame::Reflow(nsPresC
{
DO_GLOBAL_REFLOW_COUNT("nsHTMLFramesetBlankFrame");
// Override Reflow(), since we don't want to deal with what our
// computed values are.
SizeToAvailSize(aReflowInput, aDesiredSize);
aDesiredSize.SetOverflowAreasToDesiredBounds();
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
}
class nsDisplayFramesetBlank : public nsDisplayItem {
public:
nsDisplayFramesetBlank(nsDisplayListBuilder* aBuilder,
nsIFrame* aFrame) :
nsDisplayItem(aBuilder, aFrame) {
MOZ_COUNT_CTOR(nsDisplayFramesetBlank);
--- a/layout/generic/nsGfxScrollFrame.cpp
+++ b/layout/generic/nsGfxScrollFrame.cpp
@@ -1101,17 +1101,17 @@ nsHTMLScrollFrame::Reflow(nsPresContext*
}
if (mHelper.mIsRoot && !oldScrolledAreaBounds.IsEqualEdges(newScrolledAreaBounds)) {
mHelper.PostScrolledAreaEvent();
}
mHelper.UpdatePrevScrolledRect();
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
mHelper.PostOverflowEvent();
}
////////////////////////////////////////////////////////////////////////////////
#ifdef DEBUG_FRAME_DUMP
--- a/layout/generic/nsGridContainerFrame.cpp
+++ b/layout/generic/nsGridContainerFrame.cpp
@@ -5316,17 +5316,17 @@ nsGridContainerFrame::ReflowInFlowChild(
nscoord
nsGridContainerFrame::ReflowInFragmentainer(GridReflowInput& aState,
const LogicalRect& aContentArea,
ReflowOutput& aDesiredSize,
nsReflowStatus& aStatus,
Fragmentainer& aFragmentainer,
const nsSize& aContainerSize)
{
- MOZ_ASSERT(aStatus == NS_FRAME_COMPLETE);
+ MOZ_ASSERT(aStatus.IsEmpty());
MOZ_ASSERT(aState.mReflowInput);
// Collect our grid items and sort them in row order. Collect placeholders
// and put them in a separate array.
nsTArray<const GridItemInfo*> sortedItems(aState.mGridItems.Length());
nsTArray<nsIFrame*> placeholders(aState.mAbsPosItems.Length());
aState.mIter.Reset(GridItemCSSOrderIterator::eIncludeAll);
for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
@@ -5392,17 +5392,17 @@ nsGridContainerFrame::ReflowInFragmentai
return aState.mFragBStart;
}
if ((itemStartRow > startRow ||
(itemStartRow == startRow && !isTopOfPage)) &&
itemStartRow < endRow) {
endRow = itemStartRow;
isForcedBreak = true;
// reset any BREAK_AFTER we found on an earlier item
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
break; // we're done since the items are sorted in row order
}
}
uint32_t itemEndRow = info->mArea.mRows.mEnd;
if (disp->mBreakAfter) {
if (itemEndRow != numRows) {
if (itemEndRow > startRow && itemEndRow < endRow) {
endRow = itemEndRow;
@@ -5669,17 +5669,17 @@ nsGridContainerFrame::ReflowRowsInFragme
i = -1; // i == 0 after the next loop increment
isRowTopOfPage = isStartRowTopOfPage;
overflowIncompleteItems.Clear();
incompleteItems.Clear();
aStatus.SetIncomplete();
continue;
}
NS_ERROR("got BREAK_BEFORE at top-of-page");
- childStatus = NS_FRAME_COMPLETE;
+ childStatus.Reset();
} else {
NS_ERROR("got BREAK_BEFORE again after growing the row?");
childStatus.SetIncomplete();
}
} else if (childStatus.IsInlineBreakAfter()) {
MOZ_ASSERT_UNREACHABLE("unexpected child reflow status");
}
@@ -5819,19 +5819,19 @@ nsGridContainerFrame::ReflowRowsInFragme
nscoord
nsGridContainerFrame::ReflowChildren(GridReflowInput& aState,
const LogicalRect& aContentArea,
ReflowOutput& aDesiredSize,
nsReflowStatus& aStatus)
{
MOZ_ASSERT(aState.mReflowInput);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
nsOverflowAreas ocBounds;
- nsReflowStatus ocStatus = NS_FRAME_COMPLETE;
+ nsReflowStatus ocStatus;
if (GetPrevInFlow()) {
ReflowOverflowContainerChildren(PresContext(), *aState.mReflowInput,
ocBounds, 0, ocStatus,
MergeSortedFrameListsFor);
}
WritingMode wm = aState.mReflowInput->GetWritingMode();
const nsSize containerSize =
--- a/layout/generic/nsHTMLCanvasFrame.cpp
+++ b/layout/generic/nsHTMLCanvasFrame.cpp
@@ -252,17 +252,17 @@ nsHTMLCanvasFrame::Reflow(nsPresContext*
DO_GLOBAL_REFLOW_COUNT("nsHTMLCanvasFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aMetrics, aStatus);
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
("enter nsHTMLCanvasFrame::Reflow: availSize=%d,%d",
aReflowInput.AvailableWidth(), aReflowInput.AvailableHeight()));
NS_PRECONDITION(mState & NS_FRAME_IN_REFLOW, "frame is not in reflow");
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
WritingMode wm = aReflowInput.GetWritingMode();
LogicalSize finalSize(wm,
aReflowInput.ComputedISize(),
aReflowInput.ComputedBSize());
// stash this away so we can compute our inner area later
mBorderPadding = aReflowInput.ComputedLogicalBorderPadding();
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -256,16 +256,27 @@ public:
bool operator==(uint32_t aRhs) const {
return mStatus == aRhs;
}
bool operator!=(uint32_t aRhs) const {
return !(*this == aRhs);
}
+ // Return true if all flags are cleared.
+ bool IsEmpty() const {
+ return (!mIncomplete &&
+ !mOverflowIncomplete &&
+ !mNextInFlowNeedsReflow &&
+ !mTruncated &&
+ !mInlineBreak &&
+ !mInlineBreakAfter &&
+ !mFirstLetterComplete);
+ }
+
// mIncomplete bit flag means the frame does not map all its content, and
// that the parent frame should create a continuing frame. If this bit
// isn't set, it means the frame does map all its content. This bit is
// mutually exclusive with mOverflowIncomplete.
//
// mOverflowIncomplete bit flag means that the frame has overflow that is
// not complete, but its own box is complete. (This happens when content
// overflows a fixed-height box.) The reflower should place and size the
@@ -364,18 +375,16 @@ private:
bool mTruncated : 1;
// Inline break status bit flags.
bool mInlineBreak : 1;
bool mInlineBreakAfter : 1;
bool mFirstLetterComplete : 1;
};
-#define NS_FRAME_COMPLETE 0 // Note: not a bit!
-
#define NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aMetrics) \
aStatus.UpdateTruncated(aReflowInput, aMetrics);
//----------------------------------------------------------------------
/**
* DidReflow status values.
*/
--- a/layout/generic/nsImageFrame.cpp
+++ b/layout/generic/nsImageFrame.cpp
@@ -954,17 +954,17 @@ nsImageFrame::Reflow(nsPresContext*
DO_GLOBAL_REFLOW_COUNT("nsImageFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aMetrics, aStatus);
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
("enter nsImageFrame::Reflow: availSize=%d,%d",
aReflowInput.AvailableWidth(), aReflowInput.AvailableHeight()));
NS_PRECONDITION(mState & NS_FRAME_IN_REFLOW, "frame is not in reflow");
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
// see if we have a frozen size (i.e. a fixed width and height)
if (HaveFixedSize(aReflowInput)) {
mState |= IMAGE_SIZECONSTRAINED;
} else {
mState &= ~IMAGE_SIZECONSTRAINED;
}
--- a/layout/generic/nsInlineFrame.cpp
+++ b/layout/generic/nsInlineFrame.cpp
@@ -569,17 +569,17 @@ nsInlineFrame::PullOverflowsFromPrevInFl
void
nsInlineFrame::ReflowFrames(nsPresContext* aPresContext,
const ReflowInput& aReflowInput,
InlineReflowInput& irs,
ReflowOutput& aMetrics,
nsReflowStatus& aStatus)
{
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
nsLineLayout* lineLayout = aReflowInput.mLineLayout;
bool inFirstLine = aReflowInput.mLineLayout->GetInFirstLine();
RestyleManager* restyleManager = aPresContext->RestyleManager();
WritingMode frameWM = aReflowInput.GetWritingMode();
WritingMode lineWM = aReflowInput.mLineLayout->mRootSpan->mWritingMode;
LogicalMargin framePadding = aReflowInput.ComputedLogicalBorderPadding();
nscoord startEdge = 0;
--- a/layout/generic/nsLeafFrame.cpp
+++ b/layout/generic/nsLeafFrame.cpp
@@ -80,17 +80,17 @@ nsLeafFrame::DoReflow(nsPresContext* aPr
"Shouldn't have unconstrained stuff here "
"thanks to ComputeAutoSize");
// XXX how should border&padding effect baseline alignment?
// => descent = borderPadding.bottom for example
WritingMode wm = aReflowInput.GetWritingMode();
aMetrics.SetSize(wm, aReflowInput.ComputedSizeWithBorderPadding());
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
("exit nsLeafFrame::DoReflow: size=%d,%d",
aMetrics.ISize(wm), aMetrics.BSize(wm)));
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aMetrics);
aMetrics.SetOverflowAreasToDesiredBounds();
}
--- a/layout/generic/nsPageContentFrame.cpp
+++ b/layout/generic/nsPageContentFrame.cpp
@@ -23,17 +23,17 @@ void
nsPageContentFrame::Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsPageContentFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
- aStatus = NS_FRAME_COMPLETE; // initialize out parameter
+ aStatus.Reset(); // initialize out parameter
if (GetPrevInFlow() && (GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
nsresult rv = aPresContext->PresShell()->FrameConstructor()
->ReplicateFixedFrames(this);
if (NS_FAILED(rv)) {
return;
}
}
@@ -88,17 +88,17 @@ nsPageContentFrame::Reflow(nsPresContext
// Place and size the child
FinishReflowChild(frame, aPresContext, aDesiredSize, &kidReflowInput, 0, 0, 0);
NS_ASSERTION(aPresContext->IsDynamic() || !aStatus.IsFullyComplete() ||
!frame->GetNextInFlow(), "bad child flow list");
}
// Reflow our fixed frames
- nsReflowStatus fixedStatus = NS_FRAME_COMPLETE;
+ nsReflowStatus fixedStatus;
ReflowAbsoluteFrames(aPresContext, aDesiredSize, aReflowInput, fixedStatus);
NS_ASSERTION(fixedStatus.IsComplete(), "fixed frames can be truncated, but not incomplete");
// Return our desired size
WritingMode wm = aReflowInput.GetWritingMode();
aDesiredSize.ISize(wm) = aReflowInput.ComputedISize();
if (aReflowInput.ComputedBSize() != NS_UNCONSTRAINEDSIZE) {
aDesiredSize.BSize(wm) = aReflowInput.ComputedBSize();
--- a/layout/generic/nsPageFrame.cpp
+++ b/layout/generic/nsPageFrame.cpp
@@ -53,17 +53,17 @@ void
nsPageFrame::Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsPageFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
- aStatus = NS_FRAME_COMPLETE; // initialize out parameter
+ aStatus.Reset(); // initialize out parameter
NS_ASSERTION(mFrames.FirstChild() &&
nsGkAtoms::pageContentFrame == mFrames.FirstChild()->GetType(),
"pageFrame must have a pageContentFrame child");
// Resize our frame allowing it only to be as big as we are
// XXX Pay attention to the page's border and padding...
if (mFrames.NotEmpty()) {
@@ -726,17 +726,17 @@ nsPageBreakFrame::Reflow(nsPresContext*
// round the height down to the nearest pixel
finalSize.BSize(wm) -=
finalSize.BSize(wm) % nsPresContext::CSSPixelsToAppUnits(1);
aDesiredSize.SetSize(wm, finalSize);
// Note: not using NS_FRAME_FIRST_REFLOW here, since it's not clear whether
// DidReflow will always get called before the next Reflow() call.
mHaveReflowed = true;
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
}
nsIAtom*
nsPageBreakFrame::GetType() const
{
return nsGkAtoms::pageBreakFrame;
}
--- a/layout/generic/nsPlaceholderFrame.cpp
+++ b/layout/generic/nsPlaceholderFrame.cpp
@@ -142,17 +142,17 @@ nsPlaceholderFrame::Reflow(nsPresContext
}
#endif
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsPlaceholderFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
aDesiredSize.ClearSize();
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
void
nsPlaceholderFrame::DestroyFrom(nsIFrame* aDestructRoot)
{
nsIFrame* oof = mOutOfFlowFrame;
if (oof) {
--- a/layout/generic/nsPluginFrame.cpp
+++ b/layout/generic/nsPluginFrame.cpp
@@ -501,23 +501,23 @@ nsPluginFrame::Reflow(nsPresContext*
GetDesiredSize(aPresContext, aReflowInput, aMetrics);
aMetrics.SetOverflowAreasToDesiredBounds();
FinishAndStoreOverflow(&aMetrics);
// delay plugin instantiation until all children have
// arrived. Otherwise there may be PARAMs or other stuff that the
// plugin needs to see that haven't arrived yet.
if (!GetContent()->IsDoneAddingChildren()) {
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
return;
}
// if we are printing or print previewing, bail for now
if (aPresContext->Medium() == nsGkAtoms::print) {
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
return;
}
nsRect r(0, 0, aMetrics.Width(), aMetrics.Height());
r.Deflate(aReflowInput.ComputedPhysicalBorderPadding());
if (mInnerView) {
nsViewManager* vm = mInnerView->GetViewManager();
@@ -526,17 +526,17 @@ nsPluginFrame::Reflow(nsPresContext*
}
FixupWindow(r.Size());
if (!mReflowCallbackPosted) {
mReflowCallbackPosted = true;
aPresContext->PresShell()->PostReflowCallback(this);
}
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aMetrics);
}
///////////// nsIReflowCallback ///////////////
bool
nsPluginFrame::ReflowFinished()
--- a/layout/generic/nsRubyBaseContainerFrame.cpp
+++ b/layout/generic/nsRubyBaseContainerFrame.cpp
@@ -302,17 +302,17 @@ struct nsRubyBaseContainerFrame::RubyRef
nsRubyBaseContainerFrame::Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsRubyBaseContainerFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
if (!aReflowInput.mLineLayout) {
NS_ASSERTION(
aReflowInput.mLineLayout,
"No line layout provided to RubyBaseContainerFrame reflow method.");
return;
}
@@ -465,41 +465,41 @@ struct MOZ_STACK_CLASS nsRubyBaseContain
nscoord
nsRubyBaseContainerFrame::ReflowColumns(const RubyReflowInput& aReflowInput,
nsReflowStatus& aStatus)
{
nsLineLayout* lineLayout = aReflowInput.mBaseReflowInput.mLineLayout;
const uint32_t rtcCount = aReflowInput.mTextContainers.Length();
nscoord icoord = lineLayout->GetCurrentICoord();
MOZ_ASSERT(icoord == 0, "border/padding of rbc should have been suppressed");
- nsReflowStatus reflowStatus = NS_FRAME_COMPLETE;
- aStatus = NS_FRAME_COMPLETE;
+ nsReflowStatus reflowStatus;
+ aStatus.Reset();
uint32_t columnIndex = 0;
RubyColumn column;
column.mTextFrames.SetCapacity(rtcCount);
RubyColumnEnumerator e(this, aReflowInput.mTextContainers);
for (; !e.AtEnd(); e.Next()) {
e.GetColumn(column);
icoord += ReflowOneColumn(aReflowInput, columnIndex, column, reflowStatus);
if (!reflowStatus.IsInlineBreakBefore()) {
columnIndex++;
}
if (reflowStatus.IsInlineBreak()) {
break;
}
// We are not handling overflow here.
- MOZ_ASSERT(reflowStatus == NS_FRAME_COMPLETE);
+ MOZ_ASSERT(reflowStatus.IsEmpty());
}
bool isComplete = false;
PullFrameState pullFrameState(this, aReflowInput.mTextContainers);
while (!reflowStatus.IsInlineBreak()) {
// We are not handling overflow here.
- MOZ_ASSERT(reflowStatus == NS_FRAME_COMPLETE);
+ MOZ_ASSERT(reflowStatus.IsEmpty());
// Try pull some frames from next continuations. This call replaces
// frames in |column| with the frame pulled in each level.
PullOneColumn(lineLayout, pullFrameState, column, isComplete);
if (isComplete) {
// No more frames can be pulled.
break;
}
--- a/layout/generic/nsRubyFrame.cpp
+++ b/layout/generic/nsRubyFrame.cpp
@@ -111,17 +111,17 @@ nsRubyFrame::Reflow(nsPresContext* aPres
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsRubyFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
if (!aReflowInput.mLineLayout) {
NS_ASSERTION(aReflowInput.mLineLayout,
"No line layout provided to RubyFrame reflow method.");
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
return;
}
// Grab overflow frames from prev-in-flow and its own.
MoveOverflowToChildList();
// Clear leadings
mLeadings.Reset();
@@ -138,29 +138,29 @@ nsRubyFrame::Reflow(nsPresContext* aPres
}
NS_ASSERTION(aReflowInput.AvailableISize() != NS_UNCONSTRAINEDSIZE,
"should no longer use available widths");
nscoord availableISize = aReflowInput.AvailableISize();
availableISize -= startEdge + borderPadding.IEnd(frameWM);
aReflowInput.mLineLayout->BeginSpan(this, &aReflowInput,
startEdge, availableISize, &mBaseline);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
for (RubySegmentEnumerator e(this); !e.AtEnd(); e.Next()) {
ReflowSegment(aPresContext, aReflowInput, e.GetBaseContainer(), aStatus);
if (aStatus.IsInlineBreak()) {
// A break occurs when reflowing the segment.
// Don't continue reflowing more segments.
break;
}
}
ContinuationTraversingState pullState(this);
- while (aStatus == NS_FRAME_COMPLETE) {
+ while (aStatus.IsEmpty()) {
nsRubyBaseContainerFrame* baseContainer =
PullOneSegment(aReflowInput.mLineLayout, pullState);
if (!baseContainer) {
// No more continuations after, finish now.
break;
}
ReflowSegment(aPresContext, aReflowInput, baseContainer, aStatus);
}
@@ -300,20 +300,20 @@ nsRubyFrame::ReflowSegment(nsPresContext
availSize.ConvertTo(rtcWM, lineWM));
// FIXME We probably shouldn't be using the same nsLineLayout for
// the text containers. But it should be fine now as we are
// not actually using this line layout to reflow something,
// but just read the writing mode from it.
textReflowInput.mLineLayout = aReflowInput.mLineLayout;
textContainer->Reflow(aPresContext, textMetrics,
textReflowInput, textReflowStatus);
- // Ruby text containers always return NS_FRAME_COMPLETE even when
+ // Ruby text containers always return complete reflow status even when
// they have continuations, because the breaking has already been
// handled when reflowing the base containers.
- NS_ASSERTION(textReflowStatus == NS_FRAME_COMPLETE,
+ NS_ASSERTION(textReflowStatus.IsEmpty(),
"Ruby text container must not break itself inside");
// The metrics is initialized with reflow state of this ruby frame,
// hence the writing-mode is tied to rubyWM instead of rtcWM.
LogicalSize size = textMetrics.Size(rubyWM).ConvertTo(lineWM, rubyWM);
textContainer->SetSize(lineWM, size);
nscoord reservedISize = RubyUtils::GetReservedISize(textContainer);
segmentISize = std::max(segmentISize, size.ISize(lineWM) + reservedISize);
--- a/layout/generic/nsRubyTextContainerFrame.cpp
+++ b/layout/generic/nsRubyTextContainerFrame.cpp
@@ -125,20 +125,20 @@ nsRubyTextContainerFrame::Reflow(nsPresC
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsRubyTextContainerFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
// Although a ruby text container may have continuations, returning
- // NS_FRAME_COMPLETE here is still safe, since its parent, ruby frame,
+ // complete reflow status is still safe, since its parent, ruby frame,
// ignores the status, and continuations of the ruby base container
// will take care of our continuations.
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
WritingMode lineWM = aReflowInput.mLineLayout->GetWritingMode();
nscoord minBCoord = nscoord_MAX;
nscoord maxBCoord = nscoord_MIN;
// The container size is not yet known, so we use a dummy (0, 0) size.
// The block-dir position will be corrected below after containerSize
// is finalized.
const nsSize dummyContainerSize;
--- a/layout/generic/nsSimplePageSequenceFrame.cpp
+++ b/layout/generic/nsSimplePageSequenceFrame.cpp
@@ -151,17 +151,17 @@ nsSimplePageSequenceFrame::Reflow(nsPres
{
MarkInReflow();
NS_PRECONDITION(aPresContext->IsRootPaginatedDocument(),
"A Page Sequence is only for real pages");
DO_GLOBAL_REFLOW_COUNT("nsSimplePageSequenceFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
NS_FRAME_TRACE_REFLOW_IN("nsSimplePageSequenceFrame::Reflow");
- aStatus = NS_FRAME_COMPLETE; // we're always complete
+ aStatus.Reset(); // we're always complete
// Don't do incremental reflow until we've taught tables how to do
// it right in paginated mode.
if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
// Return our desired size
SetDesiredSize(aDesiredSize, aReflowInput, mSize.width, mSize.height);
aDesiredSize.SetOverflowAreasToDesiredBounds();
FinishAndStoreOverflow(&aDesiredSize);
--- a/layout/generic/nsSubDocumentFrame.cpp
+++ b/layout/generic/nsSubDocumentFrame.cpp
@@ -747,17 +747,17 @@ nsSubDocumentFrame::Reflow(nsPresContext
NS_ASSERTION(aReflowInput.ComputedWidth() != NS_UNCONSTRAINEDSIZE,
"Shouldn't have unconstrained stuff here "
"thanks to the rules of reflow");
NS_ASSERTION(NS_INTRINSICSIZE != aReflowInput.ComputedHeight(),
"Shouldn't have unconstrained stuff here "
"thanks to ComputeAutoSize");
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_ASSERTION(mContent->GetPrimaryFrame() == this,
"Shouldn't happen");
// XUL <iframe> or <browser>, or HTML <iframe>, <object> or <embed>
aDesiredSize.SetSize(aReflowInput.GetWritingMode(),
aReflowInput.ComputedSizeWithBorderPadding());
--- a/layout/generic/nsTextFrame.cpp
+++ b/layout/generic/nsTextFrame.cpp
@@ -8979,17 +8979,17 @@ nsTextFrame::Reflow(nsPresContext*
DO_GLOBAL_REFLOW_COUNT("nsTextFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aMetrics, aStatus);
// XXX If there's no line layout, we shouldn't even have created this
// frame. This may happen if, for example, this is text inside a table
// but not inside a cell. For now, just don't reflow.
if (!aReflowInput.mLineLayout) {
ClearMetrics(aMetrics);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
return;
}
ReflowText(*aReflowInput.mLineLayout, aReflowInput.AvailableWidth(),
aReflowInput.mRenderingContext->GetDrawTarget(), aMetrics, aStatus);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aMetrics);
}
@@ -9055,17 +9055,17 @@ nsTextFrame::ReflowText(nsLineLayout& aL
// so that when doing reflow our styles prevail over any part of the
// textrun we look at. Note that next-in-flows may be mapping the same
// content; gfxTextRun construction logic will ensure that we take priority.
int32_t maxContentLength = GetInFlowContentLength();
// We don't need to reflow if there is no content.
if (!maxContentLength) {
ClearMetrics(aMetrics);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
return;
}
#ifdef NOISY_BIDI
printf("Reflowed textframe\n");
#endif
const nsStyleText* textStyle = StyleText();
@@ -9212,17 +9212,17 @@ nsTextFrame::ReflowText(nsLineLayout& aL
ClearTextRuns();
iter = EnsureTextRun(nsTextFrame::eInflated, aDrawTarget,
lineContainer, aLineLayout.GetLine(),
&flowEndInTextRun);
}
if (!mTextRun) {
ClearMetrics(aMetrics);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
return;
}
NS_ASSERTION(gfxSkipCharsIterator(iter).ConvertOriginalToSkipped(offset + length)
<= mTextRun->GetLength(),
"Text run does not map enough text for our reflow");
/////////////////////////////////////////////////////////////////////
--- a/layout/generic/nsVideoFrame.cpp
+++ b/layout/generic/nsVideoFrame.cpp
@@ -291,17 +291,17 @@ nsVideoFrame::Reflow(nsPresContext* aPre
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aMetrics, aStatus);
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
("enter nsVideoFrame::Reflow: availSize=%d,%d",
aReflowInput.AvailableWidth(),
aReflowInput.AvailableHeight()));
NS_PRECONDITION(mState & NS_FRAME_IN_REFLOW, "frame is not in reflow");
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
const WritingMode myWM = aReflowInput.GetWritingMode();
nscoord contentBoxBSize = aReflowInput.ComputedBSize();
const nscoord borderBoxISize = aReflowInput.ComputedISize() +
aReflowInput.ComputedLogicalBorderPadding().IStartEnd(myWM);
const bool isBSizeShrinkWrapping = (contentBoxBSize == NS_INTRINSICSIZE);
nscoord borderBoxBSize;
--- a/layout/mathml/nsMathMLContainerFrame.cpp
+++ b/layout/mathml/nsMathMLContainerFrame.cpp
@@ -945,17 +945,17 @@ nsMathMLContainerFrame::Reflow(nsPresCon
childFrame = childFrame->GetNextSibling();
}
}
/////////////
// Place children now by re-adjusting the origins to align the baselines
FinalizeReflow(drawTarget, aDesiredSize);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
static nscoord AddInterFrameSpacingToSize(ReflowOutput& aDesiredSize,
nsMathMLContainerFrame* aFrame);
/* virtual */ void
nsMathMLContainerFrame::MarkIntrinsicISizesDirty()
--- a/layout/mathml/nsMathMLSelectedFrame.cpp
+++ b/layout/mathml/nsMathMLSelectedFrame.cpp
@@ -135,17 +135,17 @@ nsMathMLSelectedFrame::ComputeSize(nsRen
void
nsMathMLSelectedFrame::Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus)
{
MarkInReflow();
mPresentationData.flags &= ~NS_MATHML_ERROR;
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
aDesiredSize.ClearSize();
aDesiredSize.SetBlockStartAscent(0);
mBoundingMetrics = nsBoundingMetrics();
nsIFrame* childFrame = GetSelectedFrame();
if (childFrame) {
WritingMode wm = childFrame->GetWritingMode();
LogicalSize availSize = aReflowInput.ComputedSize(wm);
availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
--- a/layout/mathml/nsMathMLTokenFrame.cpp
+++ b/layout/mathml/nsMathMLTokenFrame.cpp
@@ -147,17 +147,17 @@ nsMathMLTokenFrame::Reflow(nsPresContext
//NS_ASSERTION(aStatus.IsComplete(), "bad status");
SaveReflowAndBoundingMetricsFor(childFrame, childDesiredSize,
childDesiredSize.mBoundingMetrics);
}
// place and size children
FinalizeReflow(aReflowInput.mRenderingContext->GetDrawTarget(), aDesiredSize);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
// For token elements, mBoundingMetrics is computed at the ReflowToken
// pass, it is not computed here because our children may be text frames
// that do not implement the GetBoundingMetrics() interface.
/* virtual */ nsresult
nsMathMLTokenFrame::Place(DrawTarget* aDrawTarget,
--- a/layout/mathml/nsMathMLmfencedFrame.cpp
+++ b/layout/mathml/nsMathMLmfencedFrame.cpp
@@ -441,17 +441,17 @@ nsMathMLmfencedFrame::Reflow(nsPresConte
FixInterFrameSpacing(aDesiredSize);
// Finished with these:
ClearSavedChildMetrics();
// Set our overflow area
GatherAndStoreOverflow(&aDesiredSize);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
static void
GetCharSpacing(nsMathMLChar* aMathMLChar,
nsOperatorFlags aForm,
int32_t aScriptLevel,
nscoord em,
--- a/layout/mathml/nsMathMLmrootFrame.cpp
+++ b/layout/mathml/nsMathMLmrootFrame.cpp
@@ -211,17 +211,17 @@ nsMathMLmrootFrame::Reflow(nsPresContext
}
count++;
childFrame = childFrame->GetNextSibling();
}
if (2 != count) {
// report an error, encourage people to get their markups in order
ReportChildCountError();
ReflowError(drawTarget, aDesiredSize);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
// Call DidReflow() for the child frames we successfully did reflow.
DidReflowChildren(mFrames.FirstChild(), childFrame);
return;
}
////////////
// Prepare the radical symbol and the overline bar
@@ -349,17 +349,17 @@ nsMathMLmrootFrame::Reflow(nsPresContext
dy = aDesiredSize.BlockStartAscent() - baseSize.BlockStartAscent();
FinishReflowChild(baseFrame, aPresContext, baseSize, nullptr,
MirrorIfRTL(aDesiredSize.Width(), baseSize.Width(), dx),
dy, 0);
mReference.x = 0;
mReference.y = aDesiredSize.BlockStartAscent();
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
/* virtual */ void
nsMathMLmrootFrame::GetIntrinsicISizeMetrics(nsRenderingContext* aRenderingContext, ReflowOutput& aDesiredSize)
{
nsIFrame* baseFrame = mFrames.FirstChild();
nsIFrame* indexFrame = nullptr;
--- a/layout/mathml/nsMathMLmspaceFrame.cpp
+++ b/layout/mathml/nsMathMLmspaceFrame.cpp
@@ -110,17 +110,17 @@ nsMathMLmspaceFrame::Reflow(nsPresContex
mBoundingMetrics.rightBearing = mBoundingMetrics.width;
aDesiredSize.SetBlockStartAscent(mHeight);
aDesiredSize.Width() = std::max(0, mBoundingMetrics.width);
aDesiredSize.Height() = aDesiredSize.BlockStartAscent() + mDepth;
// Also return our bounding metrics
aDesiredSize.mBoundingMetrics = mBoundingMetrics;
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
/* virtual */ nsresult
nsMathMLmspaceFrame::MeasureForWidth(DrawTarget* aDrawTarget,
ReflowOutput& aDesiredSize)
{
ProcessAttributes(PresContext());
--- a/layout/svg/nsSVGForeignObjectFrame.cpp
+++ b/layout/svg/nsSVGForeignObjectFrame.cpp
@@ -153,17 +153,17 @@ nsSVGForeignObjectFrame::Reflow(nsPresCo
DoReflow();
WritingMode wm = aReflowInput.GetWritingMode();
LogicalSize finalSize(wm, aReflowInput.ComputedISize(),
aReflowInput.ComputedBSize());
aDesiredSize.SetSize(wm, finalSize);
aDesiredSize.SetOverflowAreasToDesiredBounds();
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
}
void
nsSVGForeignObjectFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists)
{
if (!static_cast<const nsSVGElement*>(mContent)->HasValidDimensions()) {
--- a/layout/svg/nsSVGOuterSVGFrame.cpp
+++ b/layout/svg/nsSVGOuterSVGFrame.cpp
@@ -364,17 +364,17 @@ nsSVGOuterSVGFrame::Reflow(nsPresContext
DO_GLOBAL_REFLOW_COUNT("nsSVGOuterSVGFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
("enter nsSVGOuterSVGFrame::Reflow: availSize=%d,%d",
aReflowInput.AvailableWidth(), aReflowInput.AvailableHeight()));
NS_PRECONDITION(mState & NS_FRAME_IN_REFLOW, "frame is not in reflow");
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
aDesiredSize.Width() = aReflowInput.ComputedWidth() +
aReflowInput.ComputedPhysicalBorderPadding().LeftRight();
aDesiredSize.Height() = aReflowInput.ComputedHeight() +
aReflowInput.ComputedPhysicalBorderPadding().TopBottom();
NS_ASSERTION(!GetPrevInFlow(), "SVG can't currently be broken across pages.");
--- a/layout/tables/nsTableCellFrame.cpp
+++ b/layout/tables/nsTableCellFrame.cpp
@@ -871,17 +871,17 @@ nsTableCellFrame::Reflow(nsPresContext*
if (aReflowInput.mFlags.mSpecialBSizeReflow) {
FirstInFlow()->AddStateBits(NS_TABLE_CELL_HAD_SPECIAL_REFLOW);
}
// see if a special bsize reflow needs to occur due to having a pct height
nsTableFrame::CheckRequestSpecialBSizeReflow(aReflowInput);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
WritingMode wm = aReflowInput.GetWritingMode();
LogicalSize availSize(wm, aReflowInput.AvailableISize(),
aReflowInput.AvailableBSize());
LogicalMargin borderPadding = aReflowInput.ComputedLogicalPadding();
LogicalMargin border = GetBorderWidth(wm);
borderPadding += border;
--- a/layout/tables/nsTableColFrame.cpp
+++ b/layout/tables/nsTableColFrame.cpp
@@ -113,17 +113,17 @@ nsTableColFrame::Reflow(nsPresContext*
DO_GLOBAL_REFLOW_COUNT("nsTableColFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
aDesiredSize.ClearSize();
const nsStyleVisibility* colVis = StyleVisibility();
bool collapseCol = (NS_STYLE_VISIBILITY_COLLAPSE == colVis->mVisible);
if (collapseCol) {
GetTableFrame()->SetNeedToCollapse(true);
}
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
int32_t nsTableColFrame::GetSpan()
{
return StyleTable()->mSpan;
}
--- a/layout/tables/nsTableColGroupFrame.cpp
+++ b/layout/tables/nsTableColGroupFrame.cpp
@@ -374,17 +374,17 @@ nsTableColGroupFrame::Reflow(nsPresConte
LogicalSize(kidFrame->GetWritingMode()));
nsReflowStatus status;
ReflowChild(kidFrame, aPresContext, kidSize, kidReflowInput, 0, 0, 0, status);
FinishReflowChild(kidFrame, aPresContext, kidSize, nullptr, 0, 0, 0);
}
aDesiredSize.ClearSize();
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
nsTableColFrame * nsTableColGroupFrame::GetFirstColumn()
{
return GetNextColumn(nullptr);
}
--- a/layout/tables/nsTableFrame.cpp
+++ b/layout/tables/nsTableFrame.cpp
@@ -1839,17 +1839,17 @@ nsTableFrame::Reflow(nsPresContext*
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsTableFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
bool isPaginated = aPresContext->IsPaginated();
WritingMode wm = aReflowInput.GetWritingMode();
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
if (!GetPrevInFlow() && !mTableLayoutStrategy) {
NS_ERROR("strategy should have been created in Init");
return;
}
// see if collapsing borders need to be calculated
if (!GetPrevInFlow() && IsBorderCollapse() && NeedToCalcBCBorders()) {
CalcBCBorders();
@@ -2042,17 +2042,17 @@ nsTableFrame::FixupPositionedTableParts(
// chain of parent reflow states. It also doesn't necessarily have a
// correct containing block.
WritingMode wm = positionedPart->GetWritingMode();
LogicalSize availSize(wm, size);
availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
ReflowInput reflowInput(aPresContext, positionedPart,
aReflowInput.mRenderingContext, availSize,
ReflowInput::DUMMY_PARENT_REFLOW_STATE);
- nsReflowStatus reflowStatus = NS_FRAME_COMPLETE;
+ nsReflowStatus reflowStatus;
// Reflow absolutely-positioned descendants of the positioned part.
// FIXME: Unconditionally using NS_UNCONSTRAINEDSIZE for the bsize and
// ignoring any change to the reflow status aren't correct. We'll never
// paginate absolutely positioned frames.
nsFrame* positionedFrame = static_cast<nsFrame*>(positionedPart);
positionedFrame->FinishReflowWithAbsoluteFrames(PresContext(),
desiredSize,
@@ -3017,17 +3017,17 @@ nsTableFrame::PlaceRepeatedFooter(TableR
// Reflow the children based on the avail size and reason in aReflowInput
void
nsTableFrame::ReflowChildren(TableReflowInput& aReflowInput,
nsReflowStatus& aStatus,
nsIFrame*& aLastChildReflowed,
nsOverflowAreas& aOverflowAreas)
{
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
aLastChildReflowed = nullptr;
nsIFrame* prevKidFrame = nullptr;
WritingMode wm = aReflowInput.reflowInput.GetWritingMode();
NS_WARNING_ASSERTION(
wm.IsVertical() ||
NS_UNCONSTRAINEDSIZE != aReflowInput.reflowInput.ComputedWidth(),
"shouldn't have unconstrained width in horizontal mode");
--- a/layout/tables/nsTableRowFrame.cpp
+++ b/layout/tables/nsTableRowFrame.cpp
@@ -798,17 +798,17 @@ nscoord CalcBSizeFromUnpaginatedBSize(ns
void
nsTableRowFrame::ReflowChildren(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsTableFrame& aTableFrame,
nsReflowStatus& aStatus)
{
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
// XXXldb Should we be checking constrained bsize instead?
const bool isPaginated = aPresContext->IsPaginated();
const bool borderCollapse = aTableFrame.IsBorderCollapse();
int32_t cellColSpan = 1; // must be defined here so it's set properly for non-cell kids
// remember the col index of the previous cell to handle rowspans into this row
--- a/layout/tables/nsTableRowGroupFrame.cpp
+++ b/layout/tables/nsTableRowGroupFrame.cpp
@@ -1251,17 +1251,17 @@ nsTableRowGroupFrame::SplitRowGroup(nsPr
lastRowThisPage = prevRowFrame;
isTopOfPage = (lastRowThisPage == firstRowThisPage) && aReflowInput.mFlags.mIsTopOfPage;
aStatus.Reset();
aStatus.SetIncomplete();
}
else {
// We can't push children, so let our parent reflow us again with more space
aDesiredSize.Height() = rowRect.YMost();
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
break;
}
}
// reflow the cells with rowspan >1 that occur on the page
nsTableRowFrame* firstTruncatedRow;
nscoord bMost;
SplitSpanningCells(*aPresContext, aReflowInput, *aTableFrame, *firstRowThisPage,
@@ -1271,17 +1271,17 @@ nsTableRowGroupFrame::SplitRowGroup(nsPr
// A rowspan >1 cell did not fit (and could not split) in the space we gave it
if (firstTruncatedRow == firstRowThisPage) {
if (aReflowInput.mFlags.mIsTopOfPage) {
NS_WARNING("data loss in a row spanned cell");
}
else {
// We can't push children, so let our parent reflow us again with more space
aDesiredSize.Height() = rowRect.YMost();
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
UndoContinuedRow(aPresContext, contRow);
contRow = nullptr;
}
}
else { // (firstTruncatedRow != firstRowThisPage)
// Try to put firstTruncateRow on the next page
nsTableRowFrame* rowBefore = ::GetRowBefore(*firstRowThisPage, *firstTruncatedRow);
nscoord oldSpanningRowBottom = spanningRowBottom;
@@ -1308,17 +1308,17 @@ nsTableRowGroupFrame::SplitRowGroup(nsPr
SplitSpanningCells(*aPresContext, aReflowInput, *aTableFrame, *firstRowThisPage,
*lastRowThisPage, aReflowInput.mFlags.mIsTopOfPage, spanningRowBottom, contRow,
firstTruncatedRow, aDesiredSize.Height());
NS_WARNING("data loss in a row spanned cell");
}
else {
// Let our parent reflow us again with more space
aDesiredSize.Height() = rowRect.YMost();
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
UndoContinuedRow(aPresContext, contRow);
contRow = nullptr;
}
}
} // if (firstTruncatedRow == firstRowThisPage)
} // if (firstTruncatedRow)
else {
aDesiredSize.Height() = std::max(aDesiredSize.Height(), bMost);
@@ -1363,17 +1363,17 @@ nsTableRowGroupFrame::Reflow(nsPresConte
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsTableRowGroupFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
// Row geometry may be going to change so we need to invalidate any row cursor.
ClearRowCursor();
// see if a special bsize reflow needs to occur due to having a pct bsize
nsTableFrame::CheckRequestSpecialBSizeReflow(aReflowInput);
nsTableFrame* tableFrame = GetTableFrame();
--- a/layout/tables/nsTableWrapperFrame.cpp
+++ b/layout/tables/nsTableWrapperFrame.cpp
@@ -850,17 +850,17 @@ nsTableWrapperFrame::Reflow(nsPresContex
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsTableWrapperFrame");
DISPLAY_REFLOW(aPresContext, this, aOuterRI, aDesiredSize, aStatus);
// Initialize out parameters
aDesiredSize.ClearSize();
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
if (!HasAnyStateBits(NS_FRAME_FIRST_REFLOW)) {
// Set up our kids. They're already present, on an overflow list,
// or there are none so we'll create them now
MoveOverflowToChildList();
}
Maybe<ReflowInput> captionRI;
--- a/layout/xul/nsBoxFrame.cpp
+++ b/layout/xul/nsBoxFrame.cpp
@@ -653,17 +653,17 @@ nsBoxFrame::Reflow(nsPresContext*
printSize("AH", aReflowInput.AvailableHeight());
printSize("CW", aReflowInput.ComputedWidth());
printSize("CH", aReflowInput.ComputedHeight());
printf(" *\n");
#endif
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
// create the layout state
nsBoxLayoutState state(aPresContext, aReflowInput.mRenderingContext,
&aReflowInput, aReflowInput.mReflowDepth);
WritingMode wm = aReflowInput.GetWritingMode();
LogicalSize computedSize(wm, aReflowInput.ComputedISize(),
aReflowInput.ComputedBSize());
@@ -939,17 +939,17 @@ nsBoxFrame::DoXULLayout(nsBoxLayoutState
ascent = GetXULBoxAscent(aState);
}
desiredSize.SetBlockStartAscent(ascent);
desiredSize.mOverflowAreas = GetOverflowAreas();
AddStateBits(NS_FRAME_IN_REFLOW);
// Set up a |reflowStatus| to pass into ReflowAbsoluteFrames
// (just a dummy value; hopefully that's OK)
- nsReflowStatus reflowStatus = NS_FRAME_COMPLETE;
+ nsReflowStatus reflowStatus;
ReflowAbsoluteFrames(aState.PresContext(), desiredSize,
reflowInput, reflowStatus);
RemoveStateBits(NS_FRAME_IN_REFLOW);
}
return rv;
}
--- a/layout/xul/nsLeafBoxFrame.cpp
+++ b/layout/xul/nsLeafBoxFrame.cpp
@@ -230,17 +230,17 @@ nsLeafBoxFrame::Reflow(nsPresContext*
printSize("AH", aReflowInput.AvailableHeight());
printSize("CW", aReflowInput.ComputedWidth());
printSize("CH", aReflowInput.ComputedHeight());
printf(" *\n");
#endif
- aStatus = NS_FRAME_COMPLETE;
+ aStatus.Reset();
// create the layout state
nsBoxLayoutState state(aPresContext, aReflowInput.mRenderingContext);
nsSize computedSize(aReflowInput.ComputedWidth(),aReflowInput.ComputedHeight());
nsMargin m;
m = aReflowInput.ComputedPhysicalBorderPadding();