Bug 775624 Part 7 - Remove NS_FRAME_SET_INCOMPLETE. r?dholbert
This patch is written by the help of the following script.
function rename() {
find layout\
-type f\
\( -name "*.cpp" -or\
-name "*.h" \)\
-exec sed -i -r "s/$1/$2/g" "{}" \;
}
rename "NS_FRAME_SET_INCOMPLETE\(\*([a-zA-Z0-9.*]*)\)" "\1->SetIncomplete()"
rename "NS_FRAME_SET_INCOMPLETE\(([a-zA-Z0-9.*]*)\)" "\1.SetIncomplete()"
MozReview-Commit-ID: GOd4y2N6dcz
--- a/layout/generic/nsBlockFrame.cpp
+++ b/layout/generic/nsBlockFrame.cpp
@@ -1264,17 +1264,17 @@ nsBlockFrame::Reflow(nsPresContext*
NS_MergeReflowStatusInto(&state.mReflowStatus, ocStatus);
NS_MergeReflowStatusInto(&state.mReflowStatus, fcStatus);
// If we end in a BR with clear and affected floats continue,
// we need to continue, too.
if (NS_UNCONSTRAINEDSIZE != reflowInput->AvailableBSize() &&
state.mReflowStatus.IsComplete() &&
state.FloatManager()->ClearContinues(FindTrailingClear())) {
- NS_FRAME_SET_INCOMPLETE(state.mReflowStatus);
+ state.mReflowStatus.SetIncomplete();
}
if (!state.mReflowStatus.IsFullyComplete()) {
if (HasOverflowLines() || HasPushedFloats()) {
state.mReflowStatus |= NS_FRAME_REFLOW_NEXTINFLOW;
}
#ifdef DEBUG_kipp
@@ -2573,17 +2573,17 @@ nsBlockFrame::ReflowDirtyLines(BlockRefl
}
}
if (skipPull && aState.mNextInFlow) {
NS_ASSERTION(heightConstrained, "Height should be constrained here\n");
if (IS_TRUE_OVERFLOW_CONTAINER(aState.mNextInFlow))
NS_FRAME_SET_OVERFLOW_INCOMPLETE(aState.mReflowStatus);
else
- NS_FRAME_SET_INCOMPLETE(aState.mReflowStatus);
+ aState.mReflowStatus.SetIncomplete();
}
if (!skipPull && aState.mNextInFlow) {
// Pull data from a next-in-flow if there's still room for more
// content here.
while (keepGoing && aState.mNextInFlow) {
// Grab first line from our next-in-flow
nsBlockFrame* nextInFlow = aState.mNextInFlow;
@@ -2650,17 +2650,17 @@ nsBlockFrame::ReflowDirtyLines(BlockRefl
// line to be created; see SplitLine's callers for examples of
// when this happens).
while (line != LinesEnd()) {
ReflowLine(aState, line, &keepGoing);
if (aState.mReflowInput.WillReflowAgainForClearance()) {
line->MarkDirty();
keepGoing = false;
- NS_FRAME_SET_INCOMPLETE(aState.mReflowStatus);
+ aState.mReflowStatus.SetIncomplete();
break;
}
DumpLine(aState, line, deltaBCoord, -1);
if (!keepGoing) {
if (0 == line->GetChildCount()) {
DeleteLine(aState, line, line_end);
}
@@ -3402,17 +3402,17 @@ nsBlockFrame::ReflowBlockFrame(BlockRefl
// constrained block size to turn into an unconstrained one.
aState.mBCoord = startingBCoord;
aState.mPrevBEndMargin = incomingMargin;
*aKeepReflowGoing = false;
if (ShouldAvoidBreakInside(aState.mReflowInput)) {
aState.mReflowStatus = NS_INLINE_LINE_BREAK_BEFORE();
} else {
PushLines(aState, aLine.prev());
- NS_FRAME_SET_INCOMPLETE(aState.mReflowStatus);
+ aState.mReflowStatus.SetIncomplete();
}
return;
}
// Now put the block-dir coordinate back to the start of the
// block-start-margin + clearance.
aState.mBCoord -= bStartMargin;
availSpace.BStart(wm) -= bStartMargin;
@@ -3579,17 +3579,17 @@ nsBlockFrame::ReflowBlockFrame(BlockRefl
if (NS_INLINE_IS_BREAK_BEFORE(frameReflowStatus)) {
// None of the child block fits.
*aKeepReflowGoing = false;
if (ShouldAvoidBreakInside(aState.mReflowInput)) {
aState.mReflowStatus = NS_INLINE_LINE_BREAK_BEFORE();
} else {
PushLines(aState, aLine.prev());
- NS_FRAME_SET_INCOMPLETE(aState.mReflowStatus);
+ aState.mReflowStatus.SetIncomplete();
}
}
else {
// Note: line-break-after a block is a nop
// Try to place the child block.
// Don't force the block to fit if we have positive clearance, because
// pushing it to the next page would give it more room.
@@ -3655,17 +3655,17 @@ nsBlockFrame::ReflowBlockFrame(BlockRefl
// Push continuation to a new line, but only if we actually made one.
if (madeContinuation) {
nsLineBox* line = NewLineBox(nextFrame, true);
mLines.after_insert(aLine, line);
}
PushLines(aState, aLine);
- NS_FRAME_SET_INCOMPLETE(aState.mReflowStatus);
+ aState.mReflowStatus.SetIncomplete();
// If we need to reflow the continuation of the block child,
// then we'd better reflow our continuation
if (frameReflowStatus & NS_FRAME_REFLOW_NEXTINFLOW) {
aState.mReflowStatus |= NS_FRAME_REFLOW_NEXTINFLOW;
// We also need to make that continuation's line dirty so
// it gets reflowed when we reflow our next in flow. The
// nif's line must always be either a line of the nif's
@@ -3755,17 +3755,17 @@ nsBlockFrame::ReflowBlockFrame(BlockRefl
// If it's our very first line *or* we're not at the top of the page
// and we have page-break-inside:avoid, then we need to be pushed to
// our parent's next-in-flow.
aState.mReflowStatus = NS_INLINE_LINE_BREAK_BEFORE();
} else {
// Push the line that didn't fit and any lines that follow it
// to our next-in-flow.
PushLines(aState, aLine.prev());
- NS_FRAME_SET_INCOMPLETE(aState.mReflowStatus);
+ aState.mReflowStatus.SetIncomplete();
}
}
}
break; // out of the reflow retry loop
}
// Now that we've got its final position all figured out, position any child
// views it may have. Note that the case when frame has a view got handled
@@ -3858,17 +3858,17 @@ nsBlockFrame::ReflowInlineFrames(BlockRe
void
nsBlockFrame::PushTruncatedLine(BlockReflowInput& aState,
LineIterator aLine,
bool* aKeepReflowGoing)
{
PushLines(aState, aLine.prev());
*aKeepReflowGoing = false;
- NS_FRAME_SET_INCOMPLETE(aState.mReflowStatus);
+ aState.mReflowStatus.SetIncomplete();
}
void
nsBlockFrame::DoReflowInlineFrames(BlockReflowInput& aState,
nsLineLayout& aLineLayout,
LineIterator aLine,
nsFlowAreaRect& aFloatAvailableSpace,
nscoord& aAvailableSpaceBSize,
@@ -7426,17 +7426,17 @@ nsBlockFrame::ComputeFinalBSize(const Re
}
// We don't fit and we consumed some of the computed height,
// so we should consume all the available height and then
// break. If our bottom border/padding straddles the break
// point, then this will increase our height and push the
// border/padding to the next page/column.
aFinalSize.BSize(wm) = std::max(aReflowInput.AvailableBSize(),
aContentBSize);
- NS_FRAME_SET_INCOMPLETE(*aStatus);
+ aStatus->SetIncomplete();
if (!GetNextInFlow())
*aStatus |= NS_FRAME_REFLOW_NEXTINFLOW;
}
}
}
nsresult
nsBlockFrame::ResolveBidi()
--- a/layout/generic/nsFlexContainerFrame.cpp
+++ b/layout/generic/nsFlexContainerFrame.cpp
@@ -3898,17 +3898,17 @@ ResolveFlexContainerMainSize(const Reflo
// Fragmenting *and* our fixed BSize is larger than available BSize:
// Mark incomplete so we get a next-in-flow, and take up all of the
// available BSize (or the amount of BSize required by our children, if
// that's larger; but of course not more than our own computed BSize).
// XXXdholbert For now, we don't support pushing children to our next
// continuation or splitting children, so "amount of BSize required by
// our children" is just the main-size (BSize) of our longest flex line.
- NS_FRAME_SET_INCOMPLETE(aStatus);
+ aStatus.SetIncomplete();
nscoord largestLineOuterSize = GetLargestLineMainSize(aFirstLine);
if (largestLineOuterSize <= aAvailableBSizeForContent) {
return aAvailableBSizeForContent;
}
return std::min(aTentativeMainSize, largestLineOuterSize);
}
@@ -3958,17 +3958,17 @@ nsFlexContainerFrame::ComputeCrossSize(c
// Fragmenting *and* our fixed BSize is too tall for available BSize:
// Mark incomplete so we get a next-in-flow, and take up all of the
// available BSize (or the amount of BSize required by our children, if
// that's larger; but of course not more than our own computed BSize).
// XXXdholbert For now, we don't support pushing children to our next
// continuation or splitting children, so "amount of BSize required by
// our children" is just the sum of our FlexLines' BSizes (cross sizes).
- NS_FRAME_SET_INCOMPLETE(aStatus);
+ aStatus.SetIncomplete();
if (aSumLineCrossSizes <= aAvailableBSizeForContent) {
return aAvailableBSizeForContent;
}
return std::min(effectiveComputedBSize, aSumLineCrossSizes);
}
// Row-oriented case (cross axis is block axis), with auto BSize:
// Shrink-wrap our line(s), subject to our min-size / max-size
@@ -4633,17 +4633,17 @@ nsFlexContainerFrame::DoFlexLayout(nsPre
if (aReflowInput.AvailableBSize() == NS_UNCONSTRAINEDSIZE ||
desiredSizeInFlexWM.BSize(flexWM) == 0 ||
desiredBSizeWithBEndBP <= aReflowInput.AvailableBSize() ||
aReflowInput.ComputedBSize() == NS_INTRINSICSIZE) {
// Update desired height to include block-end border/padding
desiredSizeInFlexWM.BSize(flexWM) = desiredBSizeWithBEndBP;
} else {
// We couldn't fit bottom border/padding, so we'll need a continuation.
- NS_FRAME_SET_INCOMPLETE(aStatus);
+ aStatus.SetIncomplete();
}
}
// Calculate the container baselines so that our parent can baseline-align us.
mBaselineFromLastReflow = flexContainerAscent;
mLastBaselineFromLastReflow = lines.getLast()->GetLastBaselineOffset();
if (mLastBaselineFromLastReflow == nscoord_MIN) {
// XXX we fall back to a mirrored first baseline here for now, but this
--- a/layout/generic/nsGridContainerFrame.cpp
+++ b/layout/generic/nsGridContainerFrame.cpp
@@ -95,22 +95,22 @@ ClampToCSSMaxBSize(nscoord aSize, const
static nscoord
ClampToCSSMaxBSize(nscoord aSize, const ReflowInput* aReflowInput,
nsReflowStatus* aStatus)
{
auto maxSize = aReflowInput->ComputedMaxBSize();
if (MOZ_UNLIKELY(maxSize != NS_UNCONSTRAINEDSIZE)) {
MOZ_ASSERT(aReflowInput->ComputedMinBSize() <= maxSize);
if (aSize < maxSize) {
- NS_FRAME_SET_INCOMPLETE(*aStatus);
+ aStatus->SetIncomplete();
} else {
aSize = maxSize;
}
} else {
- NS_FRAME_SET_INCOMPLETE(*aStatus);
+ aStatus->SetIncomplete();
}
return aSize;
}
static bool
IsPercentOfIndefiniteSize(const nsStyleCoord& aCoord, nscoord aPercentBasis)
{
return aPercentBasis == NS_UNCONSTRAINEDSIZE && aCoord.HasPercent();
@@ -5480,31 +5480,31 @@ nsGridContainerFrame::ReflowInFragmentai
// Fill the fragmentainer, but not more than our desired block-size and
// at least to the size of the last row (even if that overflows).
nscoord newBSize = std::min(bSize, availableSize);
newBSize = std::max(newBSize, bEndRow);
// If it's just the border+padding that is overflowing and we have
// box-decoration-break:clone then we are technically COMPLETE. There's
// no point in creating another zero-bsize fragment in this case.
if (newBSize < bSize || !isBDBClone) {
- NS_FRAME_SET_INCOMPLETE(aStatus);
+ aStatus.SetIncomplete();
}
bSize = newBSize;
} else if (bSize <= bEndRow && startRow + 1 < endRow) {
if (endRow == numRows) {
// We have more than one row in this fragment, so we can break before
// the last row instead.
--endRow;
bEndRow = aState.mRows.GridLineEdge(endRow, GridLineSide::eBeforeGridGap);
bSize = bEndRow;
if (aFragmentainer.mIsAutoBSize) {
bSize = ClampToCSSMaxBSize(bSize, aState.mReflowInput);
}
}
- NS_FRAME_SET_INCOMPLETE(aStatus);
+ aStatus.SetIncomplete();
} else if (endRow < numRows) {
bSize = ClampToCSSMaxBSize(bEndRow, aState.mReflowInput, &aStatus);
} // else - no break opportunities.
} else {
// Even though our block-size fits we need to honor forced breaks, or if
// a row doesn't fit in an auto-sized container (unless it's constrained
// by a max-bsize which make us overflow-incomplete).
if (endRow < numRows && (isForcedBreak ||
@@ -5665,24 +5665,24 @@ nsGridContainerFrame::ReflowRowsInFragme
if (!isRowTopOfPage) {
// We can break before this row - restart with it as the new end row.
aEndRow = row;
aBSize = aState.mRows.GridLineEdge(aEndRow, GridLineSide::eBeforeGridGap);
i = -1; // i == 0 after the next loop increment
isRowTopOfPage = isStartRowTopOfPage;
overflowIncompleteItems.Clear();
incompleteItems.Clear();
- NS_FRAME_SET_INCOMPLETE(aStatus);
+ aStatus.SetIncomplete();
continue;
}
NS_ERROR("got BREAK_BEFORE at top-of-page");
childStatus = NS_FRAME_COMPLETE;
} else {
NS_ERROR("got BREAK_BEFORE again after growing the row?");
- NS_FRAME_SET_INCOMPLETE(childStatus);
+ childStatus.SetIncomplete();
}
} else if (NS_INLINE_IS_BREAK_AFTER(childStatus)) {
MOZ_ASSERT_UNREACHABLE("unexpected child reflow status");
}
if (childStatus.IsIncomplete()) {
incompleteItems.PutEntry(child);
} else if (!childStatus.IsFullyComplete()) {
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -300,19 +300,16 @@ private:
#define NS_FRAME_COMPLETE 0 // Note: not a bit!
#define NS_FRAME_NOT_COMPLETE 0x1
#define NS_FRAME_REFLOW_NEXTINFLOW 0x2
#define NS_FRAME_OVERFLOW_INCOMPLETE 0x4
// These macros set or switch incomplete statuses without touching the
// NS_FRAME_REFLOW_NEXTINFLOW bit.
-#define NS_FRAME_SET_INCOMPLETE(status) \
- status = (status & ~NS_FRAME_OVERFLOW_INCOMPLETE) | NS_FRAME_NOT_COMPLETE
-
#define NS_FRAME_SET_OVERFLOW_INCOMPLETE(status) \
status = (status & ~NS_FRAME_NOT_COMPLETE) | NS_FRAME_OVERFLOW_INCOMPLETE
// This bit is set, when a break is requested. This bit is orthogonal
// to the nsIFrame::nsReflowStatus completion bits.
#define NS_INLINE_BREAK 0x0100
// When a break is requested, this bit when set indicates that the
--- a/layout/generic/nsInlineFrame.cpp
+++ b/layout/generic/nsInlineFrame.cpp
@@ -824,26 +824,26 @@ nsInlineFrame::ReflowInlineFrame(nsPresC
// Create a next-in-flow if needed.
if (!aStatus.IsFullyComplete()) {
CreateNextInFlow(aFrame);
}
if (NS_INLINE_IS_BREAK_AFTER(aStatus)) {
nsIFrame* nextFrame = aFrame->GetNextSibling();
if (nextFrame) {
- NS_FRAME_SET_INCOMPLETE(aStatus);
+ aStatus.SetIncomplete();
PushFrames(aPresContext, nextFrame, aFrame, irs);
}
else {
// We must return an incomplete status if there are more child
// frames remaining in a next-in-flow that follows this frame.
nsInlineFrame* nextInFlow = static_cast<nsInlineFrame*>(GetNextInFlow());
while (nextInFlow) {
if (nextInFlow->mFrames.NotEmpty()) {
- NS_FRAME_SET_INCOMPLETE(aStatus);
+ aStatus.SetIncomplete();
break;
}
nextInFlow = static_cast<nsInlineFrame*>(nextInFlow->GetNextInFlow());
}
}
return;
}
--- a/layout/generic/nsRubyBaseContainerFrame.cpp
+++ b/layout/generic/nsRubyBaseContainerFrame.cpp
@@ -512,17 +512,17 @@ nsRubyBaseContainerFrame::ReflowColumns(
if (!e.AtEnd() && NS_INLINE_IS_BREAK_AFTER(reflowStatus)) {
// The current column has been successfully placed.
// Skip to the next column and mark break before.
e.Next();
e.GetColumn(column);
reflowStatus = NS_INLINE_LINE_BREAK_BEFORE();
}
if (!e.AtEnd() || (GetNextInFlow() && !isComplete)) {
- NS_FRAME_SET_INCOMPLETE(aStatus);
+ aStatus.SetIncomplete();
}
if (NS_INLINE_IS_BREAK_BEFORE(reflowStatus)) {
if (!columnIndex || !aReflowInput.mAllowLineBreak) {
// If no column has been placed yet, or we have any span,
// the whole container should be in the next line.
aStatus = NS_INLINE_LINE_BREAK_BEFORE();
return 0;
--- a/layout/tables/nsTableCellFrame.cpp
+++ b/layout/tables/nsTableCellFrame.cpp
@@ -955,17 +955,17 @@ nsTableCellFrame::Reflow(nsPresContext*
nsRect origVisualOverflow = firstKid->GetVisualOverflowRect();
bool firstReflow = firstKid->HasAnyStateBits(NS_FRAME_FIRST_REFLOW);
ReflowChild(firstKid, aPresContext, kidSize, kidReflowInput,
wm, kidOrigin, containerSize, 0, aStatus);
if (aStatus.IsOverflowIncomplete()) {
// Don't pass OVERFLOW_INCOMPLETE through tables until they can actually handle it
//XXX should paginate overflow as overflow, but not in this patch (bug 379349)
- NS_FRAME_SET_INCOMPLETE(aStatus);
+ aStatus.SetIncomplete();
printf("Set table cell incomplete %p\n", static_cast<void*>(this));
}
// XXXbz is this invalidate actually needed, really?
if (HasAnyStateBits(NS_FRAME_IS_DIRTY)) {
InvalidateFrameSubtree();
}
--- a/layout/tables/nsTableRowFrame.cpp
+++ b/layout/tables/nsTableRowFrame.cpp
@@ -1056,17 +1056,17 @@ nsTableRowFrame::ReflowChildren(nsPresCo
}
}
} else { // constrained bsize, paginated
// Compute the bsize we should have from style (subtracting the
// bsize from our prev-in-flows from the style bsize)
nscoord styleBSize = CalcBSizeFromUnpaginatedBSize(*this, wm);
if (styleBSize > aReflowInput.AvailableBSize()) {
styleBSize = aReflowInput.AvailableBSize();
- NS_FRAME_SET_INCOMPLETE(aStatus);
+ aStatus.SetIncomplete();
}
aDesiredSize.BSize(wm) = std::max(cellMaxBSize, styleBSize);
}
if (wm.IsVerticalRL()) {
// Any children whose width was not the same as our final
// aDesiredSize.BSize will have been misplaced earlier at the
// FinishReflowChild stage. So fix them up now.
--- a/layout/tables/nsTableRowGroupFrame.cpp
+++ b/layout/tables/nsTableRowGroupFrame.cpp
@@ -1402,17 +1402,17 @@ nsTableRowGroupFrame::Reflow(nsPresConte
((ReflowInput::ReflowInputFlags&)aReflowInput.mFlags).mSpecialBSizeReflow = specialReflow;
}
// XXXmats The following is just bogus. We leave it here for now because
// ReflowChildren should pull up rows from our next-in-flow before returning
// a Complete status, but doesn't (bug 804888).
if (GetNextInFlow() && GetNextInFlow()->PrincipalChildList().FirstChild()) {
- NS_FRAME_SET_INCOMPLETE(aStatus);
+ aStatus.SetIncomplete();
}
SetHasStyleBSize((NS_UNCONSTRAINEDSIZE != aReflowInput.ComputedBSize()) &&
(aReflowInput.ComputedBSize() > 0));
// Just set our isize to what was available.
// The table will calculate the isize and not use our value.
WritingMode wm = aReflowInput.GetWritingMode();