author | Ting-Yu Lin <tlin@mozilla.com> |
Thu, 21 Jul 2016 18:36:35 +0800 | |
changeset 306063 | 36e0aef210e256b04a1afce041c8ad5f150bd720 |
parent 306062 | 999402eb1b15f1c23038d201036b2578c424fab5 |
child 306064 | 7fa3859b444c9a45f642e344d2ad961873bdaf8e |
push id | 30474 |
push user | cbook@mozilla.com |
push date | Thu, 21 Jul 2016 14:25:10 +0000 |
treeherder | mozilla-central@6b180266ac16 [default view] [failures only] |
perfherder | [talos] [build metrics] [platform microbench] (compared to previous push) |
reviewers | dbaron |
bugs | 1277129 |
milestone | 50.0a1 |
first release with | nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
|
last release without | nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
|
--- a/layout/base/RestyleManager.cpp +++ b/layout/base/RestyleManager.cpp @@ -453,22 +453,22 @@ RestyleManager::RecomputePosition(nsIFra "Unexpected type of positioning"); for (nsIFrame* cont = aFrame; cont; cont = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(cont)) { nsIFrame* cb = cont->GetContainingBlock(); nsMargin newOffsets; WritingMode wm = cb->GetWritingMode(); const LogicalSize size(wm, cb->GetContentRectRelativeToSelf().Size()); - nsHTMLReflowState::ComputeRelativeOffsets(wm, cont, size, newOffsets); + ReflowInput::ComputeRelativeOffsets(wm, cont, size, newOffsets); NS_ASSERTION(newOffsets.left == -newOffsets.right && newOffsets.top == -newOffsets.bottom, "ComputeRelativeOffsets should return valid results"); - // nsHTMLReflowState::ApplyRelativePositioning would work here, but + // ReflowInput::ApplyRelativePositioning would work here, but // since we've already checked mPosition and aren't changing the frame's // normal position, go ahead and add the offsets directly. cont->SetPosition(cont->GetNormalPosition() + nsPoint(newOffsets.left, newOffsets.top)); } } return true; @@ -484,26 +484,26 @@ RestyleManager::RecomputePosition(nsIFra // Construct a bogus parent reflow state so that there's a usable // containing block reflow state. nsIFrame* parentFrame = aFrame->GetParent(); WritingMode parentWM = parentFrame->GetWritingMode(); WritingMode frameWM = aFrame->GetWritingMode(); LogicalSize parentSize = parentFrame->GetLogicalSize(); nsFrameState savedState = parentFrame->GetStateBits(); - nsHTMLReflowState parentReflowState(aFrame->PresContext(), parentFrame, + ReflowInput parentReflowState(aFrame->PresContext(), parentFrame, &rc, parentSize); parentFrame->RemoveStateBits(~nsFrameState(0)); parentFrame->AddStateBits(savedState); // The bogus parent state here was created with no parent state of its own, // and therefore it won't have an mCBReflowState set up. // But we may need one (for InitCBReflowState in a child state), so let's // try to create one here for the cases where it will be needed. - Maybe<nsHTMLReflowState> cbReflowState; + Maybe<ReflowInput> cbReflowState; nsIFrame* cbFrame = parentFrame->GetContainingBlock(); if (cbFrame && (aFrame->GetContainingBlock() != parentFrame || parentFrame->GetType() == nsGkAtoms::tableFrame)) { LogicalSize cbSize = cbFrame->GetLogicalSize(); cbReflowState.emplace(cbFrame->PresContext(), cbFrame, &rc, cbSize); cbReflowState->ComputedPhysicalMargin() = cbFrame->GetUsedMargin(); cbReflowState->ComputedPhysicalPadding() = cbFrame->GetUsedPadding(); cbReflowState->ComputedPhysicalBorderPadding() = @@ -527,17 +527,17 @@ RestyleManager::RecomputePosition(nsIFra ViewportFrame* viewport = do_QueryFrame(parentFrame); nsSize cbSize = viewport ? viewport->AdjustReflowStateAsContainingBlock(&parentReflowState).Size() : aFrame->GetContainingBlock()->GetSize(); const nsMargin& parentBorder = parentReflowState.mStyleBorder->GetComputedBorder(); cbSize -= nsSize(parentBorder.LeftRight(), parentBorder.TopBottom()); LogicalSize lcbSize(frameWM, cbSize); - nsHTMLReflowState reflowState(aFrame->PresContext(), parentReflowState, + ReflowInput reflowState(aFrame->PresContext(), parentReflowState, aFrame, availSize, &lcbSize); nsSize computedSize(reflowState.ComputedWidth(), reflowState.ComputedHeight()); computedSize.width += reflowState.ComputedPhysicalBorderPadding().LeftRight(); if (computedSize.height != NS_INTRINSICSIZE) { computedSize.height += reflowState.ComputedPhysicalBorderPadding().TopBottom(); } nsSize size = aFrame->GetSize(); // The RecomputePosition hint is not used if any offset changed between auto
--- a/layout/base/nsIPercentBSizeObserver.h +++ b/layout/base/nsIPercentBSizeObserver.h @@ -4,30 +4,30 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #ifndef nsIPercentBSizeObserver_h___ #define nsIPercentBSizeObserver_h___ #include "nsQueryFrame.h" namespace mozilla { -struct nsHTMLReflowState; +struct ReflowInput; } // namespace mozilla /** * This interface is supported by frames that need to provide computed bsize * values to children during reflow which would otherwise not happen. Currently * only table cells support this. */ class nsIPercentBSizeObserver { public: NS_DECL_QUERYFRAME_TARGET(nsIPercentBSizeObserver) // Notify the observer that aReflowState has no computed bsize, // but it has a percent bsize - virtual void NotifyPercentBSize(const mozilla::nsHTMLReflowState& aReflowState) = 0; + virtual void NotifyPercentBSize(const mozilla::ReflowInput& aReflowState) = 0; // Ask the observer if it should observe aReflowState.frame - virtual bool NeedsToObserve(const mozilla::nsHTMLReflowState& aReflowState) = 0; + virtual bool NeedsToObserve(const mozilla::ReflowInput& aReflowState) = 0; }; #endif // nsIPercentBSizeObserver_h___
--- a/layout/base/nsLayoutUtils.cpp +++ b/layout/base/nsLayoutUtils.cpp @@ -5286,17 +5286,17 @@ nsLayoutUtils::MarkDescendantsDirty(nsIF // dirty descendants, iterating over subtrees that may include // additional subtrees associated with placeholders do { nsIFrame *subtreeRoot = subtrees.ElementAt(subtrees.Length() - 1); subtrees.RemoveElementAt(subtrees.Length() - 1); // Mark all descendants dirty (using an nsTArray stack rather than // recursion). - // Note that nsHTMLReflowState::InitResizeFlags has some similar + // Note that ReflowInput::InitResizeFlags has some similar // code; see comments there for how and why it differs. AutoTArray<nsIFrame*, 32> stack; stack.AppendElement(subtreeRoot); do { nsIFrame *f = stack.ElementAt(stack.Length() - 1); stack.RemoveElementAt(stack.Length() - 1);
--- a/layout/base/nsPresShell.cpp +++ b/layout/base/nsPresShell.cpp @@ -2658,17 +2658,17 @@ PresShell::FrameNeedsReflow(nsIFrame *aF a && !FRAME_IS_REFLOW_ROOT(a); a = a->GetParent()) a->MarkIntrinsicISizesDirty(); } if (aIntrinsicDirty == eStyleChange) { // Mark all descendants dirty (using an nsTArray stack rather than // recursion). - // Note that nsHTMLReflowState::InitResizeFlags has some similar + // Note that ReflowInput::InitResizeFlags has some similar // code; see comments there for how and why it differs. AutoTArray<nsIFrame*, 32> stack; stack.AppendElement(subtreeRoot); do { nsIFrame *f = stack.ElementAt(stack.Length() - 1); stack.RemoveElementAt(stack.Length() - 1); @@ -9540,30 +9540,30 @@ PresShell::DoReflow(nsIFrame* target, bo } NS_ASSERTION(!target->GetNextInFlow() && !target->GetPrevInFlow(), "reflow roots should never split"); // Don't pass size directly to the reflow state, since a // constrained height implies page/column breaking. LogicalSize reflowSize(wm, size.ISize(wm), NS_UNCONSTRAINEDSIZE); - nsHTMLReflowState reflowState(mPresContext, target, &rcx, reflowSize, - nsHTMLReflowState::CALLER_WILL_INIT); + ReflowInput reflowState(mPresContext, target, &rcx, reflowSize, + ReflowInput::CALLER_WILL_INIT); reflowState.mOrthogonalLimit = size.BSize(wm); if (rootFrame == target) { reflowState.Init(mPresContext); // When the root frame is being reflowed with unconstrained block-size // (which happens when we're called from // nsDocumentViewer::SizeToContent), we're effectively doing a // resize in the block direction, since it changes the meaning of // percentage block-sizes even if no block-sizes actually changed. // The same applies when we reflow again after that computation. This is - // an unusual case, and isn't caught by nsHTMLReflowState::InitResizeFlags. + // an unusual case, and isn't caught by ReflowInput::InitResizeFlags. bool hasUnconstrainedBSize = size.BSize(wm) == NS_UNCONSTRAINEDSIZE; if (hasUnconstrainedBSize || mLastRootReflowHadUnconstrainedBSize) { reflowState.SetBResize(true); } mLastRootReflowHadUnconstrainedBSize = hasUnconstrainedBSize; } else {
--- a/layout/forms/nsComboboxControlFrame.cpp +++ b/layout/forms/nsComboboxControlFrame.cpp @@ -413,33 +413,33 @@ public: return NS_OK; } nsWeakFrame mFrame; }; void nsComboboxControlFrame::ReflowDropdown(nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState) + const ReflowInput& aReflowState) { // All we want out of it later on, really, is the block size of a row, so we // don't even need to cache mDropdownFrame's ascent or anything. If we don't // need to reflow it, just bail out here. if (!aReflowState.ShouldReflowAllKids() && !NS_SUBTREE_DIRTY(mDropdownFrame)) { return; } // XXXbz this will, for small-block-size dropdowns, have extra space // on the appropriate edge for the scrollbar we don't show... but // that's the best we can do here for now. WritingMode wm = mDropdownFrame->GetWritingMode(); LogicalSize availSize = aReflowState.AvailableSize(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; - nsHTMLReflowState kidReflowState(aPresContext, aReflowState, mDropdownFrame, + ReflowInput kidReflowState(aPresContext, aReflowState, mDropdownFrame, availSize); // If the dropdown's intrinsic inline size is narrower than our // specified inline size, then expand it out. We want our border-box // inline size to end up the same as the dropdown's so account for // both sets of mComputedBorderPadding. nscoord forcedISize = aReflowState.ComputedISize() + aReflowState.ComputedLogicalBorderPadding().IStartEnd(wm) - @@ -804,17 +804,17 @@ nsComboboxControlFrame::GetPrefISize(nsR DISPLAY_PREF_WIDTH(this, prefISize); prefISize = GetIntrinsicISize(aRenderingContext, nsLayoutUtils::PREF_ISIZE); return prefISize; } void nsComboboxControlFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); // Constraints we try to satisfy: // 1) Default inline size of button is the vertical scrollbar size // 2) If the inline size of button is bigger than our inline size, set // inline size of button to 0. @@ -1282,17 +1282,17 @@ public: virtual bool IsFrameOfType(uint32_t aFlags) const override { return nsBlockFrame::IsFrameOfType(aFlags & ~(nsIFrame::eReplacedContainsBlock)); } virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; protected: nsComboboxControlFrame* mComboBox; @@ -1304,20 +1304,20 @@ nsIAtom* nsComboboxDisplayFrame::GetType() const { return nsGkAtoms::comboboxDisplayFrame; } void nsComboboxDisplayFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { - nsHTMLReflowState state(aReflowState); + ReflowInput state(aReflowState); if (state.ComputedBSize() == NS_INTRINSICSIZE) { // Note that the only way we can have a computed block size here is // if the combobox had a specified block size. If it didn't, size // based on what our rows look like, for lack of anything better. state.SetComputedBSize(mComboBox->mListControlFrame->GetBSizeOfARow()); } WritingMode wm = aReflowState.GetWritingMode(); nscoord computedISize = mComboBox->mDisplayISize -
--- a/layout/forms/nsComboboxControlFrame.h +++ b/layout/forms/nsComboboxControlFrame.h @@ -76,17 +76,17 @@ public: #endif virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override; virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override; virtual void Reflow(nsPresContext* aCX, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsresult HandleEvent(nsPresContext* aPresContext, mozilla::WidgetGUIEvent* aEvent, nsEventStatus* aEventStatus) override; virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, @@ -212,17 +212,17 @@ public: protected: friend class RedisplayTextEvent; friend class nsAsyncResize; friend class nsResizeDropdownAtFinalPosition; // Utilities void ReflowDropdown(nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState); + const ReflowInput& aReflowState); enum DropDownPositionState { // can't show the dropdown at its current position eDropDownPositionSuppressed, // a resize reflow is pending, don't show it yet eDropDownPositionPendingResize, // the dropdown has its final size and position and can be displayed here eDropDownPositionFinal
--- a/layout/forms/nsFieldSetFrame.cpp +++ b/layout/forms/nsFieldSetFrame.cpp @@ -379,17 +379,17 @@ nsFieldSetFrame::ComputeSize(nsRendering } return result; } void nsFieldSetFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsFieldSetFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); NS_PRECONDITION(aReflowState.ComputedISize() != NS_INTRINSICSIZE, "Should have a precomputed inline-size!"); @@ -444,17 +444,17 @@ nsFieldSetFrame::Reflow(nsPresContext* // get our border and padding LogicalMargin border = aReflowState.ComputedLogicalBorderPadding() - aReflowState.ComputedLogicalPadding(); // Figure out how big the legend is if there is one. // get the legend's margin LogicalMargin legendMargin(wm); // reflow the legend only if needed - Maybe<nsHTMLReflowState> legendReflowState; + Maybe<ReflowInput> legendReflowState; if (legend) { legendReflowState.emplace(aPresContext, aReflowState, legend, legendAvailSize); } if (reflowLegend) { nsHTMLReflowMetrics legendDesiredSize(aReflowState); // We'll move the legend to its proper place later, so the position @@ -502,19 +502,19 @@ nsFieldSetFrame::Reflow(nsPresContext* } // This containerSize is incomplete as yet: it does not include the size // of the |inner| frame itself. nsSize containerSize = (LogicalSize(wm, 0, mLegendSpace) + border.Size(wm)).GetPhysicalSize(wm); // reflow the content frame only if needed if (reflowInner) { - nsHTMLReflowState kidReflowState(aPresContext, aReflowState, inner, + ReflowInput kidReflowState(aPresContext, aReflowState, inner, innerAvailSize, nullptr, - nsHTMLReflowState::CALLER_WILL_INIT); + ReflowInput::CALLER_WILL_INIT); // Override computed padding, in case it's percentage padding kidReflowState.Init(aPresContext, nullptr, nullptr, &aReflowState.ComputedPhysicalPadding()); // Our child is "height:100%" but we actually want its height to be reduced // by the amount of content-height the legend is eating up, unless our // height is unconstrained (in which case the child's will be too). if (aReflowState.ComputedBSize() != NS_UNCONSTRAINEDSIZE) { kidReflowState.SetComputedBSize( @@ -615,17 +615,17 @@ nsFieldSetFrame::Reflow(nsPresContext* actualLegendRect.Deflate(wm, legendMargin); LogicalPoint actualLegendPos(actualLegendRect.Origin(wm)); // Note that legend's writing mode may be different from the fieldset's, // so we need to convert offsets before applying them to it (bug 1134534). LogicalMargin offsets = legendReflowState->ComputedLogicalOffsets(). ConvertTo(wm, legendReflowState->GetWritingMode()); - nsHTMLReflowState::ApplyRelativePositioning(legend, wm, offsets, + ReflowInput::ApplyRelativePositioning(legend, wm, offsets, &actualLegendPos, containerSize); legend->SetPosition(wm, actualLegendPos, containerSize); nsContainerFrame::PositionFrameView(legend); nsContainerFrame::PositionChildViews(legend); }
--- a/layout/forms/nsFieldSetFrame.h +++ b/layout/forms/nsFieldSetFrame.h @@ -38,17 +38,17 @@ public: /** * The area to paint box-shadows around. It's the border rect except * when there's a <legend> we offset the y-position to the center of it. */ virtual nsRect VisualBorderRectRelativeToSelf() const override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; DrawResult PaintBorder(nsDisplayListBuilder* aBuilder, nsRenderingContext& aRenderingContext,
--- a/layout/forms/nsFormControlFrame.cpp +++ b/layout/forms/nsFormControlFrame.cpp @@ -110,17 +110,17 @@ nsFormControlFrame::GetLogicalBaseline(W ? GetLogicalUsedBorderAndPadding(aWritingMode).BStart(aWritingMode) : BSize(aWritingMode) - GetLogicalUsedBorderAndPadding(aWritingMode).BEnd(aWritingMode); } void nsFormControlFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsFormControlFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS, ("enter nsFormControlFrame::Reflow: aMaxSize=%d,%d", aReflowState.AvailableWidth(), aReflowState.AvailableHeight()));
--- a/layout/forms/nsFormControlFrame.h +++ b/layout/forms/nsFormControlFrame.h @@ -78,17 +78,17 @@ public: const override; /** * Respond to the request to resize and/or reflow * @see nsIFrame::Reflow */ virtual void Reflow(nsPresContext* aCX, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual void DestroyFrom(nsIFrame* aDestructRoot) override; // new behavior virtual void SetFocus(bool aOn = true, bool aRepaint = false) override;
--- a/layout/forms/nsHTMLButtonControlFrame.cpp +++ b/layout/forms/nsHTMLButtonControlFrame.cpp @@ -180,17 +180,17 @@ nsHTMLButtonControlFrame::GetPrefISize(n : mRenderer.GetAddedButtonBorderAndPadding().LeftRight(); return result; } void nsHTMLButtonControlFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsHTMLButtonControlFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); NS_PRECONDITION(aReflowState.ComputedISize() != NS_INTRINSICSIZE, "Should have real computed inline-size by now"); @@ -237,43 +237,43 @@ nsHTMLButtonControlFrame::Reflow(nsPresC NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize); } // Helper-function that lets us clone the button's reflow state, but with its // ComputedWidth and ComputedHeight reduced by the amount of renderer-specific // focus border and padding that we're using. (This lets us provide a more // appropriate content-box size for descendents' percent sizes to resolve // against.) -static nsHTMLReflowState +static ReflowInput CloneReflowStateWithReducedContentBox( - const nsHTMLReflowState& aButtonReflowState, + const ReflowInput& aButtonReflowState, const nsMargin& aFocusPadding) { nscoord adjustedWidth = aButtonReflowState.ComputedWidth() - aFocusPadding.LeftRight(); adjustedWidth = std::max(0, adjustedWidth); // (Only adjust height if it's an actual length.) nscoord adjustedHeight = aButtonReflowState.ComputedHeight(); if (adjustedHeight != NS_INTRINSICSIZE) { adjustedHeight -= aFocusPadding.TopBottom(); adjustedHeight = std::max(0, adjustedHeight); } - nsHTMLReflowState clone(aButtonReflowState); + ReflowInput clone(aButtonReflowState); clone.SetComputedWidth(adjustedWidth); clone.SetComputedHeight(adjustedHeight); return clone; } void nsHTMLButtonControlFrame::ReflowButtonContents(nsPresContext* aPresContext, nsHTMLReflowMetrics& aButtonDesiredSize, - const nsHTMLReflowState& aButtonReflowState, + const ReflowInput& aButtonReflowState, nsIFrame* aFirstKid) { WritingMode wm = GetWritingMode(); LogicalSize availSize = aButtonReflowState.ComputedSize(wm); availSize.BSize(wm) = NS_INTRINSICSIZE; // Buttons have some bonus renderer-determined border/padding, // which occupies part of the button's content-box area: @@ -310,21 +310,21 @@ nsHTMLButtonControlFrame::ReflowButtonCo availSize.ISize(wm) -= focusPadding.IStartEnd(wm); LogicalPoint childPos(wm); childPos.I(wm) = focusPadding.IStart(wm) + clbp.IStart(wm); availSize.ISize(wm) = std::max(availSize.ISize(wm), 0); // Give child a clone of the button's reflow state, with height/width reduced // by focusPadding, so that descendants with height:100% don't protrude. - nsHTMLReflowState adjustedButtonReflowState = + ReflowInput adjustedButtonReflowState = CloneReflowStateWithReducedContentBox(aButtonReflowState, focusPadding.GetPhysicalMargin(wm)); - nsHTMLReflowState contentsReflowState(aPresContext, + ReflowInput contentsReflowState(aPresContext, adjustedButtonReflowState, aFirstKid, availSize); nsReflowStatus contentsReflowStatus; nsHTMLReflowMetrics contentsDesiredSize(aButtonReflowState); childPos.B(wm) = 0; // This will be set properly later, after reflowing the // child to determine its size.
--- a/layout/forms/nsHTMLButtonControlFrame.h +++ b/layout/forms/nsHTMLButtonControlFrame.h @@ -31,17 +31,17 @@ public: const nsDisplayListSet& aLists) override; virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override; virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsresult HandleEvent(nsPresContext* aPresContext, mozilla::WidgetGUIEvent* aEvent, nsEventStatus* aEventStatus) override; virtual void Init(nsIContent* aContent, nsContainerFrame* aParent, @@ -97,17 +97,17 @@ protected: // border-box (either because of "overflow" or because of legacy reasons // about how <input>-flavored buttons work). bool ShouldClipPaintingToBorderBox(); // Reflows the button's sole child frame, and computes the desired size // of the button itself from the results. void ReflowButtonContents(nsPresContext* aPresContext, nsHTMLReflowMetrics& aButtonDesiredSize, - const nsHTMLReflowState& aButtonReflowState, + const ReflowInput& aButtonReflowState, nsIFrame* aFirstKid); nsButtonFrameRenderer mRenderer; }; #endif
--- a/layout/forms/nsImageControlFrame.cpp +++ b/layout/forms/nsImageControlFrame.cpp @@ -27,17 +27,17 @@ public: nsContainerFrame* aParent, nsIFrame* aPrevInFlow) override; NS_DECL_QUERYFRAME NS_DECL_FRAMEARENA_HELPERS virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsresult HandleEvent(nsPresContext* aPresContext, WidgetGUIEvent* aEvent, nsEventStatus* aEventStatus) override; virtual nsIAtom* GetType() const override; @@ -122,17 +122,17 @@ nsIAtom* nsImageControlFrame::GetType() const { return nsGkAtoms::imageControlFrame; } void nsImageControlFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { DO_GLOBAL_REFLOW_COUNT("nsImageControlFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); if (!GetPrevInFlow() && (mState & NS_FRAME_FIRST_REFLOW)) { nsFormControlFrame::RegUnRegAccessKey(this, true); } return nsImageFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
--- a/layout/forms/nsLegendFrame.cpp +++ b/layout/forms/nsLegendFrame.cpp @@ -45,17 +45,17 @@ nsLegendFrame::DestroyFrom(nsIFrame* aDe NS_QUERYFRAME_HEAD(nsLegendFrame) NS_QUERYFRAME_ENTRY(nsLegendFrame) NS_QUERYFRAME_TAIL_INHERITING(nsBlockFrame) void nsLegendFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { DO_GLOBAL_REFLOW_COUNT("nsLegendFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); if (mState & NS_FRAME_FIRST_REFLOW) { nsFormControlFrame::RegUnRegAccessKey(static_cast<nsIFrame*>(this), true); } return nsBlockFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
--- a/layout/forms/nsLegendFrame.h +++ b/layout/forms/nsLegendFrame.h @@ -14,17 +14,17 @@ public: NS_DECL_QUERYFRAME_TARGET(nsLegendFrame) NS_DECL_QUERYFRAME NS_DECL_FRAMEARENA_HELPERS explicit nsLegendFrame(nsStyleContext* aContext) : nsBlockFrame(aContext) {} virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual void DestroyFrom(nsIFrame* aDestructRoot) override; virtual nsIAtom* GetType() const override; #ifdef DEBUG_FRAME_DUMP virtual nsresult GetFrameName(nsAString& aResult) const override;
--- a/layout/forms/nsListControlFrame.cpp +++ b/layout/forms/nsListControlFrame.cpp @@ -351,17 +351,17 @@ nsListControlFrame::GetMinISize(nsRender result += scrollbarSize.IStartEnd(wm); return result; } void nsListControlFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { NS_PRECONDITION(aReflowState.ComputedISize() != NS_UNCONSTRAINEDSIZE, "Must have a computed inline size"); SchedulePaint(); mHasPendingInterruptAtStartOfReflow = aPresContext->HasPendingInterrupt(); @@ -409,17 +409,17 @@ nsListControlFrame::Reflow(nsPresContext * the old one. */ bool autoBSize = (aReflowState.ComputedBSize() == NS_UNCONSTRAINEDSIZE); mMightNeedSecondPass = autoBSize && (NS_SUBTREE_DIRTY(this) || aReflowState.ShouldReflowAllKids()); - nsHTMLReflowState state(aReflowState); + ReflowInput state(aReflowState); int32_t length = GetNumberOfRows(); nscoord oldBSizeOfARow = BSizeOfARow(); if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW) && autoBSize) { // When not doing an initial reflow, and when the block size is // auto, start off with our computed block size set to what we'd // expect our block size to be. @@ -489,33 +489,33 @@ nsListControlFrame::Reflow(nsPresContext // mComputedPadding.top to it (and subtract it from descent). Need that // because nsGfxScrollFrame just adds in the border.... nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize, state, aStatus); } void nsListControlFrame::ReflowAsDropdown(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { NS_PRECONDITION(aReflowState.ComputedBSize() == NS_UNCONSTRAINEDSIZE, "We should not have a computed block size here!"); mMightNeedSecondPass = NS_SUBTREE_DIRTY(this) || aReflowState.ShouldReflowAllKids(); WritingMode wm = aReflowState.GetWritingMode(); #ifdef DEBUG nscoord oldBSizeOfARow = BSizeOfARow(); nscoord oldVisibleBSize = (GetStateBits() & NS_FRAME_FIRST_REFLOW) ? NS_UNCONSTRAINEDSIZE : GetScrolledFrame()->BSize(wm); #endif - nsHTMLReflowState state(aReflowState); + ReflowInput state(aReflowState); if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW)) { // When not doing an initial reflow, and when the block size is // auto, start off with our computed block size set to what we'd // expect our block size to be. // Note: At this point, mLastDropdownComputedBSize can be // NS_UNCONSTRAINEDSIZE in cases when last time we didn't have to // constrain the block size. That's fine; just do the same thing as @@ -1489,17 +1489,17 @@ nsListControlFrame::AboutToRollup() if (IsInDropDownMode()) { ComboboxFinish(mComboboxFrame->GetIndexOfDisplayArea()); // might destroy us } } void nsListControlFrame::DidReflow(nsPresContext* aPresContext, - const nsHTMLReflowState* aReflowState, + const ReflowInput* aReflowState, nsDidReflowStatus aStatus) { bool wasInterrupted = !mHasPendingInterruptAtStartOfReflow && aPresContext->HasPendingInterrupt(); nsHTMLScrollFrame::DidReflow(aPresContext, aReflowState, aStatus); if (mNeedToReset && !wasInterrupted) {
--- a/layout/forms/nsListControlFrame.h +++ b/layout/forms/nsListControlFrame.h @@ -63,25 +63,25 @@ public: virtual void SetInitialChildList(ChildListID aListID, nsFrameList& aChildList) override; virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override; virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override; virtual void Reflow(nsPresContext* aCX, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual void Init(nsIContent* aContent, nsContainerFrame* aParent, nsIFrame* aPrevInFlow) override; virtual void DidReflow(nsPresContext* aPresContext, - const nsHTMLReflowState* aReflowState, + const ReflowInput* aReflowState, nsDidReflowStatus aStatus) override; virtual void DestroyFrom(nsIFrame* aDestructRoot) override; virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; virtual nsContainerFrame* GetContentInsertionFrame() override; @@ -341,17 +341,17 @@ protected: /** * Method to reflow ourselves as a dropdown list. This differs from * reflow as a listbox because the criteria for needing a second * pass are different. This will be called from Reflow() as needed. */ void ReflowAsDropdown(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus); // Selection bool SetOptionsSelectedFromFrame(int32_t aStartIndex, int32_t aEndIndex, bool aValue, bool aClearAll); bool ToggleOptionSelectedFromFrame(int32_t aIndex);
--- a/layout/forms/nsMeterFrame.cpp +++ b/layout/forms/nsMeterFrame.cpp @@ -100,17 +100,17 @@ NS_QUERYFRAME_HEAD(nsMeterFrame) NS_QUERYFRAME_ENTRY(nsMeterFrame) NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator) NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame) void nsMeterFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsMeterFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); NS_ASSERTION(mBarDiv, "Meter bar div must exist!"); NS_ASSERTION(!GetPrevContinuation(), @@ -136,24 +136,24 @@ nsMeterFrame::Reflow(nsPresContext* aStatus = NS_FRAME_COMPLETE; NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize); } void nsMeterFrame::ReflowBarFrame(nsIFrame* aBarFrame, nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { bool vertical = ResolvedOrientationIsVertical(); WritingMode wm = aBarFrame->GetWritingMode(); LogicalSize availSize = aReflowState.ComputedSize(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; - nsHTMLReflowState reflowState(aPresContext, aReflowState, + ReflowInput reflowState(aPresContext, aReflowState, aBarFrame, availSize); nscoord size = vertical ? aReflowState.ComputedHeight() : aReflowState.ComputedWidth(); nscoord xoffset = aReflowState.ComputedPhysicalBorderPadding().left; nscoord yoffset = aReflowState.ComputedPhysicalBorderPadding().top; // NOTE: Introduce a new function getPosition in the content part ? HTMLMeterElement* meterElement = static_cast<HTMLMeterElement*>(mContent);
--- a/layout/forms/nsMeterFrame.h +++ b/layout/forms/nsMeterFrame.h @@ -25,17 +25,17 @@ public: explicit nsMeterFrame(nsStyleContext* aContext); virtual ~nsMeterFrame(); virtual void DestroyFrom(nsIFrame* aDestructRoot) override; virtual void Reflow(nsPresContext* aCX, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsIAtom* GetType() const override; #ifdef DEBUG_FRAME_DUMP virtual nsresult GetFrameName(nsAString& aResult) const override { return MakeFrameName(NS_LITERAL_STRING("Meter"), aResult); } @@ -77,17 +77,17 @@ public: bool ShouldUseNativeStyle() const; virtual Element* GetPseudoElement(mozilla::CSSPseudoElementType aType) override; protected: // Helper function which reflow the anonymous div frame. void ReflowBarFrame(nsIFrame* aBarFrame, nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus); /** * The div used to show the meter bar. * @see nsMeterFrame::CreateAnonymousContent */ nsCOMPtr<Element> mBarDiv; };
--- a/layout/forms/nsNumberControlFrame.cpp +++ b/layout/forms/nsNumberControlFrame.cpp @@ -101,17 +101,17 @@ nsNumberControlFrame::GetPrefISize(nsRen } return result; } void nsNumberControlFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsNumberControlFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); NS_ASSERTION(mOuterWrapper, "Outer wrapper div must exist!"); @@ -157,17 +157,17 @@ nsNumberControlFrame::Reflow(nsPresConte NS_ASSERTION(outerWrapperFrame == mFrames.FirstChild(), "huh?"); nsHTMLReflowMetrics wrappersDesiredSize(aReflowState); WritingMode wrapperWM = outerWrapperFrame->GetWritingMode(); LogicalSize availSize = aReflowState.ComputedSize(wrapperWM); availSize.BSize(wrapperWM) = NS_UNCONSTRAINEDSIZE; - nsHTMLReflowState wrapperReflowState(aPresContext, aReflowState, + ReflowInput wrapperReflowState(aPresContext, aReflowState, outerWrapperFrame, availSize); // Convert wrapper margin into my own writing-mode (in case it differs): LogicalMargin wrapperMargin = wrapperReflowState.ComputedLogicalMargin().ConvertTo(myWM, wrapperWM); // offsets of wrapper frame within this frame: LogicalPoint
--- a/layout/forms/nsNumberControlFrame.h +++ b/layout/forms/nsNumberControlFrame.h @@ -56,17 +56,17 @@ public: #endif virtual nscoord GetMinISize(nsRenderingContext* aRenderingContext) override; virtual nscoord GetPrefISize(nsRenderingContext* aRenderingContext) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsresult AttributeChanged(int32_t aNameSpaceID, nsIAtom* aAttribute, int32_t aModType) override; // nsIAnonymousContentCreator virtual nsresult CreateAnonymousContent(nsTArray<ContentInfo>& aElements) override;
--- a/layout/forms/nsProgressFrame.cpp +++ b/layout/forms/nsProgressFrame.cpp @@ -105,17 +105,17 @@ nsProgressFrame::BuildDisplayList(nsDisp const nsDisplayListSet& aLists) { BuildDisplayListForInline(aBuilder, aDirtyRect, aLists); } void nsProgressFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsProgressFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); NS_ASSERTION(mBarDiv, "Progress bar div must exist!"); NS_ASSERTION(!GetPrevContinuation(), @@ -140,24 +140,24 @@ nsProgressFrame::Reflow(nsPresContext* aStatus = NS_FRAME_COMPLETE; NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize); } void nsProgressFrame::ReflowBarFrame(nsIFrame* aBarFrame, nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { bool vertical = ResolvedOrientationIsVertical(); WritingMode wm = aBarFrame->GetWritingMode(); LogicalSize availSize = aReflowState.ComputedSize(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; - nsHTMLReflowState reflowState(aPresContext, aReflowState, + ReflowInput reflowState(aPresContext, aReflowState, aBarFrame, availSize); nscoord size = vertical ? aReflowState.ComputedHeight() : aReflowState.ComputedWidth(); nscoord xoffset = aReflowState.ComputedPhysicalBorderPadding().left; nscoord yoffset = aReflowState.ComputedPhysicalBorderPadding().top; double position = static_cast<HTMLProgressElement*>(mContent)->Position();
--- a/layout/forms/nsProgressFrame.h +++ b/layout/forms/nsProgressFrame.h @@ -32,17 +32,17 @@ public: virtual void DestroyFrom(nsIFrame* aDestructRoot) override; virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; virtual void Reflow(nsPresContext* aCX, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsIAtom* GetType() const override; #ifdef DEBUG_FRAME_DUMP virtual nsresult GetFrameName(nsAString& aResult) const override { return MakeFrameName(NS_LITERAL_STRING("Progress"), aResult); } @@ -84,17 +84,17 @@ public: bool ShouldUseNativeStyle() const; virtual Element* GetPseudoElement(CSSPseudoElementType aType) override; protected: // Helper function which reflow the anonymous div frame. void ReflowBarFrame(nsIFrame* aBarFrame, nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus); /** * The div used to show the progress bar. * @see nsProgressFrame::CreateAnonymousContent */ nsCOMPtr<Element> mBarDiv; };
--- a/layout/forms/nsRangeFrame.cpp +++ b/layout/forms/nsRangeFrame.cpp @@ -310,17 +310,17 @@ nsRangeFrame::BuildDisplayList(nsDisplay aLists.Content()->AppendNewToTop( new (aBuilder) nsDisplayRangeFocusRing(aBuilder, this)); } void nsRangeFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsRangeFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); NS_ASSERTION(mTrackDiv, "::-moz-range-track div must exist!"); NS_ASSERTION(mProgressDiv, "::-moz-range-progress div must exist!"); @@ -370,17 +370,17 @@ nsRangeFrame::Reflow(nsPresContext* aStatus = NS_FRAME_COMPLETE; NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize); } void nsRangeFrame::ReflowAnonymousContent(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState) + const ReflowInput& aReflowState) { // The width/height of our content box, which is the available width/height // for our anonymous content: nscoord rangeFrameContentBoxWidth = aReflowState.ComputedWidth(); nscoord rangeFrameContentBoxHeight = aReflowState.ComputedHeight(); if (rangeFrameContentBoxHeight == NS_AUTOHEIGHT) { rangeFrameContentBoxHeight = 0; } @@ -394,17 +394,17 @@ nsRangeFrame::ReflowAnonymousContent(nsP // height, border and padding of the track, but we ignore margin and // positioning properties and do the positioning ourself to keep the center // of the track's border box on the center of the nsRangeFrame's content // box. WritingMode wm = trackFrame->GetWritingMode(); LogicalSize availSize = aReflowState.ComputedSize(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; - nsHTMLReflowState trackReflowState(aPresContext, aReflowState, + ReflowInput trackReflowState(aPresContext, aReflowState, trackFrame, availSize); // Find the x/y position of the track frame such that it will be positioned // as described above. These coordinates are with respect to the // nsRangeFrame's border-box. nscoord trackX = rangeFrameContentBoxWidth / 2; nscoord trackY = rangeFrameContentBoxHeight / 2; @@ -429,17 +429,17 @@ nsRangeFrame::ReflowAnonymousContent(nsP } nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame(); if (thumbFrame) { // display:none? WritingMode wm = thumbFrame->GetWritingMode(); LogicalSize availSize = aReflowState.ComputedSize(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; - nsHTMLReflowState thumbReflowState(aPresContext, aReflowState, + ReflowInput thumbReflowState(aPresContext, aReflowState, thumbFrame, availSize); // Where we position the thumb depends on its size, so we first reflow // the thumb at {0,0} to obtain its size, then position it afterwards. nsReflowStatus frameStatus; nsHTMLReflowMetrics thumbDesiredSize(aReflowState); ReflowChild(thumbFrame, aPresContext, thumbDesiredSize, @@ -453,17 +453,17 @@ nsRangeFrame::ReflowAnonymousContent(nsP } nsIFrame* rangeProgressFrame = mProgressDiv->GetPrimaryFrame(); if (rangeProgressFrame) { // display:none? WritingMode wm = rangeProgressFrame->GetWritingMode(); LogicalSize availSize = aReflowState.ComputedSize(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; - nsHTMLReflowState progressReflowState(aPresContext, aReflowState, + ReflowInput progressReflowState(aPresContext, aReflowState, rangeProgressFrame, availSize); // We first reflow the range-progress frame at {0,0} to obtain its // unadjusted dimensions, then we adjust it to so that the appropriate edge // ends at the thumb. nsReflowStatus frameStatus; nsHTMLReflowMetrics progressDesiredSize(aReflowState);
--- a/layout/forms/nsRangeFrame.h +++ b/layout/forms/nsRangeFrame.h @@ -43,17 +43,17 @@ public: virtual void DestroyFrom(nsIFrame* aDestructRoot) override; void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; #ifdef DEBUG_FRAME_DUMP virtual nsresult GetFrameName(nsAString& aResult) const override { return MakeFrameName(NS_LITERAL_STRING("Range"), aResult); } #endif @@ -154,17 +154,17 @@ private: nsresult MakeAnonymousDiv(Element** aResult, CSSPseudoElementType aPseudoType, nsTArray<ContentInfo>& aElements); // Helper function which reflows the anonymous div frames. void ReflowAnonymousContent(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState); + const ReflowInput& aReflowState); void DoUpdateThumbPosition(nsIFrame* aThumbFrame, const nsSize& aRangeSize); void DoUpdateRangeProgressFrame(nsIFrame* aProgressFrame, const nsSize& aRangeSize); /**
--- a/layout/forms/nsSelectsAreaFrame.cpp +++ b/layout/forms/nsSelectsAreaFrame.cpp @@ -156,17 +156,17 @@ nsSelectsAreaFrame::BuildDisplayListInte aLists.Outlines()->AppendNewToTop(new (aBuilder) nsDisplayListFocus(aBuilder, this)); } } void nsSelectsAreaFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { nsListControlFrame* list = GetEnclosingListFrame(this); NS_ASSERTION(list, "Must have an nsListControlFrame! Frame constructor is " "broken"); bool isInDropdownMode = list->IsInDropDownMode();
--- a/layout/forms/nsSelectsAreaFrame.h +++ b/layout/forms/nsSelectsAreaFrame.h @@ -22,17 +22,17 @@ public: const nsDisplayListSet& aLists) override; void BuildDisplayListInternal(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists); virtual void Reflow(nsPresContext* aCX, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; nscoord BSizeOfARow() const { return mBSizeOfARow; } protected: explicit nsSelectsAreaFrame(nsStyleContext* aContext) : nsBlockFrame(aContext), mBSizeOfARow(0)
--- a/layout/forms/nsTextControlFrame.cpp +++ b/layout/forms/nsTextControlFrame.cpp @@ -154,17 +154,17 @@ nsTextControlFrame::CalcIntrinsicSize(ns nscoord lineHeight = 0; nscoord charWidth = 0; nscoord charMaxAdvance = 0; RefPtr<nsFontMetrics> fontMet = nsLayoutUtils::GetFontMetricsForFrame(this, aFontSizeInflation); lineHeight = - nsHTMLReflowState::CalcLineHeight(GetContent(), StyleContext(), + ReflowInput::CalcLineHeight(GetContent(), StyleContext(), NS_AUTOHEIGHT, aFontSizeInflation); charWidth = fontMet->AveCharWidth(); charMaxAdvance = fontMet->MaxAdvance(); // Set the width equal to the width in characters int32_t cols = GetCols(); aIntrinsicSize.ISize(aWM) = cols * charWidth; @@ -481,17 +481,17 @@ nsTextControlFrame::ComputeAutoSize(nsRe #endif return autoSize; } void nsTextControlFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsTextControlFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); // make sure that the form registers itself on the initial/first reflow if (mState & NS_FRAME_FIRST_REFLOW) { @@ -507,17 +507,17 @@ nsTextControlFrame::Reflow(nsPresContext aReflowState.ComputedBSize() + aReflowState.ComputedLogicalBorderPadding().BStartEnd(wm)); aDesiredSize.SetSize(wm, finalSize); // computation of the ascent wrt the input height nscoord lineHeight = aReflowState.ComputedBSize(); float inflation = nsLayoutUtils::FontSizeInflationFor(this); if (!IsSingleLineTextControl()) { - lineHeight = nsHTMLReflowState::CalcLineHeight(GetContent(), StyleContext(), + lineHeight = ReflowInput::CalcLineHeight(GetContent(), StyleContext(), NS_AUTOHEIGHT, inflation); } RefPtr<nsFontMetrics> fontMet = nsLayoutUtils::GetFontMetricsForFrame(this, inflation); // now adjust for our borders and padding aDesiredSize.SetBlockStartAscent( nsLayoutUtils::GetCenteredFontBaseline(fontMet, lineHeight, wm.IsLineInverted()) + @@ -537,28 +537,28 @@ nsTextControlFrame::Reflow(nsPresContext aStatus = NS_FRAME_COMPLETE; NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize); } void nsTextControlFrame::ReflowTextControlChild(nsIFrame* aKid, nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus, nsHTMLReflowMetrics& aParentDesiredSize) { // compute available size and frame offsets for child WritingMode wm = aKid->GetWritingMode(); LogicalSize availSize = aReflowState.ComputedSizeWithPadding(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; - nsHTMLReflowState kidReflowState(aPresContext, aReflowState, + ReflowInput kidReflowState(aPresContext, aReflowState, aKid, availSize, nullptr, - nsHTMLReflowState::CALLER_WILL_INIT); + ReflowInput::CALLER_WILL_INIT); // Override padding with our computed padding in case we got it from theming or percentage kidReflowState.Init(aPresContext, nullptr, nullptr, &aReflowState.ComputedPhysicalPadding()); // Set computed width and computed height for the child kidReflowState.SetComputedWidth(aReflowState.ComputedWidth()); kidReflowState.SetComputedHeight(aReflowState.ComputedHeight()); // Offset the frame by the size of the parent's border
--- a/layout/forms/nsTextControlFrame.h +++ b/layout/forms/nsTextControlFrame.h @@ -54,17 +54,17 @@ public: nscoord aAvailableISize, const mozilla::LogicalSize& aMargin, const mozilla::LogicalSize& aBorder, const mozilla::LogicalSize& aPadding, bool aShrinkWrap) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) override; virtual bool IsXULCollapsed() override; virtual bool IsLeaf() const override; #ifdef ACCESSIBILITY @@ -155,17 +155,17 @@ public: NS_DECL_QUERYFRAME protected: /** * Launch the reflow on the child frames - see nsTextControlFrame::Reflow() */ void ReflowTextControlChild(nsIFrame* aFrame, nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus, nsHTMLReflowMetrics& aParentDesiredSize); public: //for methods who access nsTextControlFrame directly void SetValueChanged(bool aValueChanged); // called by the focus listener nsresult MaybeBeginSecureKeyboardInput();
--- a/layout/generic/ReflowInput.cpp +++ b/layout/generic/ReflowInput.cpp @@ -48,17 +48,17 @@ enum eNormalLineHeightControl { 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, +ReflowInput::ReflowInput(nsPresContext* aPresContext, nsIFrame* aFrame, nsRenderingContext* aRenderingContext, const LogicalSize& aAvailableSpace, uint32_t aFlags) : nsCSSOffsetState(aFrame, aRenderingContext) , mBlockDelta(0) , mOrthogonalLimit(NS_UNCONSTRAINEDSIZE) , mReflowDepth(0) @@ -168,19 +168,19 @@ nsCSSOffsetState::nsCSSOffsetState(nsIFr aContainingBlockISize); ReflowStateFlags flags; InitOffsets(aContainingBlockWritingMode, cbSize, frame->GetType(), flags); } // Initialize a reflow state for a child frame's reflow. Some state // is copied from the parent reflow state; the remaining state is // computed. -nsHTMLReflowState::nsHTMLReflowState( +ReflowInput::ReflowInput( nsPresContext* aPresContext, - const nsHTMLReflowState& aParentReflowState, + const ReflowInput& aParentReflowState, nsIFrame* aFrame, const LogicalSize& aAvailableSpace, const LogicalSize* aContainingBlockSize, uint32_t aFlags) : nsCSSOffsetState(aFrame, aParentReflowState.rendContext) , mBlockDelta(0) , mOrthogonalLimit(NS_UNCONSTRAINEDSIZE) , mReflowDepth(aParentReflowState.mReflowDepth + 1) @@ -290,17 +290,17 @@ nsCSSOffsetState::ComputeBSizeValue(nsco if (aBoxSizing == StyleBoxSizing::Border) { inside = ComputedLogicalBorderPadding().BStartEnd(wm); } return nsLayoutUtils::ComputeBSizeValue(aContainingBlockBSize, inside, aCoord); } void -nsHTMLReflowState::SetComputedWidth(nscoord aComputedWidth) +ReflowInput::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 @@ -318,17 +318,17 @@ nsHTMLReflowState::SetComputedWidth(nsco if (frameType != nsGkAtoms::viewportFrame || // Or check GetParent()? mWritingMode.IsVertical()) { InitResizeFlags(frame->PresContext(), frameType); } } } void -nsHTMLReflowState::SetComputedHeight(nscoord aComputedHeight) +ReflowInput::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 @@ -341,25 +341,25 @@ nsHTMLReflowState::SetComputedHeight(nsc nsIAtom* frameType = frame->GetType(); if (frameType != nsGkAtoms::viewportFrame || !mWritingMode.IsVertical()) { InitResizeFlags(frame->PresContext(), frameType); } } } void -nsHTMLReflowState::Init(nsPresContext* aPresContext, +ReflowInput::Init(nsPresContext* aPresContext, const LogicalSize* aContainingBlockSize, const nsMargin* aBorder, const nsMargin* aPadding) { if (AvailableISize() == NS_UNCONSTRAINEDSIZE) { // Look up the parent chain for an orthogonal inline limit, // and reset AvailableISize() if found. - for (const nsHTMLReflowState *parent = mParentReflowState; + for (const ReflowInput *parent = mParentReflowState; parent != nullptr; parent = parent->mParentReflowState) { if (parent->GetWritingMode().IsOrthogonalTo(mWritingMode) && parent->mOrthogonalLimit != NS_UNCONSTRAINEDSIZE) { AvailableISize() = parent->mOrthogonalLimit; break; } } } @@ -465,17 +465,17 @@ nsHTMLReflowState::Init(nsPresContext* !frame->IsFrameOfType(nsIFrame::eReplaced)) || type == nsGkAtoms::textFrame || ComputedISize() != NS_UNCONSTRAINEDSIZE, "have unconstrained inline-size; this should only " "result from very large sizes, not attempts at " "intrinsic inline-size calculation"); } -void nsHTMLReflowState::InitCBReflowState() +void ReflowInput::InitCBReflowState() { if (!mParentReflowState) { mCBReflowState = nullptr; return; } if (mParentReflowState->frame == frame->GetContainingBlock()) { // Inner table frames need to use the containing block of the outer @@ -494,17 +494,17 @@ void nsHTMLReflowState::InitCBReflowStat * 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) +IsQuirkContainingBlockHeight(const ReflowInput* 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. @@ -514,17 +514,17 @@ IsQuirkContainingBlockHeight(const nsHTM } } } return true; } void -nsHTMLReflowState::InitResizeFlags(nsPresContext* aPresContext, nsIAtom* aFrameType) +ReflowInput::InitResizeFlags(nsPresContext* aPresContext, nsIAtom* aFrameType) { const WritingMode wm = mWritingMode; // just a shorthand bool isIResize = frame->ISize(wm) != ComputedISize() + ComputedLogicalBorderPadding().IStartEnd(wm); if ((frame->GetStateBits() & NS_FRAME_FONT_INFLATION_FLOW_ROOT) && nsLayoutUtils::FontSizeInflationEnabled(aPresContext)) { @@ -552,17 +552,17 @@ nsHTMLReflowState::InitResizeFlags(nsPre // 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 + // ReflowInput::SetComputedWidth is called, if the first time // we go through InitResizeFlags we set IsHResize() to true, and then // the second time we'd set it to false even without the // NS_FRAME_IS_DIRTY bit already set. if (frame->GetType() == nsGkAtoms::svgForeignObjectFrame) { // Foreign object frames use dirty bits in a special way. frame->AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN); nsIFrame *kid = frame->PrincipalChildList().FirstChild(); if (kid) { @@ -710,17 +710,17 @@ nsHTMLReflowState::InitResizeFlags(nsPre // It would be nice to check that |ComputedBSize != NS_AUTOHEIGHT| // &&ed with the percentage bsize check. However, this doesn't get // along with table special bsize reflows, since a special bsize // reflow (a quirk that makes such percentage height work on children // of table cells) can cause not just a single percentage height to // become fixed, but an entire descendant chain of percentage height // to become fixed. if (dependsOnCBBSize && mCBReflowState) { - const nsHTMLReflowState *rs = this; + const ReflowInput *rs = this; bool hitCBReflowState = false; do { rs = rs->mParentReflowState; if (!rs) { break; } if (rs->frame->GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_BSIZE) @@ -749,28 +749,28 @@ nsHTMLReflowState::InitResizeFlags(nsPre 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_BSIZE); } } nscoord -nsHTMLReflowState::GetContainingBlockContentISize(WritingMode aWritingMode) const +ReflowInput::GetContainingBlockContentISize(WritingMode aWritingMode) const { if (!mCBReflowState) { return 0; } return mCBReflowState->GetWritingMode().IsOrthogonalTo(aWritingMode) ? mCBReflowState->ComputedBSize() : mCBReflowState->ComputedISize(); } void -nsHTMLReflowState::InitFrameType(nsIAtom* aFrameType) +ReflowInput::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 @@ -857,17 +857,17 @@ nsHTMLReflowState::InitFrameType(nsIAtom } else if (frame->IsFrameOfType(nsIFrame::eReplaced)) { frameType = NS_FRAME_REPLACED(frameType); } mFrameType = frameType; } /* static */ void -nsHTMLReflowState::ComputeRelativeOffsets(WritingMode aWM, +ReflowInput::ComputeRelativeOffsets(WritingMode aWM, nsIFrame* aFrame, const LogicalSize& aCBSize, nsMargin& aComputedOffsets) { LogicalMargin offsets(aWM); mozilla::css::Side inlineStart = aWM.PhysicalSide(eLogicalSideIStart); mozilla::css::Side inlineEnd = aWM.PhysicalSide(eLogicalSideIEnd); mozilla::css::Side blockStart = aWM.PhysicalSide(eLogicalSideBStart); @@ -975,17 +975,17 @@ nsHTMLReflowState::ComputeRelativeOffset *physicalOffsets = aComputedOffsets; } else { props.Set(nsIFrame::ComputedOffsetProperty(), new nsMargin(aComputedOffsets)); } } /* static */ void -nsHTMLReflowState::ApplyRelativePositioning(nsIFrame* aFrame, +ReflowInput::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 " @@ -1019,28 +1019,28 @@ nsHTMLReflowState::ApplyRelativePosition StickyScrollContainer::GetStickyScrollContainerForFrame(aFrame); if (ssc) { *aPosition = ssc->ComputePosition(aFrame); } } } nsIFrame* -nsHTMLReflowState::GetHypotheticalBoxContainer(nsIFrame* aFrame, +ReflowInput::GetHypotheticalBoxContainer(nsIFrame* aFrame, nscoord& aCBIStartEdge, LogicalSize& aCBSize) const { 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; + const ReflowInput* state; if (aFrame->GetStateBits() & NS_FRAME_IN_REFLOW) { for (state = mParentReflowState; state && state->frame != aFrame; state = state->mParentReflowState) { /* do nothing */ } } else { state = nullptr; } @@ -1094,17 +1094,17 @@ GetIntrinsicSizeFor(nsIFrame* aFrame, ns } /** * aInsideBoxSizing returns the part of the padding, border, and margin * in the aAxis dimension that goes inside the edge given by box-sizing; * aOutsideBoxSizing returns the rest. */ void -nsHTMLReflowState::CalculateBorderPaddingMargin( +ReflowInput::CalculateBorderPaddingMargin( LogicalAxis aAxis, nscoord aContainingBlockSize, nscoord* aInsideBoxSizing, nscoord* aOutsideBoxSizing) const { WritingMode wm = GetWritingMode(); mozilla::css::Side startSide = wm.PhysicalSide(MakeLogicalSide(aAxis, eLogicalEdgeStart)); @@ -1201,20 +1201,20 @@ static bool AreAllEarlierInFlowFramesEmp // The values returned are relative to the padding edge of the absolute // containing block. The writing-mode of the hypothetical box position will // have the same block direction as the absolute containing block, but may // differ in inline-bidi direction. // In the code below, |cbrs->frame| is the absolute containing block, while // |containingBlock| is the nearest block container of the placeholder frame, // which may be different from the absolute containing block. void -nsHTMLReflowState::CalculateHypotheticalPosition +ReflowInput::CalculateHypotheticalPosition (nsPresContext* aPresContext, nsIFrame* aPlaceholderFrame, - const nsHTMLReflowState* cbrs, + const ReflowInput* cbrs, nsHypotheticalPosition& aHypotheticalPos, nsIAtom* aFrameType) const { NS_ASSERTION(mStyleDisplay->mOriginalDisplay != NS_STYLE_DISPLAY_NONE, "mOriginalDisplay has not been properly initialized"); // Find the nearest containing block frame to the placeholder frame, // and its inline-start edge and width. @@ -1499,18 +1499,18 @@ nsHTMLReflowState::CalculateHypothetical aHypotheticalPos.mBStart = origin.B(cbwm); aHypotheticalPos.mWritingMode = cbwm; } else { aHypotheticalPos.mWritingMode = wm; } } void -nsHTMLReflowState::InitAbsoluteConstraints(nsPresContext* aPresContext, - const nsHTMLReflowState* cbrs, +ReflowInput::InitAbsoluteConstraints(nsPresContext* aPresContext, + const ReflowInput* cbrs, const LogicalSize& aCBSize, nsIAtom* aFrameType) { WritingMode wm = GetWritingMode(); WritingMode cbwm = cbrs->GetWritingMode(); NS_PRECONDITION(aCBSize.BSize(cbwm) != NS_AUTOHEIGHT, "containing block bsize must be constrained"); @@ -1837,17 +1837,17 @@ nsHTMLReflowState::InitAbsoluteConstrain SetComputedLogicalOffsets(offsets.ConvertTo(wm, cbwm)); SetComputedLogicalMargin(margin.ConvertTo(wm, cbwm)); } // This will not be converted to abstract coordinates because it's only // used in CalcQuirkContainingBlockHeight nscoord -GetBlockMarginBorderPadding(const nsHTMLReflowState* aReflowState) +GetBlockMarginBorderPadding(const ReflowInput* aReflowState) { nscoord result = 0; if (!aReflowState) return result; // zero auto margins nsMargin margin = aReflowState->ComputedPhysicalMargin(); if (NS_AUTOMARGIN == margin.top) margin.top = 0; @@ -1868,27 +1868,27 @@ GetBlockMarginBorderPadding(const nsHTML * 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) +CalcQuirkContainingBlockHeight(const ReflowInput* aCBReflowState) { - const nsHTMLReflowState* firstAncestorRS = nullptr; // a candidate for html frame - const nsHTMLReflowState* secondAncestorRS = nullptr; // a candidate for body frame + const ReflowInput* firstAncestorRS = nullptr; // a candidate for html frame + const ReflowInput* 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; + const ReflowInput* rs = aCBReflowState; for (; rs; rs = rs->mParentReflowState) { 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 @@ -1969,19 +1969,19 @@ CalcQuirkContainingBlockHeight(const nsH // 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 LogicalSize -nsHTMLReflowState::ComputeContainingBlockRectangle( +ReflowInput::ComputeContainingBlockRectangle( nsPresContext* aPresContext, - const nsHTMLReflowState* aContainingBlockRS) const + const ReflowInput* aContainingBlockRS) const { // Unless the element is absolutely positioned, the containing block is // formed by the content edge of the nearest block-level ancestor LogicalSize cbSize = aContainingBlockRS->ComputedSize(); WritingMode wm = aContainingBlockRS->GetWritingMode(); // mFrameType for abs-pos tables is NS_CSS_FRAME_TYPE_BLOCK, so we need to @@ -2080,17 +2080,17 @@ OffsetPercentBasis(const nsIFrame* aF return offsetPercentBasis; } // 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, +ReflowInput::InitConstraints(nsPresContext* aPresContext, const LogicalSize& aContainingBlockSize, const nsMargin* aBorder, const nsMargin* aPadding, nsIAtom* aFrameType) { WritingMode wm = GetWritingMode(); DISPLAY_INIT_CONSTRAINTS(frame, this, aContainingBlockSize.ISize(wm), @@ -2122,17 +2122,17 @@ nsHTMLReflowState::InitConstraints(nsPre } else { ComputedBSize() = NS_UNCONSTRAINEDSIZE; } ComputedMinWidth() = ComputedMinHeight() = 0; ComputedMaxWidth() = ComputedMaxHeight() = NS_UNCONSTRAINEDSIZE; } else { // Get the containing block reflow state - const nsHTMLReflowState* cbrs = mCBReflowState; + const ReflowInput* cbrs = mCBReflowState; NS_ASSERTION(nullptr != cbrs, "no containing block"); // If we weren't given a containing block width and height, then // compute one LogicalSize cbSize = (aContainingBlockSize == LogicalSize(wm, -1, -1)) ? ComputeContainingBlockRectangle(aPresContext, cbrs) : aContainingBlockSize; @@ -2551,17 +2551,17 @@ nsCSSOffsetState::InitOffsets(WritingMod // 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(nsIAtom* aFrameType) +ReflowInput::CalculateBlockSideMargins(nsIAtom* aFrameType) { // Calculations here are done in the containing block's writing mode, // which is where margins will eventually be applied: we're calculating // margins that will be used by the container in its inline direction, // which in the case of an orthogonal contained block will correspond to // the block direction of this reflow state. So in the orthogonal-flow // case, "CalculateBlock*Side*Margins" will actually end up adjusting // the BStart/BEnd margins; those are the "sides" of the block from its @@ -2613,17 +2613,17 @@ nsHTMLReflowState::CalculateBlockSideMar const nsStyleSides& styleSides = mStyleMargin->mMargin; bool isAutoStartMargin = eStyleUnit_Auto == styleSides.GetIStartUnit(cbWM); bool isAutoEndMargin = eStyleUnit_Auto == styleSides.GetIEndUnit(cbWM); if (!isAutoStartMargin && !isAutoEndMargin) { // 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 = mParentReflowState; + const ReflowInput* prs = mParentReflowState; if (aFrameType == nsGkAtoms::tableFrame) { NS_ASSERTION(prs->frame->GetType() == nsGkAtoms::tableWrapperFrame, "table not inside table wrapper"); // Center the table within the table wrapper based on the alignment // of the table wrapper's parent. prs = prs->mParentReflowState; } if (prs && @@ -2739,28 +2739,28 @@ ComputeLineHeight(nsStyleContext* aStyle } RefPtr<nsFontMetrics> fm = nsLayoutUtils:: GetFontMetricsForStyleContext(aStyleContext, aFontSizeInflation); return GetNormalLineHeight(fm); } nscoord -nsHTMLReflowState::CalcLineHeight() const +ReflowInput::CalcLineHeight() const { nscoord blockBSize = nsLayoutUtils::IsNonWrapperBlock(frame) ? ComputedBSize() : (mCBReflowState ? mCBReflowState->ComputedBSize() : NS_AUTOHEIGHT); return CalcLineHeight(frame->GetContent(), frame->StyleContext(), blockBSize, nsLayoutUtils::FontSizeInflationFor(frame)); } /* static */ nscoord -nsHTMLReflowState::CalcLineHeight(nsIContent* aContent, +ReflowInput::CalcLineHeight(nsIContent* aContent, nsStyleContext* aStyleContext, nscoord aBlockBSize, float aFontSizeInflation) { NS_PRECONDITION(aStyleContext, "Must have a style context"); nscoord lineHeight = ComputeLineHeight(aStyleContext, aBlockBSize, aFontSizeInflation); @@ -2866,17 +2866,17 @@ nsCSSOffsetState::ComputePadding(Writing stylePadding->mPadding.GetBEnd(aWM))); SetComputedLogicalPadding(aWM, p); } return isCBDependent; } void -nsHTMLReflowState::ComputeMinMaxValues(const LogicalSize&aCBSize) +ReflowInput::ComputeMinMaxValues(const LogicalSize&aCBSize) { WritingMode wm = GetWritingMode(); const nsStyleCoord& minISize = mStylePosition->MinISize(wm); const nsStyleCoord& maxISize = mStylePosition->MaxISize(wm); const nsStyleCoord& minBSize = mStylePosition->MinBSize(wm); const nsStyleCoord& maxBSize = mStylePosition->MaxBSize(wm); @@ -2955,36 +2955,36 @@ nsHTMLReflowState::ComputeMinMaxValues(c // 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 (ComputedMinBSize() > ComputedMaxBSize()) { ComputedMaxBSize() = ComputedMinBSize(); } } void -nsHTMLReflowState::SetTruncated(const nsHTMLReflowMetrics& aMetrics, +ReflowInput::SetTruncated(const nsHTMLReflowMetrics& aMetrics, nsReflowStatus* aStatus) const { const WritingMode containerWM = aMetrics.GetWritingMode(); if (GetWritingMode().IsOrthogonalTo(containerWM)) { // Orthogonal flows are always reflowed with an unconstrained dimension, - // so should never end up truncated (see nsHTMLReflowState::Init()). + // so should never end up truncated (see ReflowInput::Init()). *aStatus &= ~NS_FRAME_TRUNCATED; } else if (AvailableBSize() != NS_UNCONSTRAINEDSIZE && AvailableBSize() < aMetrics.BSize(containerWM) && !mFlags.mIsTopOfPage) { *aStatus |= NS_FRAME_TRUNCATED; } else { *aStatus &= ~NS_FRAME_TRUNCATED; } } bool -nsHTMLReflowState::IsFloating() const +ReflowInput::IsFloating() const { return mStyleDisplay->IsFloating(frame); } uint8_t -nsHTMLReflowState::GetDisplay() const +ReflowInput::GetDisplay() const { return mStyleDisplay->GetDisplay(frame); }
--- a/layout/generic/ReflowInput.h +++ b/layout/generic/ReflowInput.h @@ -1,17 +1,17 @@ /* -*- 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 */ -#ifndef mozilla_nsHTMLReflowState_h -#define mozilla_nsHTMLReflowState_h +#ifndef mozilla_ReflowInput_h +#define mozilla_ReflowInput_h #include "nsMargin.h" #include "nsStyleCoord.h" #include "nsIFrame.h" #include "mozilla/Assertions.h" #include <algorithm> class nsPresContext; @@ -91,17 +91,17 @@ typedef uint32_t nsCSSFrameType; * A macro to extract the type. Masks off the 'replaced' bit-flag */ #define NS_FRAME_GET_TYPE(_ft) \ ((_ft) & ~(NS_CSS_FRAME_TYPE_REPLACED | \ NS_CSS_FRAME_TYPE_REPLACED_CONTAINS_BLOCK)) namespace mozilla { -// A base class of nsHTMLReflowState that computes only the padding, +// A base class of ReflowInput that computes only the padding, // border, and margin, since those values are needed more often. struct nsCSSOffsetState { public: typedef mozilla::WritingMode WritingMode; typedef mozilla::LogicalMargin LogicalMargin; // the frame being reflowed nsIFrame* frame; @@ -309,46 +309,46 @@ protected: /** * State passed to a frame during reflow or intrinsic size calculation. * * XXX Refactor so only a base class (nsSizingState?) is used for intrinsic * size calculation. * * @see nsIFrame#Reflow() */ -struct nsHTMLReflowState : public nsCSSOffsetState { +struct ReflowInput : public nsCSSOffsetState { // the reflow states are linked together. this is the pointer to the // parent's reflow state - const nsHTMLReflowState* mParentReflowState; + const ReflowInput* mParentReflowState; // pointer to the float manager associated with this area nsFloatManager* mFloatManager; // LineLayout object (only for inline reflow; set to nullptr otherwise) nsLineLayout* mLineLayout; // The appropriate reflow state for the containing block (for // percentage widths, etc.) of this reflow state's frame. - const nsHTMLReflowState *mCBReflowState; + const ReflowInput *mCBReflowState; // The type of frame, from css's perspective. This value is // initialized by the Init method below. nsCSSFrameType mFrameType; // The amount the in-flow position of the block is moving vertically relative // to its previous in-flow position (i.e. the amount the line containing the // block is moving). // This should be zero for anything which is not a block outside, and it // should be zero for anything which has a non-block parent. // The intended use of this value is to allow the accurate determination // of the potential impact of a float // This takes on an arbitrary value the first time a block is reflowed nscoord mBlockDelta; - // If an nsHTMLReflowState finds itself initialized with an unconstrained + // If an ReflowInput finds itself initialized with an unconstrained // inline-size, it will look up its parentReflowState chain for a state // with an orthogonal writing mode and a non-NS_UNCONSTRAINEDSIZE value for // orthogonal limit; when it finds such a reflow-state, it will use its // orthogonal-limit value to constrain inline-size. // This is initialized to NS_UNCONSTRAINEDSIZE (so it will be ignored), // but reset to a suitable value for the reflow root by nsPresShell. nscoord mOrthogonalLimit; @@ -643,40 +643,40 @@ public: * @param aPresContext Must be equal to aFrame->PresContext(). * @param aFrame The frame for whose reflow state is being constructed. * @param aRenderingContext The rendering context to be used for measurements. * @param aAvailableSpace See comments for availableHeight and availableWidth * members. * @param aFlags A set of flags used for additional boolean parameters (see * below). */ - nsHTMLReflowState(nsPresContext* aPresContext, + ReflowInput(nsPresContext* aPresContext, nsIFrame* aFrame, nsRenderingContext* aRenderingContext, const mozilla::LogicalSize& aAvailableSpace, uint32_t aFlags = 0); /** * Initialize a reflow state for a child frame's reflow. Some parts of the * state are copied from the parent's reflow state. The remainder is computed. * * @param aPresContext Must be equal to aFrame->PresContext(). - * @param aParentReflowState A reference to an nsHTMLReflowState object that + * @param aParentReflowState A reference to an ReflowInput object that * is to be the parent of this object. * @param aFrame The frame for whose reflow state is being constructed. * @param aAvailableSpace See comments for availableHeight and availableWidth * members. * @param aContainingBlockSize An optional size, in app units, specifying * the containing block size to use instead of the default which is * to use the aAvailableSpace. * @param aFlags A set of flags used for additional boolean parameters (see * below). */ - nsHTMLReflowState(nsPresContext* aPresContext, - const nsHTMLReflowState& aParentReflowState, + ReflowInput(nsPresContext* aPresContext, + const ReflowInput& aParentReflowState, nsIFrame* aFrame, const mozilla::LogicalSize& aAvailableSpace, const mozilla::LogicalSize* aContainingBlockSize = nullptr, uint32_t aFlags = 0); // Values for |aFlags| passed to constructor enum { // Indicates that the parent of this reflow state is "fake" (see @@ -734,17 +734,17 @@ public: static nscoord CalcLineHeight(nsIContent* aContent, nsStyleContext* aStyleContext, nscoord aBlockBSize, float aFontSizeInflation); mozilla::LogicalSize ComputeContainingBlockRectangle( nsPresContext* aPresContext, - const nsHTMLReflowState* aContainingBlockRS) const; + const ReflowInput* aContainingBlockRS) const; /** * Apply the mComputed(Min/Max)Width constraints to the content * size computed so far. */ nscoord ApplyMinMaxWidth(nscoord aWidth) const { if (NS_UNCONSTRAINEDSIZE != ComputedMaxWidth()) { aWidth = std::min(aWidth, ComputedMaxWidth()); @@ -900,28 +900,28 @@ public: ComputedLogicalOffsets(), aPosition, aContainerSize); } #ifdef DEBUG // Reflow trace methods. Defined in nsFrame.cpp so they have access // to the display-reflow infrastructure. static void* DisplayInitConstraintsEnter(nsIFrame* aFrame, - nsHTMLReflowState* aState, + ReflowInput* aState, nscoord aCBISize, nscoord aCBBSize, const nsMargin* aBorder, const nsMargin* aPadding); static void DisplayInitConstraintsExit(nsIFrame* aFrame, - nsHTMLReflowState* aState, + ReflowInput* aState, void* aValue); static void* DisplayInitFrameTypeEnter(nsIFrame* aFrame, - nsHTMLReflowState* aState); + ReflowInput* aState); static void DisplayInitFrameTypeExit(nsIFrame* aFrame, - nsHTMLReflowState* aState, + ReflowInput* aState, void* aValue); #endif protected: void InitFrameType(nsIAtom* aFrameType); void InitCBReflowState(); void InitResizeFlags(nsPresContext* aPresContext, nsIAtom* aFrameType); @@ -942,22 +942,22 @@ protected: // Calculate a "hypothetical box" position where the placeholder frame // (for a position:fixed/absolute element) would have been placed if it were // positioned statically. The hypothetical box position will have a writing // mode with the same block direction as the absolute containing block // (cbrs->frame), though it may differ in inline direction. void CalculateHypotheticalPosition(nsPresContext* aPresContext, nsIFrame* aPlaceholderFrame, - const nsHTMLReflowState* cbrs, + const ReflowInput* cbrs, nsHypotheticalPosition& aHypotheticalPos, nsIAtom* aFrameType) const; void InitAbsoluteConstraints(nsPresContext* aPresContext, - const nsHTMLReflowState* cbrs, + const ReflowInput* cbrs, const mozilla::LogicalSize& aContainingBlockSize, nsIAtom* aFrameType); // Calculates the computed values for the 'min-Width', 'max-Width', // 'min-Height', and 'max-Height' properties, and stores them in the assorted // data members void ComputeMinMaxValues(const mozilla::LogicalSize& aContainingBlockSize); @@ -969,9 +969,9 @@ protected: nscoord* aInsideBoxSizing, nscoord* aOutsideBoxSizing) const; void CalculateBlockSideMargins(nsIAtom* aFrameType); }; } // namespace mozilla -#endif // mozilla_nsHTMLReflowState_h +#endif // mozilla_ReflowInput_h
--- a/layout/generic/nsAbsoluteContainingBlock.cpp +++ b/layout/generic/nsAbsoluteContainingBlock.cpp @@ -105,17 +105,17 @@ nsAbsoluteContainingBlock::RemoveFrame(n } mAbsoluteFrames.DestroyFrame(aOldFrame); } void nsAbsoluteContainingBlock::Reflow(nsContainerFrame* aDelegatingFrame, nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aReflowStatus, const nsRect& aContainingBlock, AbsPosReflowFlags aFlags, nsOverflowAreas* aOverflowAreas) { nsReflowStatus reflowStatus = NS_FRAME_COMPLETE; const bool reflowAll = aReflowState.ShouldReflowAllKids(); @@ -211,17 +211,17 @@ nsAbsoluteContainingBlock::FrameDependsO // placeholder's position // This can happen in the following cases: // 1) Vertical positioning. "top" must be auto and "bottom" must be auto // (otherwise the vertical position is completely determined by // whichever of them is not auto and the height). // 2) Horizontal positioning. "left" must be auto and "right" must be auto // (otherwise the horizontal position is completely determined by // whichever of them is not auto and the width). - // See nsHTMLReflowState::InitAbsoluteConstraints -- these are the + // See ReflowInput::InitAbsoluteConstraints -- these are the // only cases when we call CalculateHypotheticalBox(). if ((pos->mOffset.GetTopUnit() == eStyleUnit_Auto && pos->mOffset.GetBottomUnit() == eStyleUnit_Auto) || (pos->mOffset.GetLeftUnit() == eStyleUnit_Auto && pos->mOffset.GetRightUnit() == eStyleUnit_Auto)) { return true; } if (!aCBWidthChanged && !aCBHeightChanged) { @@ -338,17 +338,17 @@ nsAbsoluteContainingBlock::DoMarkFramesD // When bug 154892 is checked in, make sure that when // mChildListID == kFixedList, the height is unconstrained. // since we don't allow replicated frames to split. void nsAbsoluteContainingBlock::ReflowAbsoluteFrame(nsIFrame* aDelegatingFrame, nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, const nsRect& aContainingBlock, AbsPosReflowFlags aFlags, nsIFrame* aKidFrame, nsReflowStatus& aStatus, nsOverflowAreas* aOverflowAreas) { #ifdef DEBUG if (nsBlockFrame::gNoisyReflow) { @@ -384,20 +384,20 @@ nsAbsoluteContainingBlock::ReflowAbsolut uint32_t rsFlags = 0; if (aFlags & AbsPosReflowFlags::eIsGridContainerCB) { // When a grid container generates the abs.pos. CB for a *child* then // the static-position is the CB origin (i.e. of the grid area rect). // https://drafts.csswg.org/css-grid/#static-position nsIFrame* placeholder = aPresContext->PresShell()->GetPlaceholderFrameFor(aKidFrame); if (placeholder && placeholder->GetParent() == aDelegatingFrame) { - rsFlags |= nsHTMLReflowState::STATIC_POS_IS_CB_ORIGIN; + rsFlags |= ReflowInput::STATIC_POS_IS_CB_ORIGIN; } } - nsHTMLReflowState kidReflowState(aPresContext, aReflowState, aKidFrame, + ReflowInput kidReflowState(aPresContext, aReflowState, aKidFrame, LogicalSize(wm, availISize, NS_UNCONSTRAINEDSIZE), &logicalCBSize, rsFlags); // Get the border values WritingMode outerWM = aReflowState.GetWritingMode(); const LogicalMargin border(outerWM, aReflowState.mStyleBorder->GetComputedBorder()); @@ -474,22 +474,22 @@ nsAbsoluteContainingBlock::ReflowAbsolut // Offset the frame rect by the given origin of the absolute containing block. // If the frame is auto-positioned on both sides of an axis, it will be // positioned based on its containing block and we don't need to offset // (unless the caller demands it (the STATIC_POS_IS_CB_ORIGIN case)). if (aContainingBlock.TopLeft() != nsPoint(0, 0)) { const nsStyleSides& offsets = kidReflowState.mStylePosition->mOffset; if (!(offsets.GetLeftUnit() == eStyleUnit_Auto && offsets.GetRightUnit() == eStyleUnit_Auto) || - (rsFlags & nsHTMLReflowState::STATIC_POS_IS_CB_ORIGIN)) { + (rsFlags & ReflowInput::STATIC_POS_IS_CB_ORIGIN)) { r.x += aContainingBlock.x; } if (!(offsets.GetTopUnit() == eStyleUnit_Auto && offsets.GetBottomUnit() == eStyleUnit_Auto) || - (rsFlags & nsHTMLReflowState::STATIC_POS_IS_CB_ORIGIN)) { + (rsFlags & ReflowInput::STATIC_POS_IS_CB_ORIGIN)) { r.y += aContainingBlock.y; } } aKidFrame->SetRect(r); nsView* view = aKidFrame->GetView(); if (view) {
--- a/layout/generic/nsAbsoluteContainingBlock.h +++ b/layout/generic/nsAbsoluteContainingBlock.h @@ -89,17 +89,17 @@ public: * @param aReflowStatus is assumed to be already-initialized, e.g. with the * status of the delegating frame's main reflow. This function merges in the * statuses of the absolutely positioned children's reflows. * * @param aFlags zero or more AbsPosReflowFlags */ void Reflow(nsContainerFrame* aDelegatingFrame, nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aReflowStatus, const nsRect& aContainingBlock, AbsPosReflowFlags aFlags, nsOverflowAreas* aOverflowAreas); void DestroyFrames(nsIFrame* aDelegatingFrame, nsIFrame* aDestructRoot); @@ -122,17 +122,17 @@ protected: * its placeholder or if the position or size of aFrame depends on a * containing block dimension that changed. */ bool FrameDependsOnContainer(nsIFrame* aFrame, bool aCBWidthChanged, bool aCBHeightChanged); void ReflowAbsoluteFrame(nsIFrame* aDelegatingFrame, nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, const nsRect& aContainingBlockRect, AbsPosReflowFlags aFlags, nsIFrame* aKidFrame, nsReflowStatus& aStatus, nsOverflowAreas* aOverflowAreas); /** * Mark our absolute frames dirty.
--- a/layout/generic/nsBRFrame.cpp +++ b/layout/generic/nsBRFrame.cpp @@ -33,17 +33,17 @@ public: virtual FrameSearchResult PeekOffsetCharacter(bool aForward, int32_t* aOffset, bool aRespectClusters = true) override; virtual FrameSearchResult PeekOffsetWord(bool aForward, bool aWordSelectEatSpace, bool aIsKeyboardSelect, int32_t* aOffset, PeekWordState* aState) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual void AddInlineMinISize(nsRenderingContext *aRenderingContext, InlineMinISizeData *aData) override; virtual void AddInlinePrefISize(nsRenderingContext *aRenderingContext, InlinePrefISizeData *aData) override; virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override; virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override; virtual nsIAtom* GetType() const override; @@ -76,17 +76,17 @@ NS_IMPL_FRAMEARENA_HELPERS(BRFrame) BRFrame::~BRFrame() { } void BRFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aMetrics, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("BRFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus); WritingMode wm = aReflowState.GetWritingMode(); LogicalSize finalSize(wm); finalSize.BSize(wm) = 0; // BR frames with block size 0 are ignored in quirks
--- a/layout/generic/nsBackdropFrame.cpp +++ b/layout/generic/nsBackdropFrame.cpp @@ -82,17 +82,17 @@ nsBackdropFrame::ComputeAutoSize(nsRende aBorder.ISize(aWM) - aPadding.ISize(aWM); } return result; } /* virtual */ void nsBackdropFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsBackdropFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); // Note that this frame is a child of the viewport frame. WritingMode wm = aReflowState.GetWritingMode();
--- a/layout/generic/nsBackdropFrame.h +++ b/layout/generic/nsBackdropFrame.h @@ -34,13 +34,13 @@ public: const LogicalSize& aCBSize, nscoord aAvailableISize, const LogicalSize& aMargin, const LogicalSize& aBorder, const LogicalSize& aPadding, bool aShrinkWrap) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; }; #endif // nsBackdropFrame_h___
--- a/layout/generic/nsBlockFrame.cpp +++ b/layout/generic/nsBlockFrame.cpp @@ -488,17 +488,17 @@ nsBlockFrame::GetCaretBaseline() const if (firstLine->GetChildCount()) { return bp.top + firstLine->mFirstChild->GetCaretBaseline(); } } float inflation = nsLayoutUtils::FontSizeInflationFor(this); RefPtr<nsFontMetrics> fm = nsLayoutUtils::GetFontMetricsForFrame(this, inflation); nscoord lineHeight = - nsHTMLReflowState::CalcLineHeight(GetContent(), StyleContext(), + ReflowInput::CalcLineHeight(GetContent(), StyleContext(), contentRect.height, inflation); const WritingMode wm = GetWritingMode(); return nsLayoutUtils::GetCenteredFontBaseline(fm, lineHeight, wm.IsLineInverted()) + bp.top; } ///////////////////////////////////////////////////////////////////////////// // Child frame enumeration @@ -931,17 +931,17 @@ AvailableSpaceShrunk(WritingMode aWM, } // Have we shrunk on either side? return aNewAvailableSpace.IStart(aWM) > aOldAvailableSpace.IStart(aWM) || aNewAvailableSpace.IEnd(aWM) < aOldAvailableSpace.IEnd(aWM); } static LogicalSize CalculateContainingBlockSizeForAbsolutes(WritingMode aWM, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, LogicalSize aFrameSize) { // The issue here is that for a 'height' of 'auto' the reflow state // code won't know how to calculate the containing block height // because it's calculated bottom up. So we use our own computed // size as the dimensions. nsIFrame* frame = aReflowState.frame; @@ -962,18 +962,18 @@ CalculateContainingBlockSizeForAbsolutes // frame is fully reflowed and using the resulting dimensions, even // if they're intrinsic. // In fact we should be attaching absolute children to the outermost // frame and not always sticking them in block frames. // First, find the reflow state for the outermost frame for this // content, except for fieldsets where the inner anonymous frame has // the correct padding area with the legend taken into account. - const nsHTMLReflowState* aLastRS = &aReflowState; - const nsHTMLReflowState* lastButOneRS = &aReflowState; + const ReflowInput* aLastRS = &aReflowState; + const ReflowInput* lastButOneRS = &aReflowState; while (aLastRS->mParentReflowState && aLastRS->mParentReflowState->frame->GetContent() == frame->GetContent() && aLastRS->mParentReflowState->frame->GetType() != nsGkAtoms::fieldSetFrame) { lastButOneRS = aLastRS; aLastRS = aLastRS->mParentReflowState; } if (aLastRS != &aReflowState) { // Scrollbars need to be specifically excluded, if present, because they are outside the @@ -1015,17 +1015,17 @@ CalculateContainingBlockSizeForAbsolutes } return cbSize; } void nsBlockFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aMetrics, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsBlockFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus); #ifdef DEBUG if (gNoisyReflow) { IndentBy(stdout, gNoiseIndent); @@ -1038,22 +1038,22 @@ nsBlockFrame::Reflow(nsPresContext* PRTime start = 0; // Initialize these variablies to silence the compiler. int32_t ctc = 0; // We only use these if they are set (gLameReflowMetrics). if (gLameReflowMetrics) { start = PR_Now(); ctc = nsLineBox::GetCtorCount(); } #endif - const nsHTMLReflowState *reflowState = &aReflowState; + const ReflowInput *reflowState = &aReflowState; WritingMode wm = aReflowState.GetWritingMode(); nscoord consumedBSize = GetConsumedBSize(); nscoord effectiveComputedBSize = GetEffectiveComputedBSize(aReflowState, consumedBSize); - Maybe<nsHTMLReflowState> mutableReflowState; + Maybe<ReflowInput> mutableReflowState; // If we have non-auto block size, we're clipping our kids and we fit, // make sure our kids fit too. if (aReflowState.AvailableBSize() != NS_UNCONSTRAINEDSIZE && aReflowState.ComputedBSize() != NS_AUTOHEIGHT && ShouldApplyOverflowClipping(this, aReflowState.mStyleDisplay)) { LogicalMargin blockDirExtras = aReflowState.ComputedLogicalBorderPadding(); if (GetLogicalSkipSides().BStart()) { blockDirExtras.BStart(wm) = 0; @@ -1072,17 +1072,17 @@ nsBlockFrame::Reflow(nsPresContext* } } // See comment below about oldSize. Use *only* for the // abs-pos-containing-block-size-change optimization! nsSize oldSize = GetSize(); // Should we create a float manager? - nsAutoFloatManager autoFloatManager(const_cast<nsHTMLReflowState&>(*reflowState)); + nsAutoFloatManager autoFloatManager(const_cast<ReflowInput&>(*reflowState)); // XXXldb If we start storing the float manager in the frame rather // than keeping it around only during reflow then we should create it // only when there are actually floats to manage. Otherwise things // like tables will gain significant bloat. bool needFloatManager = nsBlockFrame::BlockNeedsFloatManager(this); if (needFloatManager) autoFloatManager.CreateFloatManager(aPresContext); @@ -1471,17 +1471,17 @@ nsBlockFrame::CheckForCollapsedBEndMargi if (line->HasClearance()) { return true; } } // not reached } void -nsBlockFrame::ComputeFinalSize(const nsHTMLReflowState& aReflowState, +nsBlockFrame::ComputeFinalSize(const ReflowInput& aReflowState, nsBlockReflowState& aState, nsHTMLReflowMetrics& aMetrics, nscoord* aBEndEdgeOfChildren) { WritingMode wm = aState.mReflowState.GetWritingMode(); const LogicalMargin& borderPadding = aState.BorderPadding(); #ifdef NOISY_FINAL_SIZE ListTag(stdout); @@ -3207,21 +3207,21 @@ nsBlockFrame::ReflowBlockFrame(nsBlockRe // Setup a reflowState to get the style computed block-start margin // value. We'll use a reason of `resize' so that we don't fudge // any incremental reflow state. // The availSpace here is irrelevant to our needs - all we want // out if this setup is the block-start margin value which doesn't depend // on the childs available space. - // XXX building a complete nsHTMLReflowState just to get the block-start + // XXX building a complete ReflowInput just to get the block-start // margin seems like a waste. And we do this for almost every block! WritingMode wm = frame->GetWritingMode(); LogicalSize availSpace = aState.ContentSize(wm); - nsHTMLReflowState reflowState(aState.mPresContext, aState.mReflowState, + ReflowInput reflowState(aState.mPresContext, aState.mReflowState, frame, availSpace); if (treatWithClearance) { aState.mBCoord += aState.mPrevBEndMargin.get(); aState.mPrevBEndMargin.Zero(); } // Now compute the collapsed margin-block-start value into @@ -3349,17 +3349,17 @@ nsBlockFrame::ReflowBlockFrame(nsBlockRe aState.mBCoord -= bStartMargin; availSpace.BStart(wm) -= bStartMargin; if (NS_UNCONSTRAINEDSIZE != availSpace.BSize(wm)) { availSpace.BSize(wm) += bStartMargin; } // construct the html reflow state for the block. ReflowBlock // will initialize it. - Maybe<nsHTMLReflowState> blockHtmlRS; + Maybe<ReflowInput> blockHtmlRS; blockHtmlRS.emplace( aState.mPresContext, aState.mReflowState, frame, availSpace.Size(wm).ConvertTo(frame->GetWritingMode(), wm)); nsFloatManager::SavedState floatManagerState; nsReflowStatus frameReflowStatus; do { if (floatAvailableSpace.mHasFloats) { @@ -6091,17 +6091,17 @@ nsBlockFrame::ComputeFloatISize(nsBlockR "aFloat must be an out-of-flow frame"); // Reflow the float. LogicalRect availSpace = AdjustFloatAvailableSpace(aState, aFloatAvailableSpace, aFloat); WritingMode blockWM = aState.mReflowState.GetWritingMode(); WritingMode floatWM = aFloat->GetWritingMode(); - nsHTMLReflowState + ReflowInput floatRS(aState.mPresContext, aState.mReflowState, aFloat, availSpace.Size(blockWM).ConvertTo(floatWM, blockWM)); return floatRS.ComputedSizeWithMarginBorderPadding(blockWM).ISize(blockWM); } void nsBlockFrame::ReflowFloat(nsBlockReflowState& aState, @@ -6121,17 +6121,17 @@ nsBlockFrame::ReflowFloat(nsBlockReflowS #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) ); #endif - nsHTMLReflowState + ReflowInput floatRS(aState.mPresContext, aState.mReflowState, aFloat, aAdjustedAvailableSpace.Size(wm).ConvertTo(aFloat->GetWritingMode(), wm)); // Normally the mIsTopOfPage state is copied from the parent reflow // state. However, when reflowing a float, if we've placed other // floats that force this float *down* or *narrower*, we should unset // the mIsTopOfPage state. @@ -7171,29 +7171,29 @@ nsBlockFrame::RenumberListsFor(nsPresCon } void nsBlockFrame::ReflowBullet(nsIFrame* aBulletFrame, nsBlockReflowState& aState, nsHTMLReflowMetrics& aMetrics, nscoord aLineTop) { - const nsHTMLReflowState &rs = aState.mReflowState; + const ReflowInput &rs = aState.mReflowState; // Reflow the bullet now WritingMode bulletWM = aBulletFrame->GetWritingMode(); LogicalSize availSize(bulletWM); // Make up an inline-size since it doesn't really matter (XXX). availSize.ISize(bulletWM) = aState.ContentISize(); availSize.BSize(bulletWM) = NS_UNCONSTRAINEDSIZE; // Get the reason right. // XXXwaterson Should this look just like the logic in // nsBlockReflowContext::ReflowBlock and nsLineLayout::ReflowFrame? - nsHTMLReflowState reflowState(aState.mPresContext, rs, + ReflowInput reflowState(aState.mPresContext, rs, aBulletFrame, availSize); nsReflowStatus status; aBulletFrame->Reflow(aState.mPresContext, aMetrics, reflowState, status); // Get the float available space using our saved state from before we // started reflowing the block, so that we ignore any floats inside // the block. // FIXME: aLineTop isn't actually set correctly by some callers, since @@ -7412,17 +7412,17 @@ nsBlockFrame::ISizeToClearPastFloats(con // want to displace if the width won't compute to a value small enough // to fit. // All we really need here is the result of ComputeSize, and we // could *almost* get that from an nsCSSOffsetState, except for the // last argument. WritingMode frWM = aFrame->GetWritingMode(); LogicalSize availSpace = LogicalSize(wm, availISize, NS_UNCONSTRAINEDSIZE). ConvertTo(frWM, wm); - nsHTMLReflowState reflowState(aState.mPresContext, aState.mReflowState, + ReflowInput reflowState(aState.mPresContext, aState.mReflowState, aFrame, availSpace); result.borderBoxISize = reflowState.ComputedSizeWithBorderPadding().ConvertTo(wm, frWM).ISize(wm); // Use the margins from offsetState rather than reflowState so that // they aren't reduced by ignoring margins in overconstrained cases. LogicalMargin computedMargin = offsetState.ComputedLogicalMargin().ConvertTo(wm, frWM); result.marginIStart = computedMargin.IStart(wm); @@ -7443,17 +7443,17 @@ nsBlockFrame::GetNearestAncestorBlock(ns // Not a block. Check its parent next. aCandidate = aCandidate->GetParent(); } NS_NOTREACHED("Fell off frame tree looking for ancestor block!"); return nullptr; } void -nsBlockFrame::ComputeFinalBSize(const nsHTMLReflowState& aReflowState, +nsBlockFrame::ComputeFinalBSize(const ReflowInput& aReflowState, nsReflowStatus* aStatus, nscoord aContentBSize, const LogicalMargin& aBorderPadding, LogicalSize& aFinalSize, nscoord aConsumed) { WritingMode wm = aReflowState.GetWritingMode(); // Figure out how much of the computed height should be
--- a/layout/generic/nsBlockFrame.h +++ b/layout/generic/nsBlockFrame.h @@ -246,26 +246,26 @@ public: * to either this or the available block-size, whichever is larger, in * the case where our available block-size is constrained, and we * overflow that available block-size. * @param aBorderPadding The margins representing the border padding for block * frames. Can be 0. * @param aFinalSize Out parameter for final block-size. * @param aConsumed The block-size already consumed by our previous-in-flows. */ - void ComputeFinalBSize(const nsHTMLReflowState& aReflowState, + void ComputeFinalBSize(const ReflowInput& aReflowState, nsReflowStatus* aStatus, nscoord aContentBSize, const mozilla::LogicalMargin& aBorderPadding, mozilla::LogicalSize& aFinalSize, nscoord aConsumed); virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsresult AttributeChanged(int32_t aNameSpaceID, nsIAtom* aAttribute, int32_t aModType) override; /** * Move any frames on our overflow list to the end of our principal list. @@ -405,17 +405,17 @@ protected: nsLineBox* aLine, nscoord aDeltaBCoord); void UpdateLineContainerSize(nsLineBox* aLine, const nsSize& aNewContainerSize); // helper for SlideLine and UpdateLineContainerSize void MoveChildFramesOfLine(nsLineBox* aLine, nscoord aDeltaBCoord); - void ComputeFinalSize(const nsHTMLReflowState& aReflowState, + void ComputeFinalSize(const ReflowInput& aReflowState, nsBlockReflowState& aState, nsHTMLReflowMetrics& aMetrics, nscoord* aBottomEdgeOfChildren); void ComputeOverflowAreas(const nsRect& aBounds, const nsStyleDisplay* aDisplay, nscoord aBottomEdgeOfChildren, nsOverflowAreas& aOverflowAreas);
--- a/layout/generic/nsBlockReflowContext.cpp +++ b/layout/generic/nsBlockReflowContext.cpp @@ -23,17 +23,17 @@ using namespace mozilla; #undef NOISY_BLOCK_DIR_MARGINS #else #undef NOISY_MAX_ELEMENT_SIZE #undef REALLY_NOISY_MAX_ELEMENT_SIZE #undef NOISY_BLOCK_DIR_MARGINS #endif nsBlockReflowContext::nsBlockReflowContext(nsPresContext* aPresContext, - const nsHTMLReflowState& aParentRS) + const ReflowInput& aParentRS) : mPresContext(aPresContext), mOuterReflowState(aParentRS), mSpace(aParentRS.GetWritingMode()), mMetrics(aParentRS) { } static nsIFrame* DescendIntoBlockLevelFrame(nsIFrame* aFrame) @@ -45,17 +45,17 @@ static nsIFrame* DescendIntoBlockLevelFr if (child) { return DescendIntoBlockLevelFrame(child); } } return aFrame; } bool -nsBlockReflowContext::ComputeCollapsedBStartMargin(const nsHTMLReflowState& aRS, +nsBlockReflowContext::ComputeCollapsedBStartMargin(const ReflowInput& aRS, nsCollapsingMargin* aMargin, nsIFrame* aClearanceFrame, bool* aMayNeedRetry, bool* aBlockIsEmpty) { WritingMode wm = aRS.GetWritingMode(); WritingMode parentWM = mMetrics.GetWritingMode(); @@ -147,28 +147,28 @@ nsBlockReflowContext::ComputeCollapsedBS // child blocks margin and so in so that we can look into // it. For its margins to be computed we need to have a reflow // state for it. // We may have to construct an extra reflow state here if // we drilled down through a block wrapper. At the moment // we can only drill down one level so we only have to support // one extra reflow state. - const nsHTMLReflowState* outerReflowState = &aRS; + const ReflowInput* outerReflowState = &aRS; if (frame != aRS.frame) { NS_ASSERTION(frame->GetParent() == aRS.frame, "Can only drill through one level of block wrapper"); LogicalSize availSpace = aRS.ComputedSize(frame->GetWritingMode()); - outerReflowState = new nsHTMLReflowState(prescontext, + outerReflowState = new ReflowInput(prescontext, aRS, frame, availSpace); } { LogicalSize availSpace = outerReflowState->ComputedSize(kid->GetWritingMode()); - nsHTMLReflowState innerReflowState(prescontext, + ReflowInput innerReflowState(prescontext, *outerReflowState, kid, availSpace); // Record that we're being optimistic by assuming the kid // has no clearance if (kid->StyleDisplay()->mBreakType != NS_STYLE_CLEAR_NONE || !nsBlockFrame::BlockCanIntersectFloats(kid)) { *aMayNeedRetry = true; } @@ -181,17 +181,17 @@ nsBlockReflowContext::ComputeCollapsedBS if (isEmpty) { WritingMode innerWM = innerReflowState.GetWritingMode(); LogicalMargin innerMargin = innerReflowState.ComputedLogicalMargin().ConvertTo(parentWM, innerWM); aMargin->Include(innerMargin.BEnd(parentWM)); } } if (outerReflowState != &aRS) { - delete const_cast<nsHTMLReflowState*>(outerReflowState); + delete const_cast<ReflowInput*>(outerReflowState); } } if (!isEmpty) { if (!setBlockIsEmpty && aBlockIsEmpty) { setBlockIsEmpty = true; *aBlockIsEmpty = false; } goto done; @@ -222,17 +222,17 @@ nsBlockReflowContext::ComputeCollapsedBS void nsBlockReflowContext::ReflowBlock(const LogicalRect& aSpace, bool aApplyBStartMargin, nsCollapsingMargin& aPrevMargin, nscoord aClearance, bool aIsAdjacentWithBStart, nsLineBox* aLine, - nsHTMLReflowState& aFrameRS, + ReflowInput& aFrameRS, nsReflowStatus& aFrameReflowStatus, nsBlockReflowState& aState) { mFrame = aFrameRS.frame; mWritingMode = aState.mReflowState.GetWritingMode(); mContainerSize = aState.ContainerSize(); mSpace = aSpace; @@ -352,17 +352,17 @@ nsBlockReflowContext::ReflowBlock(const } /** * Attempt to place the block frame within the available space. If * it fits, apply inline-dir ("horizontal") positioning (CSS 10.3.3), * collapse margins (CSS2 8.3.1). Also apply relative positioning. */ bool -nsBlockReflowContext::PlaceBlock(const nsHTMLReflowState& aReflowState, +nsBlockReflowContext::PlaceBlock(const ReflowInput& aReflowState, bool aForceFit, nsLineBox* aLine, nsCollapsingMargin& aBEndMarginResult, nsOverflowAreas& aOverflowAreas, nsReflowStatus aReflowStatus) { // Compute collapsed block-end margin value. WritingMode wm = aReflowState.GetWritingMode();
--- a/layout/generic/nsBlockReflowContext.h +++ b/layout/generic/nsBlockReflowContext.h @@ -15,34 +15,34 @@ class nsBlockReflowState; class nsLineBox; class nsPresContext; /** * An encapsulation of the state and algorithm for reflowing block frames. */ class nsBlockReflowContext { - using nsHTMLReflowState = mozilla::nsHTMLReflowState; + using ReflowInput = mozilla::ReflowInput; public: nsBlockReflowContext(nsPresContext* aPresContext, - const nsHTMLReflowState& aParentRS); + const ReflowInput& aParentRS); ~nsBlockReflowContext() { } void ReflowBlock(const mozilla::LogicalRect& aSpace, bool aApplyBStartMargin, nsCollapsingMargin& aPrevMargin, nscoord aClearance, bool aIsAdjacentWithBStart, nsLineBox* aLine, - nsHTMLReflowState& aReflowState, + ReflowInput& aReflowState, nsReflowStatus& aReflowStatus, nsBlockReflowState& aState); - bool PlaceBlock(const nsHTMLReflowState& aReflowState, + bool PlaceBlock(const ReflowInput& aReflowState, bool aForceFit, nsLineBox* aLine, nsCollapsingMargin& aBEndMarginResult /* out */, nsOverflowAreas& aOverflowAreas, nsReflowStatus aReflowStatus); nsCollapsingMargin& GetCarriedOutBEndMargin() { return mMetrics.mCarriedOutBEndMargin; @@ -66,25 +66,25 @@ public: * there); also, this function is responsible for marking it with * SetHasClearance. * If in the optimistic pass any frame is encountered that might possibly * need clearance (i.e., if we really needed the optimism assumption) then * we set aMayNeedRetry to true. * We return true if we changed the clearance state of any line and marked it * dirty. */ - bool ComputeCollapsedBStartMargin(const nsHTMLReflowState& aRS, + bool ComputeCollapsedBStartMargin(const ReflowInput& aRS, nsCollapsingMargin* aMargin, nsIFrame* aClearanceFrame, bool* aMayNeedRetry, bool* aIsEmpty = nullptr); protected: nsPresContext* mPresContext; - const nsHTMLReflowState& mOuterReflowState; + const ReflowInput& mOuterReflowState; nsIFrame* mFrame; mozilla::LogicalRect mSpace; nscoord mICoord, mBCoord; nsSize mContainerSize; mozilla::WritingMode mWritingMode; nsHTMLReflowMetrics mMetrics;
--- a/layout/generic/nsBlockReflowState.cpp +++ b/layout/generic/nsBlockReflowState.cpp @@ -23,17 +23,17 @@ #endif using namespace mozilla; using namespace mozilla::layout; static bool sFloatFragmentsInsideColumnEnabled; static bool sFloatFragmentsInsideColumnPrefCached; -nsBlockReflowState::nsBlockReflowState(const nsHTMLReflowState& aReflowState, +nsBlockReflowState::nsBlockReflowState(const ReflowInput& aReflowState, nsPresContext* aPresContext, nsBlockFrame* aFrame, bool aBStartMarginRoot, bool aBEndMarginRoot, bool aBlockNeedsFloatManager, nscoord aConsumedBSize) : mBlock(aFrame), mPresContext(aPresContext), @@ -671,17 +671,17 @@ nsBlockReflowState::CanPlaceFloat(nscoor } // Return the inline-size that the float (including margins) will take up // in the writing mode of the containing block. If this returns // NS_UNCONSTRAINEDSIZE, we're dealing with an orthogonal block that // has block-size:auto, and we'll need to actually reflow it to find out // how much inline-size it will occupy in the containing block's mode. static nscoord -FloatMarginISize(const nsHTMLReflowState& aCBReflowState, +FloatMarginISize(const ReflowInput& aCBReflowState, nscoord aFloatAvailableISize, nsIFrame *aFloat, const nsCSSOffsetState& aFloatOffsetState) { AutoMaybeDisableFontInflation an(aFloat); WritingMode wm = aFloatOffsetState.GetWritingMode(); LogicalSize floatSize = @@ -947,17 +947,17 @@ nsBlockReflowState::FlowAndPlaceFloat(ns // Calculate the actual origin of the float frame's border rect // relative to the parent block; the margin must be added in // to get the border rect LogicalPoint origin(wm, floatMargin.IStart(wm) + floatPos.I(wm), floatMargin.BStart(wm) + floatPos.B(wm)); // If float is relatively positioned, factor that in as well - nsHTMLReflowState::ApplyRelativePositioning(aFloat, wm, floatOffsets, + ReflowInput::ApplyRelativePositioning(aFloat, wm, floatOffsets, &origin, ContainerSize()); // Position the float and make sure and views are properly // positioned. We need to explicitly position its child views as // well, since we're moving the float after flowing it. bool moved = aFloat->GetLogicalPosition(wm, ContainerSize()) != origin; if (moved) { aFloat->SetPosition(wm, origin, ContainerSize());
--- a/layout/generic/nsBlockReflowState.h +++ b/layout/generic/nsBlockReflowState.h @@ -15,17 +15,17 @@ class nsBlockFrame; class nsFrameList; class nsOverflowContinuationTracker; // Block reflow state flags. // // BRS_UNCONSTRAINEDBSIZE is set in the nsBlockReflowState constructor when the // frame being reflowed has been given NS_UNCONSTRAINEDSIZE as its available -// BSize in the nsHTMLReflowState. If set, NS_UNCONSTRAINEDSIZE is passed to +// BSize in the ReflowInput. If set, NS_UNCONSTRAINEDSIZE is passed to // nsLineLayout as the available BSize. #define BRS_UNCONSTRAINEDBSIZE 0x00000001 // BRS_ISBSTARTMARGINROOT is set in the nsBlockReflowState constructor when // reflowing a "block margin root" frame (i.e. a frame with the // NS_BLOCK_MARGIN_ROOT flag set, for which margins apply by default). // // The flag is also set when reflowing a frame whose computed BStart border // padding is non-zero. @@ -67,23 +67,23 @@ class nsOverflowContinuationTracker; #define BRS_ISOVERFLOWCONTAINER 0x00000100 // Our mPushedFloats list is stored on the blocks' proptable #define BRS_PROPTABLE_FLOATCLIST 0x00000200 // Set when the pref layout.float-fragments-inside-column.enabled is true. #define BRS_FLOAT_FRAGMENTS_INSIDE_COLUMN_ENABLED 0x00000400 #define BRS_LASTFLAG BRS_FLOAT_FRAGMENTS_INSIDE_COLUMN_ENABLED // nsBlockReflowState contains additional reflow state information that the -// block frame uses along with nsHTMLReflowState. Like nsHTMLReflowState, this +// block frame uses along with ReflowInput. Like ReflowInput, this // is read-only data that is passed down from a parent frame to its children. class nsBlockReflowState { - using nsHTMLReflowState = mozilla::nsHTMLReflowState; + using ReflowInput = mozilla::ReflowInput; public: - nsBlockReflowState(const nsHTMLReflowState& aReflowState, + nsBlockReflowState(const ReflowInput& aReflowState, nsPresContext* aPresContext, nsBlockFrame* aFrame, bool aBStartMarginRoot, bool aBEndMarginRoot, bool aBlockNeedsFloatManager, nscoord aConsumedBSize = NS_INTRINSICSIZE); /** * Get the available reflow space (the area not occupied by floats) @@ -202,17 +202,17 @@ public: // This state is the "global" state computed once for the reflow of // the block. // The block frame that is using this object nsBlockFrame* mBlock; nsPresContext* mPresContext; - const nsHTMLReflowState& mReflowState; + const ReflowInput& mReflowState; nsFloatManager* mFloatManager; // The coordinates within the float manager where the block is being // placed <b>after</b> taking into account the blocks border and // padding. This, therefore, represents the inner "content area" (in // spacemanager coordinates) where child frames will be placed, // including child blocks and floats.
--- a/layout/generic/nsBulletFrame.cpp +++ b/layout/generic/nsBulletFrame.cpp @@ -626,17 +626,17 @@ nsBulletFrame::GetDesiredSize(nsPresCont break; } aMetrics.SetSize(wm, finalSize); } void nsBulletFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aMetrics, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsBulletFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus); float inflation = nsLayoutUtils::FontSizeInflationFor(this); SetFontSizeInflation(inflation);
--- a/layout/generic/nsBulletFrame.h +++ b/layout/generic/nsBulletFrame.h @@ -73,17 +73,17 @@ public: virtual nsIAtom* GetType() const override; virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext) override; #ifdef DEBUG_FRAME_DUMP virtual nsresult GetFrameName(nsAString& aResult) const override; #endif virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aMetrics, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override; virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override; void AddInlineMinISize(nsRenderingContext* aRenderingContext, nsIFrame::InlineMinISizeData* aData) override; void AddInlinePrefISize(nsRenderingContext* aRenderingContext, nsIFrame::InlinePrefISizeData* aData) override;
--- a/layout/generic/nsCanvasFrame.cpp +++ b/layout/generic/nsCanvasFrame.cpp @@ -568,17 +568,17 @@ nsCanvasFrame::GetPrefISize(nsRenderingC else result = mFrames.FirstChild()->GetPrefISize(aRenderingContext); return result; } void nsCanvasFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsCanvasFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); NS_FRAME_TRACE_REFLOW_IN("nsCanvasFrame::Reflow"); // Initialize OUT parameter @@ -615,17 +615,17 @@ nsCanvasFrame::Reflow(nsPresContext* nsHTMLReflowMetrics kidDesiredSize(aReflowState); if (mFrames.IsEmpty()) { // We have no child frame, so return an empty size aDesiredSize.Width() = aDesiredSize.Height() = 0; } else { nsIFrame* kidFrame = mFrames.FirstChild(); bool kidDirty = (kidFrame->GetStateBits() & NS_FRAME_IS_DIRTY) != 0; - nsHTMLReflowState + ReflowInput kidReflowState(aPresContext, aReflowState, kidFrame, aReflowState.AvailableSize(kidFrame->GetWritingMode())); if (aReflowState.IsBResizeForWM(kidReflowState.GetWritingMode()) && (kidFrame->GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_BSIZE)) { // Tell our kid it's being block-dir resized too. Bit of a // hack for framesets. kidReflowState.SetBResize(true);
--- a/layout/generic/nsCanvasFrame.h +++ b/layout/generic/nsCanvasFrame.h @@ -67,17 +67,17 @@ public: virtual void RemoveFrame(ChildListID aListID, nsIFrame* aOldFrame) override; #endif virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override; virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual bool IsFrameOfType(uint32_t aFlags) const override { return nsContainerFrame::IsFrameOfType(aFlags & ~(nsIFrame::eCanContainOverflowContainers)); } // nsIAnonymousContentCreator
--- a/layout/generic/nsColumnSetFrame.cpp +++ b/layout/generic/nsColumnSetFrame.cpp @@ -150,30 +150,30 @@ nsColumnSetFrame::PaintColumnRule(nsRend skipSides); child = nextSibling; nextSibling = nextSibling->GetNextSibling(); } } static nscoord -GetAvailableContentISize(const nsHTMLReflowState& aReflowState) +GetAvailableContentISize(const ReflowInput& aReflowState) { if (aReflowState.AvailableISize() == NS_INTRINSICSIZE) { return NS_INTRINSICSIZE; } WritingMode wm = aReflowState.GetWritingMode(); nscoord borderPaddingISize = aReflowState.ComputedLogicalBorderPadding().IStartEnd(wm); return std::max(0, aReflowState.AvailableISize() - borderPaddingISize); } nscoord -nsColumnSetFrame::GetAvailableContentBSize(const nsHTMLReflowState& aReflowState) +nsColumnSetFrame::GetAvailableContentBSize(const ReflowInput& aReflowState) { if (aReflowState.AvailableBSize() == NS_INTRINSICSIZE) { return NS_INTRINSICSIZE; } WritingMode wm = aReflowState.GetWritingMode(); LogicalMargin bp = aReflowState.ComputedLogicalBorderPadding(); bp.ApplySkipSides(GetLogicalSkipSides(&aReflowState)); @@ -193,17 +193,17 @@ GetColumnGap(nsColumnSetFrame* aFrame return colGap; } NS_NOTREACHED("Unknown gap type"); return 0; } nsColumnSetFrame::ReflowConfig -nsColumnSetFrame::ChooseColumnStrategy(const nsHTMLReflowState& aReflowState, +nsColumnSetFrame::ChooseColumnStrategy(const ReflowInput& aReflowState, bool aForceAuto = false, nscoord aFeasibleBSize = NS_INTRINSICSIZE, nscoord aInfeasibleBSize = 0) { nscoord knownFeasibleBSize = aFeasibleBSize; nscoord knownInfeasibleBSize = aInfeasibleBSize; const nsStyleColumn* colStyle = StyleColumn(); @@ -231,17 +231,17 @@ nsColumnSetFrame::ChooseColumnStrategy(c int32_t numColumns = colStyle->mColumnCount; // If column-fill is set to 'balance', then we want to balance the columns. const bool isBalancing = colStyle->mColumnFill == NS_STYLE_COLUMN_FILL_BALANCE && !aForceAuto; if (isBalancing) { const uint32_t MAX_NESTED_COLUMN_BALANCING = 2; uint32_t cnt = 0; - for (const nsHTMLReflowState* rs = aReflowState.mParentReflowState; + for (const ReflowInput* rs = aReflowState.mParentReflowState; rs && cnt < MAX_NESTED_COLUMN_BALANCING; rs = rs->mParentReflowState) { if (rs->mFlags.mIsColumnBalancing) { ++cnt; } } if (cnt == MAX_NESTED_COLUMN_BALANCING) { numColumns = 1; } @@ -338,17 +338,17 @@ nsColumnSetFrame::ChooseColumnStrategy(c ReflowConfig config = { numColumns, colISize, expectedISizeLeftOver, colGap, colBSize, isBalancing, knownFeasibleBSize, knownInfeasibleBSize, computedBSize, consumedBSize }; return config; } bool nsColumnSetFrame::ReflowColumns(nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aReflowStatus, ReflowConfig& aConfig, bool aLastColumnUnbounded, nsCollapsingMargin* aCarriedOutBEndMargin, ColumnBalanceData& aColData) { bool feasible = ReflowChildren(aDesiredSize, aReflowState, aReflowStatus, aConfig, aLastColumnUnbounded, @@ -445,17 +445,17 @@ nsColumnSetFrame::GetPrefISize(nsRenderi // The multiplication above can make 'iSize' negative (integer overflow), // so use std::max to protect against that. result = std::max(iSize, colISize); return result; } bool nsColumnSetFrame::ReflowChildren(nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus, const ReflowConfig& aConfig, bool aUnboundedLastColumn, nsCollapsingMargin* aCarriedOutBEndMargin, ColumnBalanceData& aColData) { aColData.Reset(); bool allFit = true; @@ -601,17 +601,17 @@ nsColumnSetFrame::ReflowChildren(nsHTMLR } LogicalSize computedSize = aReflowState.ComputedSize(wm); if (reflowNext) child->AddStateBits(NS_FRAME_IS_DIRTY); LogicalSize kidCBSize(wm, availSize.ISize(wm), computedSize.BSize(wm)); - nsHTMLReflowState kidReflowState(PresContext(), aReflowState, child, + ReflowInput kidReflowState(PresContext(), aReflowState, child, availSize, &kidCBSize); kidReflowState.mFlags.mIsTopOfPage = true; kidReflowState.mFlags.mTableIsSplittable = false; kidReflowState.mFlags.mIsColumnBalancing = aConfig.mBalanceColCount < INT32_MAX; // We need to reflow any float placeholders, even if our column height // hasn't changed. kidReflowState.mFlags.mMustReflowPlaceholders = !colBSizeChanged; @@ -856,17 +856,17 @@ nsColumnSetFrame::DrainOverflowColumns() if (overflows) { // We're already the parent for these frames, so no need to set // their parent again. mFrames.AppendFrames(nullptr, *overflows); } } void -nsColumnSetFrame::FindBestBalanceBSize(const nsHTMLReflowState& aReflowState, +nsColumnSetFrame::FindBestBalanceBSize(const ReflowInput& aReflowState, nsPresContext* aPresContext, ReflowConfig& aConfig, ColumnBalanceData& aColData, nsHTMLReflowMetrics& aDesiredSize, nsCollapsingMargin& aOutMargin, bool& aUnboundedLastColumn, bool& aRunWasFeasible, nsReflowStatus& aStatus) @@ -1016,17 +1016,17 @@ nsColumnSetFrame::FindBestBalanceBSize(c } aRunWasFeasible = feasible; } void nsColumnSetFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); // Don't support interruption in columns nsPresContext::InterruptPreventer noInterrupts(aPresContext); DO_GLOBAL_REFLOW_COUNT("nsColumnSetFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
--- a/layout/generic/nsColumnSetFrame.h +++ b/layout/generic/nsColumnSetFrame.h @@ -21,17 +21,17 @@ class nsColumnSetFrame final : public ns { public: NS_DECL_FRAMEARENA_HELPERS explicit nsColumnSetFrame(nsStyleContext* aContext); virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; #ifdef DEBUG virtual void SetInitialChildList(ChildListID aListID, nsFrameList& aChildList) override; virtual void AppendFrames(ChildListID aListID, nsFrameList& aFrameList) override; virtual void InsertFrames(ChildListID aListID, @@ -43,17 +43,17 @@ public: virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override; virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override; /** * Retrieve the available height for content of this frame. The available content * height is the available height for the frame, minus borders and padding. */ - virtual nscoord GetAvailableContentBSize(const nsHTMLReflowState& aReflowState); + virtual nscoord GetAvailableContentBSize(const ReflowInput& aReflowState); virtual nsContainerFrame* GetContentInsertionFrame() override { nsIFrame* frame = PrincipalChildList().FirstChild(); // if no children return nullptr if (!frame) return nullptr; @@ -157,31 +157,31 @@ protected: void Reset() { mMaxBSize = mSumBSize = mLastBSize = mMaxOverflowingBSize = 0; mHasExcessBSize = false; } }; bool ReflowColumns(nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aReflowStatus, ReflowConfig& aConfig, bool aLastColumnUnbounded, nsCollapsingMargin* aCarriedOutBEndMargin, ColumnBalanceData& aColData); /** * The basic reflow strategy is to call this function repeatedly to * obtain specific parameters that determine the layout of the * columns. This function will compute those parameters from the CSS * style. This function will also be responsible for implementing * the state machine that controls column balancing. */ - ReflowConfig ChooseColumnStrategy(const nsHTMLReflowState& aReflowState, + ReflowConfig ChooseColumnStrategy(const ReflowInput& aReflowState, bool aForceAuto, nscoord aFeasibleBSize, nscoord aInfeasibleBSize); /** * Perform the binary search for the best balance height for this column set. * * @param aReflowState The input parameters for the current reflow iteration. * @param aPresContext The presentation context in which the current reflow @@ -199,31 +199,31 @@ protected: * balancing procedure to measure the height of all content in * descendant frames of the column set. * @param aRunWasFeasible An input/output parameter indicating whether or not * the last iteration of the balancing loop was a feasible height to * fit all content from descendant frames. * @param aStatus A final reflow status of the column set frame, passed in as * an output parameter. */ - void FindBestBalanceBSize(const nsHTMLReflowState& aReflowState, + void FindBestBalanceBSize(const ReflowInput& aReflowState, nsPresContext* aPresContext, ReflowConfig& aConfig, ColumnBalanceData& aColData, nsHTMLReflowMetrics& aDesiredSize, nsCollapsingMargin& aOutMargin, bool& aUnboundedLastColumn, bool& aRunWasFeasible, nsReflowStatus& aStatus); /** * Reflow column children. Returns true iff the content that was reflowed * fit into the mColMaxBSize. */ bool ReflowChildren(nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus, const ReflowConfig& aConfig, bool aLastColumnUnbounded, nsCollapsingMargin* aCarriedOutBEndMargin, ColumnBalanceData& aColData); }; #endif // nsColumnSetFrame_h___
--- a/layout/generic/nsContainerFrame.cpp +++ b/layout/generic/nsContainerFrame.cpp @@ -990,17 +990,17 @@ nsContainerFrame::ComputeAutoSize(nsRend } return result; } void nsContainerFrame::ReflowChild(nsIFrame* aKidFrame, nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, const WritingMode& aWM, const LogicalPoint& aPos, const nsSize& aContainerSize, uint32_t aFlags, nsReflowStatus& aStatus, nsOverflowContinuationTracker* aTracker) { NS_PRECONDITION(aReflowState.frame == aKidFrame, "bad reflow state"); @@ -1038,17 +1038,17 @@ nsContainerFrame::ReflowChild(nsIFrame* } //XXX temporary: hold on to a copy of the old physical version of // ReflowChild so that we can convert callers incrementally. void nsContainerFrame::ReflowChild(nsIFrame* aKidFrame, nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nscoord aX, nscoord aY, uint32_t aFlags, nsReflowStatus& aStatus, nsOverflowContinuationTracker* aTracker) { NS_PRECONDITION(aReflowState.frame == aKidFrame, "bad reflow state"); @@ -1131,17 +1131,17 @@ nsContainerFrame::PositionChildViews(nsI * NS_FRAME_NO_MOVE_VIEW - don't position the frame's view. Set this if you * don't want to automatically sync the frame and view * NS_FRAME_NO_SIZE_VIEW - don't size the frame's view */ void nsContainerFrame::FinishReflowChild(nsIFrame* aKidFrame, nsPresContext* aPresContext, const nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState* aReflowState, + const ReflowInput* aReflowState, const WritingMode& aWM, const LogicalPoint& aPos, const nsSize& aContainerSize, uint32_t aFlags) { if (aWM.IsVerticalRL() || (!aWM.IsVertical() && !aWM.IsBidiLTR())) { NS_ASSERTION(aContainerSize.width != NS_UNCONSTRAINEDSIZE, "FinishReflowChild with unconstrained container width!"); @@ -1180,17 +1180,17 @@ nsContainerFrame::FinishReflowChild(nsIF } //XXX temporary: hold on to a copy of the old physical version of // FinishReflowChild so that we can convert callers incrementally. void nsContainerFrame::FinishReflowChild(nsIFrame* aKidFrame, nsPresContext* aPresContext, const nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState* aReflowState, + const ReflowInput* aReflowState, nscoord aX, nscoord aY, uint32_t aFlags) { nsPoint curOrigin = aKidFrame->GetPosition(); if (NS_FRAME_NO_MOVE_FRAME != (aFlags & NS_FRAME_NO_MOVE_FRAME)) { aKidFrame->SetRect(nsRect(aX, aY, aDesiredSize.Width(), aDesiredSize.Height())); @@ -1215,17 +1215,17 @@ nsContainerFrame::FinishReflowChild(nsIF } } aKidFrame->DidReflow(aPresContext, aReflowState, nsDidReflowStatus::FINISHED); } void nsContainerFrame::ReflowOverflowContainerChildren(nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsOverflowAreas& aOverflowRects, uint32_t aFlags, nsReflowStatus& aStatus, ChildFrameMerger aMergeFunc) { NS_PRECONDITION(aPresContext, "null pointer"); nsFrameList* overflowContainers = DrainExcessOverflowContainersList(aMergeFunc); @@ -1254,17 +1254,17 @@ nsContainerFrame::ReflowOverflowContaine WritingMode wm = frame->GetWritingMode(); nsSize containerSize = aReflowState.AvailableSize(wm).GetPhysicalSize(wm); LogicalRect prevRect = prevInFlow->GetLogicalRect(wm, containerSize); // Initialize reflow params LogicalSize availSpace(wm, prevRect.ISize(wm), aReflowState.AvailableSize(wm).BSize(wm)); nsHTMLReflowMetrics desiredSize(aReflowState); - nsHTMLReflowState frameState(aPresContext, aReflowState, + ReflowInput frameState(aPresContext, aReflowState, frame, availSpace); nsReflowStatus frameStatus; // Reflow LogicalPoint pos(wm, prevRect.IStart(wm), 0); ReflowChild(frame, aPresContext, desiredSize, frameState, wm, pos, containerSize, aFlags, frameStatus, &tracker); //XXXfr Do we need to override any shrinkwrap effects here?
--- a/layout/generic/nsContainerFrame.h +++ b/layout/generic/nsContainerFrame.h @@ -250,17 +250,17 @@ public: * NS_FRAME_NO_MOVE_VIEW - don't position the frame's view. Set this if you * don't want to automatically sync the frame and view * NS_FRAME_NO_MOVE_FRAME - don't move the frame. aPos is ignored in this * case. Also implies NS_FRAME_NO_MOVE_VIEW */ void ReflowChild(nsIFrame* aChildFrame, nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, const mozilla::WritingMode& aWM, const mozilla::LogicalPoint& aPos, const nsSize& aContainerSize, uint32_t aFlags, nsReflowStatus& aStatus, nsOverflowContinuationTracker* aTracker = nullptr); /** @@ -280,39 +280,39 @@ public: * case. Also implies NS_FRAME_NO_MOVE_VIEW * NS_FRAME_NO_MOVE_VIEW - don't position the frame's view. Set this if you * don't want to automatically sync the frame and view * NS_FRAME_NO_SIZE_VIEW - don't size the frame's view */ static void FinishReflowChild(nsIFrame* aKidFrame, nsPresContext* aPresContext, const nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState* aReflowState, + const ReflowInput* aReflowState, const mozilla::WritingMode& aWM, const mozilla::LogicalPoint& aPos, const nsSize& aContainerSize, uint32_t aFlags); //XXX temporary: hold on to a copy of the old physical versions of // ReflowChild and FinishReflowChild so that we can convert callers // incrementally. void ReflowChild(nsIFrame* aKidFrame, nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nscoord aX, nscoord aY, uint32_t aFlags, nsReflowStatus& aStatus, nsOverflowContinuationTracker* aTracker = nullptr); static void FinishReflowChild(nsIFrame* aKidFrame, nsPresContext* aPresContext, const nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState* aReflowState, + const ReflowInput* aReflowState, nscoord aX, nscoord aY, uint32_t aFlags); static void PositionChildViews(nsIFrame* aFrame); // ========================================================================== /* Overflow containers are continuation frames that hold overflow. They @@ -383,17 +383,17 @@ public: * continuations it makes, removing them from its child list, and * making sure they are stored properly in the overflow container lists. * The nsOverflowContinuationTracker helper class should be used for this. * * @param aFlags is passed through to ReflowChild * @param aMergeFunc is passed to DrainExcessOverflowContainersList */ void ReflowOverflowContainerChildren(nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsOverflowAreas& aOverflowRects, uint32_t aFlags, nsReflowStatus& aStatus, ChildFrameMerger aMergeFunc = DefaultChildFrameMerge); /** * Move any frames on our overflow list to the end of our principal list.
--- a/layout/generic/nsFirstLetterFrame.cpp +++ b/layout/generic/nsFirstLetterFrame.cpp @@ -159,17 +159,17 @@ nsFirstLetterFrame::ComputeSize(nsRender } return nsContainerFrame::ComputeSize(aRenderingContext, aWM, aCBSize, aAvailableISize, aMargin, aBorder, aPadding, aFlags); } void nsFirstLetterFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aMetrics, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aReflowStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsFirstLetterFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aReflowStatus); // Grab overflow list DrainOverflowFrames(aPresContext); @@ -192,17 +192,17 @@ nsFirstLetterFrame::Reflow(nsPresContext // Reflow the child if (!aReflowState.mLineLayout) { // When there is no lineLayout provided, we provide our own. The // only time that the first-letter-frame is not reflowing in a // line context is when its floating. WritingMode kidWritingMode = GetWritingMode(kid); LogicalSize kidAvailSize = availSize.ConvertTo(kidWritingMode, wm); - nsHTMLReflowState rs(aPresContext, aReflowState, kid, kidAvailSize); + ReflowInput rs(aPresContext, aReflowState, kid, kidAvailSize); nsLineLayout ll(aPresContext, nullptr, &aReflowState, nullptr, nullptr); ll.BeginLineReflow(bp.IStart(wm), bp.BStart(wm), availSize.ISize(wm), NS_UNCONSTRAINEDSIZE, false, true, kidWritingMode, nsSize(aReflowState.AvailableWidth(), aReflowState.AvailableHeight())); rs.mLineLayout = ≪ @@ -393,17 +393,17 @@ nsFirstLetterFrame::DrainOverflowFrames( nscoord nsFirstLetterFrame::GetLogicalBaseline(WritingMode aWritingMode) const { return mBaseline; } nsIFrame::LogicalSides -nsFirstLetterFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const +nsFirstLetterFrame::GetLogicalSkipSides(const ReflowInput* aReflowState) const { if (GetPrevContinuation()) { // We shouldn't get calls to GetSkipSides for later continuations since // they have separate style contexts with initial values for all the // properties that could trigger a call to GetSkipSides. Then again, // it's not really an error to call GetSkipSides on any frame, so // that's why we handle it properly. return LogicalSides(eLogicalSideBitsAll);
--- a/layout/generic/nsFirstLetterFrame.h +++ b/layout/generic/nsFirstLetterFrame.h @@ -57,22 +57,22 @@ public: nscoord aAvailableISize, const mozilla::LogicalSize& aMargin, const mozilla::LogicalSize& aBorder, const mozilla::LogicalSize& aPadding, ComputeSizeFlags aFlags) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual bool CanContinueTextRun() const override; virtual nscoord GetLogicalBaseline(mozilla::WritingMode aWritingMode) const override; - virtual LogicalSides GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const override; + virtual LogicalSides GetLogicalSkipSides(const ReflowInput* aReflowState = nullptr) const override; //override of nsFrame method virtual nsresult GetChildFrameContainingOffset(int32_t inContentOffset, bool inHint, int32_t* outFrameContentOffset, nsIFrame** outChildFrame) override; nscoord GetFirstLetterBaseline() const { return mBaseline; }
--- a/layout/generic/nsFlexContainerFrame.cpp +++ b/layout/generic/nsFlexContainerFrame.cpp @@ -405,17 +405,17 @@ private: * Represents a flex item. * Includes the various pieces of input that the Flexbox Layout Algorithm uses * to resolve a flexible width. */ class nsFlexContainerFrame::FlexItem : public LinkedListElement<FlexItem> { public: // Normal constructor: - FlexItem(nsHTMLReflowState& aFlexItemReflowState, + FlexItem(ReflowInput& aFlexItemReflowState, float aFlexGrow, float aFlexShrink, nscoord aMainBaseSize, nscoord aMainMinSize, nscoord aMainMaxSize, nscoord aTentativeCrossSize, nscoord aCrossMinSize, nscoord aCrossMaxSize, const FlexboxAxisTracker& aAxisTracker); // Simplified constructor, to be used only for generating "struts": // (NOTE: This "strut" constructor uses the *container's* writing mode, which @@ -739,17 +739,17 @@ public: uint32_t GetNumAutoMarginsInAxis(AxisOrientationType aAxis) const; // Once the main size has been resolved, should we bother doing layout to // establish the cross size? bool CanMainSizeInfluenceCrossSize(const FlexboxAxisTracker& aAxisTracker) const; protected: // Helper called by the constructor, to set mNeedsMinSizeAutoResolution: - void CheckForMinSizeAuto(const nsHTMLReflowState& aFlexItemReflowState, + void CheckForMinSizeAuto(const ReflowInput& aFlexItemReflowState, const FlexboxAxisTracker& aAxisTracker); // Our frame: nsIFrame* const mFrame; // Values that we already know in constructor: (and are hence mostly 'const') const float mFlexGrow; const float mFlexShrink; @@ -1176,23 +1176,23 @@ nsFlexContainerFrame::IsHorizontal() const FlexboxAxisTracker axisTracker(this, GetWritingMode()); return axisTracker.IsMainAxisHorizontal(); } UniquePtr<FlexItem> nsFlexContainerFrame::GenerateFlexItemForChild( nsPresContext* aPresContext, nsIFrame* aChildFrame, - const nsHTMLReflowState& aParentReflowState, + const ReflowInput& aParentReflowState, const FlexboxAxisTracker& aAxisTracker) { // Create temporary reflow state just for sizing -- to get hypothetical // main-size and the computed values of min / max main-size property. // (This reflow state will _not_ be used for reflow.) - nsHTMLReflowState + ReflowInput childRS(aPresContext, aParentReflowState, aChildFrame, aParentReflowState.ComputedSize(aChildFrame->GetWritingMode())); // FLEX GROW & SHRINK WEIGHTS // -------------------------- float flexGrow, flexShrink; if (IsLegacyBox(aParentReflowState.mStyleDisplay, mStyleContext)) { flexGrow = flexShrink = aChildFrame->StyleXUL()->mBoxFlex; @@ -1210,17 +1210,17 @@ nsFlexContainerFrame::GenerateFlexItemFo childRS.ComputedISize(), childRS.ComputedBSize()); nscoord mainMinSize = GET_MAIN_COMPONENT_LOGICAL(aAxisTracker, childWM, childRS.ComputedMinISize(), childRS.ComputedMinBSize()); nscoord mainMaxSize = GET_MAIN_COMPONENT_LOGICAL(aAxisTracker, childWM, childRS.ComputedMaxISize(), childRS.ComputedMaxBSize()); - // This is enforced by the nsHTMLReflowState where these values come from: + // This is enforced by the ReflowInput where these values come from: MOZ_ASSERT(mainMinSize <= mainMaxSize, "min size is larger than max size"); // CROSS SIZES (tentative cross size, min/max cross size) // ------------------------------------------------------ // Grab the cross size from the reflow state. This might be the right value, // or we might resolve it to something else in SizeItemInCrossAxis(); hence, // it's tentative. See comment under "Cross Size Determination" for more. nscoord tentativeCrossSize = @@ -1309,17 +1309,17 @@ nsFlexContainerFrame::GenerateFlexItemFo } // Static helper-functions for ResolveAutoFlexBasisAndMinSize(): // ------------------------------------------------------------- // Indicates whether the cross-size property is set to something definite. // The logic here should be similar to the logic for isAutoWidth/isAutoHeight // in nsLayoutUtils::ComputeSizeWithIntrinsicDimensions(). static bool -IsCrossSizeDefinite(const nsHTMLReflowState& aItemReflowState, +IsCrossSizeDefinite(const ReflowInput& aItemReflowState, const FlexboxAxisTracker& aAxisTracker) { const nsStylePosition* pos = aItemReflowState.mStylePosition; if (aAxisTracker.IsCrossAxisHorizontal()) { return pos->mWidth.GetUnit() != eStyleUnit_Auto; } // else, vertical. (We need to use IsAutoHeight() to catch e.g. %-height // applied to indefinite-height containing block, which counts as auto.) @@ -1337,17 +1337,17 @@ IsCrossSizeDefinite(const nsHTMLReflowSt // param is true, then this function is guaranteed to return a definite value // (i.e. not NS_AUTOHEIGHT, excluding cases where huge sizes are involved). // // XXXdholbert the min-size behavior here is based on my understanding in // http://lists.w3.org/Archives/Public/www-style/2014Jul/0053.html // If my understanding there ends up being wrong, we'll need to update this. static nscoord CrossSizeToUseWithRatio(const FlexItem& aFlexItem, - const nsHTMLReflowState& aItemReflowState, + const ReflowInput& aItemReflowState, bool aMinSizeFallback, const FlexboxAxisTracker& aAxisTracker) { if (aFlexItem.IsStretched()) { // Definite cross-size, imposed via 'align-self:stretch' & flex container. return aFlexItem.GetCrossSize(); } @@ -1393,17 +1393,17 @@ MainSizeFromAspectRatio(nscoord aCrossSi // By "partially", I mean we don't consider the min-content size (but we do // consider flex-basis, main max-size, and the intrinsic aspect ratio). // The caller is responsible for computing & considering the min-content size // in combination with the partially-resolved value that this function returns. // // Spec reference: http://dev.w3.org/csswg/css-flexbox/#min-size-auto static nscoord PartiallyResolveAutoMinSize(const FlexItem& aFlexItem, - const nsHTMLReflowState& aItemReflowState, + const ReflowInput& aItemReflowState, const FlexboxAxisTracker& aAxisTracker) { MOZ_ASSERT(aFlexItem.NeedsMinSizeAutoResolution(), "only call for FlexItems that need min-size auto resolution"); nscoord minMainSize = nscoord_MAX; // Intentionally huge; we'll shrink it // from here, w/ std::min(). @@ -1452,17 +1452,17 @@ PartiallyResolveAutoMinSize(const FlexIt } // Resolves flex-basis:auto, using the given intrinsic ratio and the flex // item's cross size. On success, updates the flex item with its resolved // flex-basis and returns true. On failure (e.g. if the ratio is invalid or // the cross-size is indefinite), returns false. static bool ResolveAutoFlexBasisFromRatio(FlexItem& aFlexItem, - const nsHTMLReflowState& aItemReflowState, + const ReflowInput& aItemReflowState, const FlexboxAxisTracker& aAxisTracker) { MOZ_ASSERT(NS_AUTOHEIGHT == aFlexItem.GetFlexBaseSize(), "Should only be called to resolve an 'auto' flex-basis"); // If the flex item has ... // - an intrinsic aspect ratio, // - a [used] flex-basis of 'main-size' [auto?] [We have this, if we're here.] // - a definite cross size @@ -1488,17 +1488,17 @@ ResolveAutoFlexBasisFromRatio(FlexItem& } // Note: If & when we handle "min-height: min-content" for flex items, // we may want to resolve that in this function, too. void nsFlexContainerFrame:: ResolveAutoFlexBasisAndMinSize(nsPresContext* aPresContext, FlexItem& aFlexItem, - const nsHTMLReflowState& aItemReflowState, + const ReflowInput& aItemReflowState, const FlexboxAxisTracker& aAxisTracker) { // (Note: We should never have a used flex-basis of "auto" if our main axis // is horizontal; width values should always be resolvable without reflow.) const bool isMainSizeAuto = (!aAxisTracker.IsMainAxisHorizontal() && NS_AUTOHEIGHT == aFlexItem.GetFlexBaseSize()); const bool isMainMinSizeAuto = aFlexItem.NeedsMinSizeAutoResolution(); @@ -1513,17 +1513,17 @@ nsFlexContainerFrame:: // (e.g. using it as a contstraint when measuring our content in the // main axis, or using it with the intrinsic ratio to obtain a main size). // BEFORE WE DO THAT, we need let the item "pre-stretch" its cross size (if // it's got 'align-self:stretch'), for a certain case where the spec says // the stretched cross size is considered "definite". That case is if we // have a single-line (nowrap) flex container which itself has a definite // cross-size. Otherwise, we'll wait to do stretching, since (in other // cases) we don't know how much the item should stretch yet. - const nsHTMLReflowState* flexContainerRS = aItemReflowState.mParentReflowState; + const ReflowInput* flexContainerRS = aItemReflowState.mParentReflowState; MOZ_ASSERT(flexContainerRS, "flex item's reflow state should have ptr to container's state"); if (NS_STYLE_FLEX_WRAP_NOWRAP == flexContainerRS->mStylePosition->mFlexWrap) { // XXXdholbert Maybe this should share logic with ComputeCrossSize()... // Alternately, maybe tentative container cross size should be passed down. nscoord containerCrossSize = GET_CROSS_COMPONENT_LOGICAL(aAxisTracker, aAxisTracker.GetWritingMode(), flexContainerRS->ComputedISize(), @@ -1609,26 +1609,26 @@ nsFlexContainerFrame:: } } nscoord nsFlexContainerFrame:: MeasureFlexItemContentHeight(nsPresContext* aPresContext, FlexItem& aFlexItem, bool aForceVerticalResizeForMeasuringReflow, - const nsHTMLReflowState& aParentReflowState) + const ReflowInput& aParentReflowState) { // Set up a reflow state for measuring the flex item's auto-height: WritingMode wm = aFlexItem.Frame()->GetWritingMode(); LogicalSize availSize = aParentReflowState.ComputedSize(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; - nsHTMLReflowState + ReflowInput childRSForMeasuringHeight(aPresContext, aParentReflowState, aFlexItem.Frame(), availSize, - nullptr, nsHTMLReflowState::CALLER_WILL_INIT); + nullptr, ReflowInput::CALLER_WILL_INIT); childRSForMeasuringHeight.mFlags.mIsFlexContainerMeasuringHeight = true; childRSForMeasuringHeight.Init(aPresContext); if (aFlexItem.IsStretched()) { childRSForMeasuringHeight.SetComputedWidth(aFlexItem.GetCrossSize()); childRSForMeasuringHeight.SetHResize(true); } @@ -1664,17 +1664,17 @@ nsFlexContainerFrame:: // Subtract border/padding in vertical axis, to get _just_ // the effective computed value of the "height" property. nscoord childDesiredHeight = childDesiredSize.Height() - childRSForMeasuringHeight.ComputedPhysicalBorderPadding().TopBottom(); return std::max(0, childDesiredHeight); } -FlexItem::FlexItem(nsHTMLReflowState& aFlexItemReflowState, +FlexItem::FlexItem(ReflowInput& aFlexItemReflowState, float aFlexGrow, float aFlexShrink, nscoord aFlexBaseSize, nscoord aMainMinSize, nscoord aMainMaxSize, nscoord aTentativeCrossSize, nscoord aCrossMinSize, nscoord aCrossMaxSize, const FlexboxAxisTracker& aAxisTracker) : mFrame(aFlexItemReflowState.frame), mFlexGrow(aFlexGrow), mFlexShrink(aFlexShrink), @@ -1701,17 +1701,17 @@ FlexItem::FlexItem(nsHTMLReflowState& aF // mAlignSelf, see below { MOZ_ASSERT(mFrame, "expecting a non-null child frame"); MOZ_ASSERT(mFrame->GetType() != nsGkAtoms::placeholderFrame, "placeholder frames should not be treated as flex items"); MOZ_ASSERT(!(mFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW), "out-of-flow frames should not be treated as flex items"); - const nsHTMLReflowState* containerRS = aFlexItemReflowState.mParentReflowState; + const ReflowInput* containerRS = aFlexItemReflowState.mParentReflowState; if (IsLegacyBox(containerRS->mStyleDisplay, containerRS->frame->StyleContext())) { // For -webkit-box/-webkit-inline-box, we need to: // (1) Use "-webkit-box-align" instead of "align-items" to determine the // container's cross-axis alignment behavior. // (2) Suppress the ability for flex items to override that with their own // cross-axis alignment. (The legacy box model doesn't support this.) // So, each FlexItem simply copies the container's converted "align-items" @@ -1801,17 +1801,17 @@ FlexItem::FlexItem(nsIFrame* aChildFrame "Should only make struts for children with 'visibility:collapse'"); MOZ_ASSERT(mFrame->GetType() != nsGkAtoms::placeholderFrame, "placeholder frames should not be treated as flex items"); MOZ_ASSERT(!(mFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW), "out-of-flow frames should not be treated as flex items"); } void -FlexItem::CheckForMinSizeAuto(const nsHTMLReflowState& aFlexItemReflowState, +FlexItem::CheckForMinSizeAuto(const ReflowInput& aFlexItemReflowState, const FlexboxAxisTracker& aAxisTracker) { const nsStylePosition* pos = aFlexItemReflowState.mStylePosition; const nsStyleDisplay* disp = aFlexItemReflowState.mStyleDisplay; // We'll need special behavior for "min-[width|height]:auto" (whichever is in // the main axis) iff: // (a) its computed value is "auto" @@ -3358,17 +3358,17 @@ AddNewFlexLineToList(LinkedList<FlexLine aLines.insertBack(newLine); } return newLine; } void nsFlexContainerFrame::GenerateFlexLines( nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nscoord aContentBoxMainSize, nscoord aAvailableBSizeForContent, const nsTArray<StrutInfo>& aStruts, const FlexboxAxisTracker& aAxisTracker, LinkedList<FlexLine>& aLines) { MOZ_ASSERT(aLines.isEmpty(), "Expecting outparam to start out empty"); @@ -3473,17 +3473,17 @@ nsFlexContainerFrame::GenerateFlexLines( } } // Retrieves the content-box main-size of our flex container from the // reflow state (specifically, the main-size of *this continuation* of the // flex container). nscoord nsFlexContainerFrame::GetMainSizeFromReflowState( - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, const FlexboxAxisTracker& aAxisTracker) { if (aAxisTracker.IsRowOriented()) { // Row-oriented --> our main axis is the inline axis, so our main size // is our inline size (which should already be resolved). // XXXdholbert ISize may be (wrongly) unconstrained right now: bug 1163238 // Uncomment when that's fixed: /* @@ -3523,17 +3523,17 @@ GetLargestLineMainSize(const FlexLine* a * XXXdholbert (this^ isn't quite true, if we're row-oriented and in an * orthogonal flow, per mentions of bug 1163238 in GetMainSizeFromReflowState.) * * (Note: This function should be structurally similar to 'ComputeCrossSize()', * except that here, the caller has already grabbed the tentative size from the * reflow state.) */ static nscoord -ResolveFlexContainerMainSize(const nsHTMLReflowState& aReflowState, +ResolveFlexContainerMainSize(const ReflowInput& aReflowState, const FlexboxAxisTracker& aAxisTracker, nscoord aTentativeMainSize, nscoord aAvailableBSizeForContent, const FlexLine* aFirstLine, nsReflowStatus& aStatus) { MOZ_ASSERT(aFirstLine, "null first line pointer"); @@ -3576,17 +3576,17 @@ ResolveFlexContainerMainSize(const nsHTM // XXXdholbert Handle constrained-aAvailableBSizeForContent case here. nscoord largestLineOuterSize = GetLargestLineMainSize(aFirstLine); return NS_CSS_MINMAX(largestLineOuterSize, aReflowState.ComputedMinBSize(), aReflowState.ComputedMaxBSize()); } nscoord -nsFlexContainerFrame::ComputeCrossSize(const nsHTMLReflowState& aReflowState, +nsFlexContainerFrame::ComputeCrossSize(const ReflowInput& aReflowState, const FlexboxAxisTracker& aAxisTracker, nscoord aSumLineCrossSizes, nscoord aAvailableBSizeForContent, bool* aIsDefinite, nsReflowStatus& aStatus) { MOZ_ASSERT(aIsDefinite, "outparam pointer must be non-null"); @@ -3675,30 +3675,30 @@ FlexLine::PositionItemsInMainAxis(uint8_ * flex container's content-box cross-start edge to its baseline), returns * its actual physical ascent value (the distance from the *border-box* top * edge to its baseline). */ static nscoord ComputePhysicalAscentFromFlexRelativeAscent( nscoord aFlexRelativeAscent, nscoord aContentBoxCrossSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, const FlexboxAxisTracker& aAxisTracker) { return aReflowState.ComputedPhysicalBorderPadding().top + PhysicalCoordFromFlexRelativeCoord(aFlexRelativeAscent, aContentBoxCrossSize, aAxisTracker.GetCrossAxis()); } void nsFlexContainerFrame::SizeItemInCrossAxis( nsPresContext* aPresContext, const FlexboxAxisTracker& aAxisTracker, - nsHTMLReflowState& aChildReflowState, + ReflowInput& aChildReflowState, FlexItem& aItem) { if (aAxisTracker.IsCrossAxisHorizontal()) { MOZ_ASSERT(aItem.HasIntrinsicRatio(), "For now, caller's CanMainSizeInfluenceCrossSize check should " "only allow us to get here for items with intrinsic ratio"); // XXXdholbert When we finish support for vertical writing-modes, // (in bug 1079155 or a dependency), we'll relax the horizontal check in @@ -3803,17 +3803,17 @@ FlexLine::PositionItemsInCrossAxis(nscoo // Back out to cross-axis edge of the line. lineCrossAxisPosnTracker.ResetPosition(); } } void nsFlexContainerFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsFlexContainerFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); MOZ_LOG(gFlexContainerLog, LogLevel::Debug, ("Reflow() for nsFlexContainerFrame %p\n", this)); @@ -3946,17 +3946,17 @@ public: private: const FrameProperties mItemProps; MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER }; void nsFlexContainerFrame::DoFlexLayout(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus, nscoord aContentBoxMainSize, nscoord aAvailableBSizeForContent, nsTArray<StrutInfo>& aStruts, const FlexboxAxisTracker& aAxisTracker) { aStatus = NS_FRAME_COMPLETE; @@ -3996,17 +3996,17 @@ nsFlexContainerFrame::DoFlexLayout(nsPre // been constructed, since the main size shouldn't influence anything // about cross-size measurement until we actually reflow the child.) sizeOverride.emplace(*item); } WritingMode wm = item->Frame()->GetWritingMode(); LogicalSize availSize = aReflowState.ComputedSize(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; - nsHTMLReflowState childReflowState(aPresContext, aReflowState, + ReflowInput childReflowState(aPresContext, aReflowState, item->Frame(), availSize); if (!sizeOverride) { // Directly override the computed main-size, by tweaking reflow state: if (aAxisTracker.IsMainAxisHorizontal()) { childReflowState.SetComputedWidth(item->GetMainSize()); } else { childReflowState.SetComputedHeight(item->GetMainSize()); } @@ -4253,53 +4253,53 @@ nsFlexContainerFrame::DoFlexLayout(nsPre FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize, aReflowState, aStatus); NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize) } void nsFlexContainerFrame::MoveFlexItemToFinalPosition( - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, const FlexItem& aItem, LogicalPoint& aFramePos, const nsSize& aContainerSize) { WritingMode outerWM = aReflowState.GetWritingMode(); // If item is relpos, look up its offsets (cached from prev reflow) LogicalMargin logicalOffsets(outerWM); if (NS_STYLE_POSITION_RELATIVE == aItem.Frame()->StyleDisplay()->mPosition) { FrameProperties props = aItem.Frame()->Properties(); nsMargin* cachedOffsets = props.Get(nsIFrame::ComputedOffsetProperty()); MOZ_ASSERT(cachedOffsets, "relpos previously-reflowed frame should've cached its offsets"); logicalOffsets = LogicalMargin(outerWM, *cachedOffsets); } - nsHTMLReflowState::ApplyRelativePositioning(aItem.Frame(), outerWM, + ReflowInput::ApplyRelativePositioning(aItem.Frame(), outerWM, logicalOffsets, &aFramePos, aContainerSize); aItem.Frame()->SetPosition(outerWM, aFramePos, aContainerSize); PositionFrameView(aItem.Frame()); PositionChildViews(aItem.Frame()); } void nsFlexContainerFrame::ReflowFlexItem(nsPresContext* aPresContext, const FlexboxAxisTracker& aAxisTracker, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, const FlexItem& aItem, LogicalPoint& aFramePos, const nsSize& aContainerSize) { WritingMode outerWM = aReflowState.GetWritingMode(); WritingMode wm = aItem.Frame()->GetWritingMode(); LogicalSize availSize = aReflowState.ComputedSize(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; - nsHTMLReflowState childReflowState(aPresContext, aReflowState, + ReflowInput childReflowState(aPresContext, aReflowState, aItem.Frame(), availSize); // Keep track of whether we've overriden the child's computed height // and/or width, so we can set its resize flags accordingly. bool didOverrideComputedWidth = false; bool didOverrideComputedHeight = false; // Override computed main-size @@ -4370,17 +4370,17 @@ nsFlexContainerFrame::ReflowFlexItem(nsP // unconstrained available height, which means they should always // complete. MOZ_ASSERT(NS_FRAME_IS_COMPLETE(childReflowStatus), "We gave flex item unconstrained available height, so it " "should be complete"); LogicalMargin offsets = childReflowState.ComputedLogicalOffsets().ConvertTo(outerWM, wm); - nsHTMLReflowState::ApplyRelativePositioning(aItem.Frame(), outerWM, + ReflowInput::ApplyRelativePositioning(aItem.Frame(), outerWM, offsets, &aFramePos, aContainerSize); FinishReflowChild(aItem.Frame(), aPresContext, childDesiredSize, &childReflowState, outerWM, aFramePos, aContainerSize, 0); // Save the first child's ascent; it may establish container's baseline.
--- a/layout/generic/nsFlexContainerFrame.h +++ b/layout/generic/nsFlexContainerFrame.h @@ -59,17 +59,17 @@ public: // nsIFrame overrides virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nscoord GetMinISize(nsRenderingContext* aRenderingContext) override; virtual nscoord GetPrefISize(nsRenderingContext* aRenderingContext) override; virtual nsIAtom* GetType() const override; @@ -97,17 +97,17 @@ protected: * * (The logic behind the division of work between Reflow and DoFlexLayout is * as follows: DoFlexLayout() begins at the step that we have to jump back * to, if we find any visibility:collapse children, and Reflow() does * everything before that point.) */ void DoFlexLayout(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus, nscoord aContentBoxMainSize, nscoord aAvailableBSizeForContent, nsTArray<StrutInfo>& aStruts, const FlexboxAxisTracker& aAxisTracker); /** * Checks whether our child-frame list "mFrames" is sorted, using the given @@ -134,65 +134,65 @@ protected: * Before returning, this method also processes the FlexItem to resolve its * flex basis (including e.g. auto-height) as well as to resolve * "min-height:auto", via ResolveAutoFlexBasisAndMinSize(). (Basically, the * returned FlexItem will be ready to participate in the "Resolve the * Flexible Lengths" step of the Flex Layout Algorithm.) */ mozilla::UniquePtr<FlexItem> GenerateFlexItemForChild(nsPresContext* aPresContext, nsIFrame* aChildFrame, - const nsHTMLReflowState& aParentReflowState, + const ReflowInput& aParentReflowState, const FlexboxAxisTracker& aAxisTracker); /** * This method performs a "measuring" reflow to get the content height of * aFlexItem.Frame() (treating it as if it had auto-height), & returns the * resulting height. * (Helper for ResolveAutoFlexBasisAndMinSize().) */ nscoord MeasureFlexItemContentHeight(nsPresContext* aPresContext, FlexItem& aFlexItem, bool aForceVerticalResizeForMeasuringReflow, - const nsHTMLReflowState& aParentReflowState); + const ReflowInput& aParentReflowState); /** * This method resolves an "auto" flex-basis and/or min-main-size value * on aFlexItem, if needed. * (Helper for GenerateFlexItemForChild().) */ void ResolveAutoFlexBasisAndMinSize(nsPresContext* aPresContext, FlexItem& aFlexItem, - const nsHTMLReflowState& aItemReflowState, + const ReflowInput& aItemReflowState, const FlexboxAxisTracker& aAxisTracker); // Creates FlexItems for all of our child frames, arranged in a list of // FlexLines. These are returned by reference in |aLines|. Our actual // return value has to be |nsresult|, in case we have to reflow a child // to establish its flex base size and that reflow fails. void GenerateFlexLines(nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nscoord aContentBoxMainSize, nscoord aAvailableBSizeForContent, const nsTArray<StrutInfo>& aStruts, const FlexboxAxisTracker& aAxisTracker, mozilla::LinkedList<FlexLine>& aLines); - nscoord GetMainSizeFromReflowState(const nsHTMLReflowState& aReflowState, + nscoord GetMainSizeFromReflowState(const ReflowInput& aReflowState, const FlexboxAxisTracker& aAxisTracker); - nscoord ComputeCrossSize(const nsHTMLReflowState& aReflowState, + nscoord ComputeCrossSize(const ReflowInput& aReflowState, const FlexboxAxisTracker& aAxisTracker, nscoord aSumLineCrossSizes, nscoord aAvailableBSizeForContent, bool* aIsDefinite, nsReflowStatus& aStatus); void SizeItemInCrossAxis(nsPresContext* aPresContext, const FlexboxAxisTracker& aAxisTracker, - nsHTMLReflowState& aChildReflowState, + ReflowInput& aChildReflowState, FlexItem& aItem); /** * Moves the given flex item's frame to the given LogicalPosition (modulo any * relative positioning). * * This can be used in cases where we've already done a "measuring reflow" * for the flex item at the correct size, and hence can skip its final reflow @@ -200,17 +200,17 @@ protected: * * @param aReflowState The flex container's reflow state. * @param aItem The flex item whose frame should be moved. * @param aFramePos The position where the flex item's frame should * be placed. (pre-relative positioning) * @param aContainerSize The flex container's size (required by some methods * that we call, to interpret aFramePos correctly). */ - void MoveFlexItemToFinalPosition(const nsHTMLReflowState& aReflowState, + void MoveFlexItemToFinalPosition(const ReflowInput& aReflowState, const FlexItem& aItem, mozilla::LogicalPoint& aFramePos, const nsSize& aContainerSize); /** * Helper-function to reflow a child frame, at its final position determined * by flex layout. * * @param aPresContext The presentation context being used in reflow. @@ -219,17 +219,17 @@ protected: * @param aItem The flex item to be reflowed. * @param aFramePos The position where the flex item's frame should * be placed. (pre-relative positioning) * @param aContainerSize The flex container's size (required by some methods * that we call, to interpret aFramePos correctly). */ void ReflowFlexItem(nsPresContext* aPresContext, const FlexboxAxisTracker& aAxisTracker, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, const FlexItem& aItem, mozilla::LogicalPoint& aFramePos, const nsSize& aContainerSize); bool mChildrenHaveBeenReordered; // Have we ever had to reorder our kids // to satisfy their 'order' values? };
--- a/layout/generic/nsFloatManager.h +++ b/layout/generic/nsFloatManager.h @@ -15,17 +15,17 @@ #include "nsFrameList.h" // for DEBUG_FRAME_DUMP #include "nsIntervalSet.h" #include "nsTArray.h" class nsIPresShell; class nsIFrame; class nsPresContext; namespace mozilla { -struct nsHTMLReflowState; +struct ReflowInput; } // namespace mozilla /** * The available space for content not occupied by floats is divided * into a sequence of rectangles in the block direction. However, we * need to know not only the rectangle, but also whether it was reduced * (from the content rectangle) by floats that actually intruded into * the content rectangle. @@ -368,33 +368,33 @@ private: }; /** * A helper class to manage maintenance of the float manager during * nsBlockFrame::Reflow. It automatically restores the old float * manager in the reflow state when the object goes out of scope. */ class nsAutoFloatManager { - using nsHTMLReflowState = mozilla::nsHTMLReflowState; + using ReflowInput = mozilla::ReflowInput; public: - explicit nsAutoFloatManager(nsHTMLReflowState& aReflowState) + explicit nsAutoFloatManager(ReflowInput& aReflowState) : mReflowState(aReflowState), mNew(nullptr), mOld(nullptr) {} ~nsAutoFloatManager(); /** * Create a new float manager for the specified frame. This will * `remember' the old float manager, and install the new float * manager in the reflow state. */ nsresult CreateFloatManager(nsPresContext *aPresContext); protected: - nsHTMLReflowState &mReflowState; + ReflowInput &mReflowState; nsFloatManager *mNew; nsFloatManager *mOld; }; #endif /* !defined(nsFloatManager_h_) */
--- a/layout/generic/nsFontInflationData.cpp +++ b/layout/generic/nsFontInflationData.cpp @@ -26,17 +26,17 @@ nsFontInflationData::FindFontInflationDa const nsIFrame *bfc = FlowRootFor(aFrame); NS_ASSERTION(bfc->GetStateBits() & NS_FRAME_FONT_INFLATION_FLOW_ROOT, "should have found a flow root"); return bfc->Properties().Get(FontInflationDataProperty()); } /* static */ bool -nsFontInflationData::UpdateFontInflationDataISizeFor(const nsHTMLReflowState& aReflowState) +nsFontInflationData::UpdateFontInflationDataISizeFor(const ReflowInput& aReflowState) { nsIFrame *bfc = aReflowState.frame; NS_ASSERTION(bfc->GetStateBits() & NS_FRAME_FONT_INFLATION_FLOW_ROOT, "should have been given a flow root"); FrameProperties bfcProps(bfc->Properties()); nsFontInflationData *data = bfcProps.Get(FontInflationDataProperty()); bool oldInflationEnabled; nscoord oldNCAISize; @@ -116,17 +116,17 @@ NearestCommonAncestorFirstInFlow(nsIFram } result = ancestors1[i1]; } return result; } static nscoord -ComputeDescendantISize(const nsHTMLReflowState& aAncestorReflowState, +ComputeDescendantISize(const ReflowInput& aAncestorReflowState, nsIFrame *aDescendantFrame) { nsIFrame *ancestorFrame = aAncestorReflowState.frame->FirstInFlow(); if (aDescendantFrame == ancestorFrame) { return aAncestorReflowState.ComputedISize(); } AutoTArray<nsIFrame*, 16> frames; @@ -136,47 +136,47 @@ ComputeDescendantISize(const nsHTMLReflo } // This ignores the inline-size contributions made by scrollbars, though in // reality we don't have any scrollbars on the sorts of devices on // which we use font inflation, so it's not a problem. But it may // occasionally cause problems when writing tests on desktop. uint32_t len = frames.Length(); - nsHTMLReflowState *reflowStates = static_cast<nsHTMLReflowState*> - (moz_xmalloc(sizeof(nsHTMLReflowState) * len)); + ReflowInput *reflowStates = static_cast<ReflowInput*> + (moz_xmalloc(sizeof(ReflowInput) * len)); nsPresContext *presContext = aDescendantFrame->PresContext(); for (uint32_t i = 0; i < len; ++i) { - const nsHTMLReflowState &parentReflowState = + const ReflowInput &parentReflowState = (i == 0) ? aAncestorReflowState : reflowStates[i - 1]; nsIFrame *frame = frames[len - i - 1]; WritingMode wm = frame->GetWritingMode(); LogicalSize availSize = parentReflowState.ComputedSize(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; MOZ_ASSERT(frame->GetParent()->FirstInFlow() == parentReflowState.frame->FirstInFlow(), "bad logic in this function"); - new (reflowStates + i) nsHTMLReflowState(presContext, parentReflowState, + new (reflowStates + i) ReflowInput(presContext, parentReflowState, frame, availSize); } MOZ_ASSERT(reflowStates[len - 1].frame == aDescendantFrame, "bad logic in this function"); nscoord result = reflowStates[len - 1].ComputedISize(); for (uint32_t i = len; i-- != 0; ) { - reflowStates[i].~nsHTMLReflowState(); + reflowStates[i].~ReflowInput(); } free(reflowStates); return result; } void -nsFontInflationData::UpdateISize(const nsHTMLReflowState &aReflowState) +nsFontInflationData::UpdateISize(const ReflowInput &aReflowState) { nsIFrame *bfc = aReflowState.frame; NS_ASSERTION(bfc->GetStateBits() & NS_FRAME_FONT_INFLATION_FLOW_ROOT, "must be block formatting context"); nsIFrame *firstInflatableDescendant = FindEdgeInflatableFrameIn(bfc, eFromStart); if (!firstInflatableDescendant) {
--- a/layout/generic/nsFontInflationData.h +++ b/layout/generic/nsFontInflationData.h @@ -7,26 +7,26 @@ #ifndef nsFontInflationData_h_ #define nsFontInflationData_h_ #include "nsContainerFrame.h" class nsFontInflationData { - using nsHTMLReflowState = mozilla::nsHTMLReflowState; + using ReflowInput = mozilla::ReflowInput; public: static nsFontInflationData* FindFontInflationDataFor(const nsIFrame *aFrame); // Returns whether the effective width changed (which requires the // caller to mark its descendants dirty static bool - UpdateFontInflationDataISizeFor(const nsHTMLReflowState& aReflowState); + UpdateFontInflationDataISizeFor(const ReflowInput& aReflowState); static void MarkFontInflationDataTextDirty(nsIFrame *aFrame); bool InflationEnabled() { if (mTextDirty) { ScanText(); } return mInflationEnabled; @@ -38,17 +38,17 @@ public: private: explicit nsFontInflationData(nsIFrame* aBFCFrame); nsFontInflationData(const nsFontInflationData&) = delete; void operator=(const nsFontInflationData&) = delete; - void UpdateISize(const nsHTMLReflowState &aReflowState); + void UpdateISize(const ReflowInput &aReflowState); enum SearchDirection { eFromStart, eFromEnd }; static nsIFrame* FindEdgeInflatableFrameIn(nsIFrame *aFrame, SearchDirection aDirection); void MarkTextDirty() { mTextDirty = true; } void ScanText(); // Scan text in the subtree rooted at aFrame. Increment mTextAmount // by multiplying the number of characters found by the font size
--- a/layout/generic/nsFrame.cpp +++ b/layout/generic/nsFrame.cpp @@ -1050,17 +1050,17 @@ nsIFrame::GetUsedPadding() const NS_ERROR("Returning bogus 0-sized padding, because this padding " "depends on layout & isn't cached!"); } } return padding; } nsIFrame::Sides -nsIFrame::GetSkipSides(const nsHTMLReflowState* aReflowState) const +nsIFrame::GetSkipSides(const ReflowInput* aReflowState) const { if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak == NS_STYLE_BOX_DECORATION_BREAK_CLONE) && !(GetStateBits() & NS_FRAME_IS_OVERFLOW_CONTAINER)) { return Sides(); } // Convert the logical skip sides to physical sides using the frame's @@ -4928,17 +4928,17 @@ nsFrame::ShrinkWidthToFit(nsRenderingCon result = prefWidth; } } return result; } void nsFrame::DidReflow(nsPresContext* aPresContext, - const nsHTMLReflowState* aReflowState, + const ReflowInput* aReflowState, nsDidReflowStatus aStatus) { NS_FRAME_TRACE_MSG(NS_FRAME_TRACE_CALLS, ("nsFrame::DidReflow: aStatus=%d", static_cast<uint32_t>(aStatus))); nsSVGEffects::InvalidateDirectRenderingObservers(this, nsSVGEffects::INVALIDATE_REFLOW); if (nsDidReflowStatus::FINISHED == aStatus) { @@ -4960,29 +4960,29 @@ nsFrame::DidReflow(nsPresContext* } aPresContext->ReflowedFrame(); } void nsFrame::FinishReflowWithAbsoluteFrames(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus, bool aConstrainBSize) { ReflowAbsoluteFrames(aPresContext, aDesiredSize, aReflowState, aStatus, aConstrainBSize); FinishAndStoreOverflow(&aDesiredSize); } void nsFrame::ReflowAbsoluteFrames(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus, bool aConstrainBSize) { if (HasAbsolutelyPositionedChildren()) { nsAbsoluteContainingBlock* absoluteContainer = GetAbsoluteContainingBlock(); // Let the absolutely positioned container reflow any absolutely positioned // child frames that need to be reflowed @@ -5026,17 +5026,17 @@ nsFrame::CanContinueTextRun() const // By default, a frame will *not* allow a text run to be continued // through it. return false; } void nsFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsFrame"); aDesiredSize.ClearSize(); aStatus = NS_FRAME_COMPLETE; NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize); } @@ -5849,17 +5849,17 @@ void nsIFrame::MovePositionBy(const nsPoint& aTranslation) { nsPoint position = GetNormalPosition() + aTranslation; const nsMargin* computedOffsets = nullptr; if (IsRelativelyPositioned()) { computedOffsets = Properties().Get(nsIFrame::ComputedOffsetProperty()); } - nsHTMLReflowState::ApplyRelativePositioning(this, computedOffsets ? + ReflowInput::ApplyRelativePositioning(this, computedOffsets ? *computedOffsets : nsMargin(), &position); SetPosition(position); } nsRect nsIFrame::GetNormalRect() const { @@ -6039,17 +6039,17 @@ nsFrame::UnionChildOverflow(nsOverflowAr // Define the MAX_FRAME_DEPTH to be the ContentSink's MAX_REFLOW_DEPTH plus // 4 for the frames above the document's frames: // the Viewport, GFXScroll, ScrollPort, and Canvas #define MAX_FRAME_DEPTH (MAX_REFLOW_DEPTH+4) bool -nsFrame::IsFrameTreeTooDeep(const nsHTMLReflowState& aReflowState, +nsFrame::IsFrameTreeTooDeep(const ReflowInput& aReflowState, nsHTMLReflowMetrics& aMetrics, nsReflowStatus& aStatus) { if (aReflowState.mReflowDepth > MAX_FRAME_DEPTH) { NS_WARNING("frame tree too deep; setting zero size and returning"); mState |= NS_FRAME_TOO_DEEP_IN_FRAME_TREE; ClearOverflowRects(); aMetrics.ClearSize(); @@ -8953,21 +8953,21 @@ nsFrame::DoXULLayout(nsBoxLayoutState& a // Should we do this if IsXULCollapsed() is true? LogicalSize size(GetLogicalSize(outerWM)); desiredSize.ISize(outerWM) = size.ISize(outerWM); desiredSize.BSize(outerWM) = size.BSize(outerWM); desiredSize.UnionOverflowAreasWithDesiredBounds(); if (HasAbsolutelyPositionedChildren()) { // Set up a |reflowState| to pass into ReflowAbsoluteFrames - nsHTMLReflowState reflowState(aState.PresContext(), this, + ReflowInput reflowState(aState.PresContext(), this, aState.GetRenderingContext(), LogicalSize(ourWM, ISize(), NS_UNCONSTRAINEDSIZE), - nsHTMLReflowState::DUMMY_PARENT_REFLOW_STATE); + 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; ReflowAbsoluteFrames(aState.PresContext(), desiredSize, reflowState, reflowStatus); RemoveStateBits(NS_FRAME_IN_REFLOW); @@ -9056,20 +9056,20 @@ nsFrame::BoxReflow(nsBoxLayoutState& if (parentSize.height != NS_INTRINSICSIZE) parentSize.height += margin.TopBottom(); if (parentSize.width != NS_INTRINSICSIZE) parentSize.width += margin.LeftRight(); nsIFrame *parentFrame = GetParent(); nsFrameState savedState = parentFrame->GetStateBits(); WritingMode parentWM = parentFrame->GetWritingMode(); - nsHTMLReflowState + ReflowInput parentReflowState(aPresContext, parentFrame, aRenderingContext, LogicalSize(parentWM, parentSize), - nsHTMLReflowState::DUMMY_PARENT_REFLOW_STATE); + ReflowInput::DUMMY_PARENT_REFLOW_STATE); parentFrame->RemoveStateBits(~nsFrameState(0)); parentFrame->AddStateBits(savedState); // This may not do very much useful, but it's probably worth trying. if (parentSize.width != NS_INTRINSICSIZE) parentReflowState.SetComputedWidth(std::max(parentSize.width, 0)); if (parentSize.height != NS_INTRINSICSIZE) parentReflowState.SetComputedHeight(std::max(parentSize.height, 0)); @@ -9077,39 +9077,39 @@ nsFrame::BoxReflow(nsBoxLayoutState& // XXX use box methods parentFrame->GetXULPadding(parentReflowState.ComputedPhysicalPadding()); parentFrame->GetXULBorder(parentReflowState.ComputedPhysicalBorderPadding()); parentReflowState.ComputedPhysicalBorderPadding() += parentReflowState.ComputedPhysicalPadding(); // Construct the parent chain manually since constructing it normally // messes up dimensions. - const nsHTMLReflowState *outerReflowState = aState.OuterReflowState(); + const ReflowInput *outerReflowState = aState.OuterReflowState(); NS_ASSERTION(!outerReflowState || outerReflowState->frame != this, "in and out of XUL on a single frame?"); - const nsHTMLReflowState* parentRS; + const ReflowInput* parentRS; if (outerReflowState && outerReflowState->frame == parentFrame) { // We're a frame (such as a text control frame) that jumps into // box reflow and then straight out of it on the child frame. // This means we actually have a real parent reflow state. // nsLayoutUtils::InflationMinFontSizeFor used to need this to be // linked up correctly for text control frames, so do so here). parentRS = outerReflowState; } else { parentRS = &parentReflowState; } // XXX Is it OK that this reflow state has only one ancestor? // (It used to have a bogus parent, skipping all the boxes). WritingMode wm = GetWritingMode(); LogicalSize logicalSize(wm, nsSize(aWidth, aHeight)); logicalSize.BSize(wm) = NS_INTRINSICSIZE; - nsHTMLReflowState reflowState(aPresContext, *parentRS, this, + ReflowInput reflowState(aPresContext, *parentRS, this, logicalSize, nullptr, - nsHTMLReflowState::DUMMY_PARENT_REFLOW_STATE); + ReflowInput::DUMMY_PARENT_REFLOW_STATE); // XXX_jwir3: This is somewhat fishy. If this is actually changing the value // here (which it might be), then we should make sure that it's // correct the first time around, rather than changing it later. reflowState.mCBReflowState = parentRS; reflowState.mReflowDepth = aState.GetReflowDepth(); @@ -9151,17 +9151,17 @@ nsFrame::BoxReflow(nsBoxLayoutState& // XXX Perhaps we should be doing this by twiddling the rect back to // mLastSize before calling Reflow and then switching it back, but // However, mLastSize can also be the size passed to BoxReflow by // RefreshSizeCache, so that doesn't really make sense. if (metrics->mLastSize.width != aWidth) { reflowState.SetHResize(true); // When font size inflation is enabled, a horizontal resize - // requires a full reflow. See nsHTMLReflowState::InitResizeFlags + // requires a full reflow. See ReflowInput::InitResizeFlags // for more details. if (nsLayoutUtils::FontSizeInflationEnabled(aPresContext)) { AddStateBits(NS_FRAME_IS_DIRTY); } } if (metrics->mLastSize.height != aHeight) { reflowState.SetVResize(true); } @@ -9486,17 +9486,17 @@ nsAdaptorAddIndents() { for(int32_t i=0; i < gIndent2; i++) { printf(" "); } } void -nsAdaptorPrintReason(nsHTMLReflowState& aReflowState) +nsAdaptorPrintReason(ReflowInput& aReflowState) { char* reflowReasonString; switch(aReflowState.reason) { case eReflowReason_Initial: reflowReasonString = "initial"; break; @@ -9604,17 +9604,17 @@ nsFrame::VerifyDirtyBitSet(const nsFrame } } // Start Display Reflow #ifdef DEBUG DR_cookie::DR_cookie(nsPresContext* aPresContext, nsIFrame* aFrame, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsHTMLReflowMetrics& aMetrics, nsReflowStatus& aStatus) :mPresContext(aPresContext), mFrame(aFrame), mReflowState(aReflowState), mMetrics(aMetrics), mStatus(aStatus) { MOZ_COUNT_CTOR(DR_cookie); mValue = nsFrame::DisplayReflowEnter(aPresContext, mFrame, mReflowState); } @@ -9670,34 +9670,34 @@ DR_intrinsic_size_cookie::DR_intrinsic_s DR_intrinsic_size_cookie::~DR_intrinsic_size_cookie() { MOZ_COUNT_DTOR(DR_intrinsic_size_cookie); nsFrame::DisplayIntrinsicSizeExit(mFrame, mType, mResult, mValue); } DR_init_constraints_cookie::DR_init_constraints_cookie( nsIFrame* aFrame, - nsHTMLReflowState* aState, + ReflowInput* aState, nscoord aCBWidth, nscoord aCBHeight, const nsMargin* aMargin, const nsMargin* aPadding) : mFrame(aFrame) , mState(aState) { MOZ_COUNT_CTOR(DR_init_constraints_cookie); - mValue = nsHTMLReflowState::DisplayInitConstraintsEnter(mFrame, mState, + mValue = ReflowInput::DisplayInitConstraintsEnter(mFrame, mState, aCBWidth, aCBHeight, aMargin, aPadding); } DR_init_constraints_cookie::~DR_init_constraints_cookie() { MOZ_COUNT_DTOR(DR_init_constraints_cookie); - nsHTMLReflowState::DisplayInitConstraintsExit(mFrame, mState, mValue); + ReflowInput::DisplayInitConstraintsExit(mFrame, mState, mValue); } DR_init_offsets_cookie::DR_init_offsets_cookie( nsIFrame* aFrame, nsCSSOffsetState* aState, const LogicalSize& aPercentBasis, const nsMargin* aMargin, const nsMargin* aPadding) @@ -9713,28 +9713,28 @@ DR_init_offsets_cookie::DR_init_offsets_ DR_init_offsets_cookie::~DR_init_offsets_cookie() { MOZ_COUNT_DTOR(DR_init_offsets_cookie); nsCSSOffsetState::DisplayInitOffsetsExit(mFrame, mState, mValue); } DR_init_type_cookie::DR_init_type_cookie( nsIFrame* aFrame, - nsHTMLReflowState* aState) + ReflowInput* aState) : mFrame(aFrame) , mState(aState) { MOZ_COUNT_CTOR(DR_init_type_cookie); - mValue = nsHTMLReflowState::DisplayInitFrameTypeEnter(mFrame, mState); + mValue = ReflowInput::DisplayInitFrameTypeEnter(mFrame, mState); } DR_init_type_cookie::~DR_init_type_cookie() { MOZ_COUNT_DTOR(DR_init_type_cookie); - nsHTMLReflowState::DisplayInitFrameTypeExit(mFrame, mState, mValue); + ReflowInput::DisplayInitFrameTypeExit(mFrame, mState, mValue); } struct DR_FrameTypeInfo; struct DR_FrameTreeNode; struct DR_Rule; struct DR_State { @@ -9743,17 +9743,17 @@ struct DR_State void Init(); void AddFrameTypeInfo(nsIAtom* aFrameType, const char* aFrameNameAbbrev, const char* aFrameName); DR_FrameTypeInfo* GetFrameTypeInfo(nsIAtom* aFrameType); DR_FrameTypeInfo* GetFrameTypeInfo(char* aFrameName); void InitFrameTypeTable(); DR_FrameTreeNode* CreateTreeNode(nsIFrame* aFrame, - const nsHTMLReflowState* aReflowState); + const ReflowInput* aReflowState); void FindMatchingRule(DR_FrameTreeNode& aNode); bool RuleMatches(DR_Rule& aRule, DR_FrameTreeNode& aNode); bool GetToken(FILE* aFile, char* aBuf, size_t aBufSize); DR_Rule* ParseRule(FILE* aFile); void ParseRulesFile(); @@ -10213,22 +10213,22 @@ void DR_State::FindMatchingRule(DR_Frame aNode.mDisplay = rule->mDisplay; break; } } } } DR_FrameTreeNode* DR_State::CreateTreeNode(nsIFrame* aFrame, - const nsHTMLReflowState* aReflowState) + const ReflowInput* aReflowState) { // find the frame of the parent reflow state (usually just the parent of aFrame) nsIFrame* parentFrame; if (aReflowState) { - const nsHTMLReflowState* parentRS = aReflowState->mParentReflowState; + const ReflowInput* parentRS = aReflowState->mParentReflowState; parentFrame = (parentRS) ? parentRS->frame : nullptr; } else { parentFrame = aFrame->GetParent(); } // find the parent tree node leaf DR_FrameTreeNode* parentNode = nullptr; @@ -10312,17 +10312,17 @@ CheckPixelError(nscoord aSize, if ((aSize % aPixelToTwips) > 0) { printf("VALUE %d is not a whole pixel \n", aSize); } } } static void DisplayReflowEnterPrint(nsPresContext* aPresContext, nsIFrame* aFrame, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, DR_FrameTreeNode& aTreeNode, bool aChanged) { if (aTreeNode.mDisplay) { DR_state->DisplayFrameTypeInfo(aFrame, aTreeNode.mIndent); char width[16]; char height[16]; @@ -10369,17 +10369,17 @@ static void DisplayReflowEnterPrint(nsPr CheckPixelError(aReflowState.ComputedWidth(), p2t); CheckPixelError(aReflowState.ComputedHeight(), p2t); } } } void* nsFrame::DisplayReflowEnter(nsPresContext* aPresContext, nsIFrame* aFrame, - const nsHTMLReflowState& aReflowState) + const ReflowInput& aReflowState) { if (!DR_state->mInited) DR_state->Init(); if (!DR_state->mActive) return nullptr; NS_ASSERTION(aFrame, "invalid call"); DR_FrameTreeNode* treeNode = DR_state->CreateTreeNode(aFrame, &aReflowState); if (treeNode) { @@ -10575,18 +10575,18 @@ void DR_cookie::Change() const { DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)mValue; if (treeNode && treeNode->mDisplay) { DisplayReflowEnterPrint(mPresContext, mFrame, mReflowState, *treeNode, true); } } /* static */ void* -nsHTMLReflowState::DisplayInitConstraintsEnter(nsIFrame* aFrame, - nsHTMLReflowState* aState, +ReflowInput::DisplayInitConstraintsEnter(nsIFrame* aFrame, + ReflowInput* aState, nscoord aContainingBlockWidth, nscoord aContainingBlockHeight, const nsMargin* aBorder, const nsMargin* aPadding) { NS_PRECONDITION(aFrame, "non-null frame required"); NS_PRECONDITION(aState, "non-null state required"); @@ -10614,18 +10614,18 @@ nsHTMLReflowState::DisplayInitConstraint DR_state->PrintMargin("b", aBorder); DR_state->PrintMargin("p", aPadding); putchar('\n'); } return treeNode; } /* static */ void -nsHTMLReflowState::DisplayInitConstraintsExit(nsIFrame* aFrame, - nsHTMLReflowState* aState, +ReflowInput::DisplayInitConstraintsExit(nsIFrame* aFrame, + ReflowInput* aState, void* aValue) { NS_PRECONDITION(aFrame, "non-null frame required"); NS_PRECONDITION(aState, "non-null state required"); if (!DR_state->mActive) return; if (!aValue) return; @@ -10656,17 +10656,17 @@ nsCSSOffsetState::DisplayInitOffsetsEnte const nsMargin* aPadding) { NS_PRECONDITION(aFrame, "non-null frame required"); NS_PRECONDITION(aState, "non-null state required"); if (!DR_state->mInited) DR_state->Init(); if (!DR_state->mActive) return nullptr; - // aState is not necessarily a nsHTMLReflowState + // aState is not necessarily a ReflowInput DR_FrameTreeNode* treeNode = DR_state->CreateTreeNode(aFrame, nullptr); if (treeNode && treeNode->mDisplay) { DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent); char horizPctBasisStr[16]; char vertPctBasisStr[16]; WritingMode wm = aState->GetWritingMode(); DR_state->PrettyUC(aPercentBasis.ISize(wm), horizPctBasisStr, 16); @@ -10699,32 +10699,32 @@ nsCSSOffsetState::DisplayInitOffsetsExit DR_state->PrintMargin("p", &aState->ComputedPhysicalPadding()); DR_state->PrintMargin("p+b", &aState->ComputedPhysicalBorderPadding()); putchar('\n'); } DR_state->DeleteTreeNode(*treeNode); } /* static */ void* -nsHTMLReflowState::DisplayInitFrameTypeEnter(nsIFrame* aFrame, - nsHTMLReflowState* aState) +ReflowInput::DisplayInitFrameTypeEnter(nsIFrame* aFrame, + ReflowInput* aState) { NS_PRECONDITION(aFrame, "non-null frame required"); NS_PRECONDITION(aState, "non-null state required"); if (!DR_state->mInited) DR_state->Init(); if (!DR_state->mActive) return nullptr; // we don't print anything here return DR_state->CreateTreeNode(aFrame, aState); } /* static */ void -nsHTMLReflowState::DisplayInitFrameTypeExit(nsIFrame* aFrame, - nsHTMLReflowState* aState, +ReflowInput::DisplayInitFrameTypeExit(nsIFrame* aFrame, + ReflowInput* aState, void* aValue) { NS_PRECONDITION(aFrame, "non-null frame required"); NS_PRECONDITION(aState, "non-null state required"); if (!DR_state->mActive) return; if (!aValue) return;
--- a/layout/generic/nsFrame.h +++ b/layout/generic/nsFrame.h @@ -320,55 +320,55 @@ public: * A frame's children must _all_ be reflowed if the frame is dirty (the * NS_FRAME_IS_DIRTY bit is set on it). Otherwise, individual children * must be reflowed if they are dirty or have the NS_FRAME_HAS_DIRTY_CHILDREN * bit set on them. Otherwise, whether children need to be reflowed depends * on the frame's type (it's up to individual Reflow methods), and on what * has changed. For example, a change in the width of the frame may require * all of its children to be reflowed (even those without dirty bits set on * them), whereas a change in its height might not. - * (nsHTMLReflowState::ShouldReflowAllKids may be helpful in deciding whether + * (ReflowInput::ShouldReflowAllKids may be helpful in deciding whether * to reflow all the children, but for some frame types it might result in * over-reflow.) * * Note: if it's only the overflow rect(s) of a frame that need to be * updated, then UpdateOverflow should be called instead of Reflow. */ virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual void DidReflow(nsPresContext* aPresContext, - const nsHTMLReflowState* aReflowState, + const ReflowInput* aReflowState, nsDidReflowStatus aStatus) override; /** * NOTE: aStatus is assumed to be already-initialized. The reflow statuses of * any reflowed absolute children will be merged into aStatus; aside from * that, this method won't modify aStatus. */ void ReflowAbsoluteFrames(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus, bool aConstrainBSize = true); void FinishReflowWithAbsoluteFrames(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus, bool aConstrainBSize = true); /* * If this frame is dirty, marks all absolutely-positioned children of this * frame dirty. If this frame isn't dirty, or if there are no * absolutely-positioned children, does nothing. * * It's necessary to use PushDirtyBitToAbsoluteFrames() when you plan to * reflow this frame's absolutely-positioned children after the dirty bit on - * this frame has already been cleared, which prevents nsHTMLReflowState from + * this frame has already been cleared, which prevents ReflowInput from * propagating the dirty bit normally. This situation generally only arises * when a multipass layout algorithm is used. */ void PushDirtyBitToAbsoluteFrames(); virtual bool CanContinueTextRun() const override; virtual bool ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas) override; @@ -426,29 +426,29 @@ public: //-------------------------------------------------- // Additional methods // Helper function that tests if the frame tree is too deep; if it is // it marks the frame as "unflowable", zeroes out the metrics, sets // the reflow status, and returns true. Otherwise, the frame is // unmarked "unflowable" and the metrics and reflow status are not // touched and false is returned. - bool IsFrameTreeTooDeep(const nsHTMLReflowState& aReflowState, + bool IsFrameTreeTooDeep(const ReflowInput& aReflowState, nsHTMLReflowMetrics& aMetrics, nsReflowStatus& aStatus); // Incorporate the child overflow areas into aOverflowAreas. // If the child does not have a overflow, use the child area. void ConsiderChildOverflow(nsOverflowAreas& aOverflowAreas, nsIFrame* aChildFrame); /** * @return true if we should avoid a page/column break in this frame. */ - bool ShouldAvoidBreakInside(const nsHTMLReflowState& aReflowState) const { + bool ShouldAvoidBreakInside(const ReflowInput& aReflowState) const { return !aReflowState.mFlags.mIsTopOfPage && NS_STYLE_PAGE_BREAK_AVOID == StyleDisplay()->mBreakInside && !GetPrevInFlow(); } #ifdef DEBUG /** * Tracing method that writes a method enter/exit routine to the @@ -475,17 +475,17 @@ public: * some custom behavior that requires changing how the outer "frame" * XML container is dumped. */ virtual void DumpBaseRegressionData(nsPresContext* aPresContext, FILE* out, int32_t aIndent); // Display Reflow Debugging static void* DisplayReflowEnter(nsPresContext* aPresContext, nsIFrame* aFrame, - const nsHTMLReflowState& aReflowState); + const ReflowInput& aReflowState); static void* DisplayLayoutEnter(nsIFrame* aFrame); static void* DisplayIntrinsicISizeEnter(nsIFrame* aFrame, const char* aType); static void* DisplayIntrinsicSizeEnter(nsIFrame* aFrame, const char* aType); static void DisplayReflowExit(nsPresContext* aPresContext, nsIFrame* aFrame, nsHTMLReflowMetrics& aMetrics, @@ -764,25 +764,25 @@ public: }; // Start Display Reflow Debugging #ifdef DEBUG struct DR_cookie { DR_cookie(nsPresContext* aPresContext, nsIFrame* aFrame, - const mozilla::nsHTMLReflowState& aReflowState, + const mozilla::ReflowInput& aReflowState, nsHTMLReflowMetrics& aMetrics, nsReflowStatus& aStatus); ~DR_cookie(); void Change() const; nsPresContext* mPresContext; nsIFrame* mFrame; - const mozilla::nsHTMLReflowState& mReflowState; + const mozilla::ReflowInput& mReflowState; nsHTMLReflowMetrics& mMetrics; nsReflowStatus& mStatus; void* mValue; }; struct DR_layout_cookie { explicit DR_layout_cookie(nsIFrame* aFrame); ~DR_layout_cookie(); @@ -809,45 +809,45 @@ public: nsIFrame* mFrame; const char* mType; nsSize& mResult; void* mValue; }; struct DR_init_constraints_cookie { - DR_init_constraints_cookie(nsIFrame* aFrame, mozilla::nsHTMLReflowState* aState, + DR_init_constraints_cookie(nsIFrame* aFrame, mozilla::ReflowInput* aState, nscoord aCBWidth, nscoord aCBHeight, const nsMargin* aBorder, const nsMargin* aPadding); ~DR_init_constraints_cookie(); nsIFrame* mFrame; - mozilla::nsHTMLReflowState* mState; + mozilla::ReflowInput* mState; void* mValue; }; struct DR_init_offsets_cookie { DR_init_offsets_cookie(nsIFrame* aFrame, mozilla::nsCSSOffsetState* aState, const mozilla::LogicalSize& aPercentBasis, const nsMargin* aBorder, const nsMargin* aPadding); ~DR_init_offsets_cookie(); nsIFrame* mFrame; mozilla::nsCSSOffsetState* mState; void* mValue; }; struct DR_init_type_cookie { - DR_init_type_cookie(nsIFrame* aFrame, mozilla::nsHTMLReflowState* aState); + DR_init_type_cookie(nsIFrame* aFrame, mozilla::ReflowInput* aState); ~DR_init_type_cookie(); nsIFrame* mFrame; - mozilla::nsHTMLReflowState* mState; + mozilla::ReflowInput* mState; void* mValue; }; #define DISPLAY_REFLOW(dr_pres_context, dr_frame, dr_rf_state, dr_rf_metrics, dr_rf_status) \ DR_cookie dr_cookie(dr_pres_context, dr_frame, dr_rf_state, dr_rf_metrics, dr_rf_status); #define DISPLAY_REFLOW_CHANGE() \ dr_cookie.Change(); #define DISPLAY_LAYOUT(dr_frame) \
--- a/layout/generic/nsFrameSetFrame.cpp +++ b/layout/generic/nsFrameSetFrame.cpp @@ -100,17 +100,17 @@ public: nsIFrame::Cursor& aCursor) override; virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; bool GetVisibility() { return mVisibility; } void SetVisibility(bool aVisibility); void SetColor(nscolor aColor); void PaintBorder(DrawTarget* aDrawTarget, nsPoint aPt); @@ -149,17 +149,17 @@ public: #endif virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; protected: explicit nsHTMLFramesetBlankFrame(nsStyleContext* aContext) : nsLeafFrame(aContext) {} virtual ~nsHTMLFramesetBlankFrame(); virtual nscoord GetIntrinsicISize() override; virtual nscoord GetIntrinsicBSize() override; @@ -558,17 +558,17 @@ int32_t nsHTMLFramesetFrame::GetBorderWi return mParentBorderWidth; } return nsPresContext::CSSPixelsToAppUnits(DEFAULT_BORDER_WIDTH_PX); } void nsHTMLFramesetFrame::GetDesiredSize(nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsHTMLReflowMetrics& aDesiredSize) { WritingMode wm = aReflowState.GetWritingMode(); LogicalSize desiredSize(wm); nsHTMLFramesetFrame* framesetParent = do_QueryFrame(GetParent()); if (nullptr == framesetParent) { if (aPresContext->IsPaginated()) { // XXX This needs to be changed when framesets paginate properly @@ -677,23 +677,23 @@ nsHTMLFramesetFrame::BuildDisplayList(ns aLists.Content()->AppendNewToTop( new (aBuilder) nsDisplayEventReceiver(aBuilder, this)); } } void nsHTMLFramesetFrame::ReflowPlaceChild(nsIFrame* aChild, nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsPoint& aOffset, nsSize& aSize, nsIntPoint* aCellIndex) { // reflow the child - nsHTMLReflowState reflowState(aPresContext, aReflowState, aChild, + ReflowInput reflowState(aPresContext, aReflowState, aChild, LogicalSize(aChild->GetWritingMode(), aSize)); reflowState.SetComputedWidth(std::max(0, aSize.width - reflowState.ComputedPhysicalBorderPadding().LeftRight())); reflowState.SetComputedHeight(std::max(0, aSize.height - reflowState.ComputedPhysicalBorderPadding().TopBottom())); nsHTMLReflowMetrics metrics(aReflowState); metrics.Width() = aSize.width; metrics.Height() = aSize.height; nsReflowStatus status; @@ -788,17 +788,17 @@ nscolor nsHTMLFramesetFrame::GetBorderCo } } return GetBorderColor(); } void nsHTMLFramesetFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsHTMLFramesetFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); nsIPresShell *shell = aPresContext->PresShell(); StyleSetHandle styleSet = shell->StyleSet(); @@ -1368,17 +1368,17 @@ void nsHTMLFramesetBorderFrame::SetColor { mColor = aColor; } void nsHTMLFramesetBorderFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { DO_GLOBAL_REFLOW_COUNT("nsHTMLFramesetBorderFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); // Override Reflow(), since we don't want to deal with what our // computed values are. SizeToAvailSize(aReflowState, aDesiredSize); @@ -1583,17 +1583,17 @@ nscoord nsHTMLFramesetBlankFrame::GetInt { // No intrinsic height return 0; } void nsHTMLFramesetBlankFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { DO_GLOBAL_REFLOW_COUNT("nsHTMLFramesetBlankFrame"); // Override Reflow(), since we don't want to deal with what our // computed values are. SizeToAvailSize(aReflowState, aDesiredSize);
--- a/layout/generic/nsFrameSetFrame.h +++ b/layout/generic/nsFrameSetFrame.h @@ -97,17 +97,17 @@ public: nsIFrame::Cursor& aCursor) override; virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsIAtom* GetType() const override; #ifdef DEBUG_FRAME_DUMP virtual nsresult GetFrameName(nsAString& aResult) const override; #endif virtual bool IsLeaf() const override; @@ -145,17 +145,17 @@ protected: void GenerateRowCol(nsPresContext* aPresContext, nscoord aSize, int32_t aNumSpecs, const nsFramesetSpec* aSpecs, nscoord* aValues, nsString& aNewAttr); virtual void GetDesiredSize(nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsHTMLReflowMetrics& aDesiredSize); int32_t GetBorderWidth(nsPresContext* aPresContext, bool aTakeForcingIntoAccount); int32_t GetParentBorderWidth() { return mParentBorderWidth; } void SetParentBorderWidth(int32_t aWidth) { mParentBorderWidth = aWidth; } @@ -171,17 +171,17 @@ protected: nscolor GetBorderColor(); nscolor GetBorderColor(nsIContent* aFrameContent); bool GetNoResize(nsIFrame* aChildFrame); void ReflowPlaceChild(nsIFrame* aChild, nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsPoint& aOffset, nsSize& aSize, nsIntPoint* aCellIndex = 0); bool CanResize(bool aVertical, bool aLeft); bool CanChildResize(bool aVertical, bool aLeft, int32_t aChildX);
--- a/layout/generic/nsGfxScrollFrame.cpp +++ b/layout/generic/nsGfxScrollFrame.cpp @@ -201,17 +201,17 @@ nsHTMLScrollFrame::GetType() const /** HTML scrolling implementation All other things being equal, we prefer layouts with fewer scrollbars showing. */ struct MOZ_STACK_CLASS ScrollReflowState { - const nsHTMLReflowState& mReflowState; + const ReflowInput& mReflowState; nsBoxLayoutState mBoxState; ScrollbarStyles mStyles; nsMargin mComputedBorder; // === Filled in by ReflowScrolledFrame === nsOverflowAreas mContentsOverflowAreas; bool mReflowedContentsWithHScrollbar; bool mReflowedContentsWithVScrollbar; @@ -220,17 +220,17 @@ struct MOZ_STACK_CLASS ScrollReflowState // The size of the inside-border area nsSize mInsideBorderSize; // Whether we decided to show the horizontal scrollbar bool mShowHScrollbar; // Whether we decided to show the vertical scrollbar bool mShowVScrollbar; ScrollReflowState(nsIScrollableFrame* aFrame, - const nsHTMLReflowState& aState) : + const ReflowInput& aState) : mReflowState(aState), // mBoxState is just used for scrollbars so we don't need to // worry about the reflow depth here mBoxState(aState.frame->PresContext(), aState.rendContext, 0), mStyles(aFrame->GetScrollbarStyles()) { } }; @@ -503,21 +503,21 @@ nsHTMLScrollFrame::ReflowScrolledFrame(S nullptr, &vScrollbarPrefSize, true); availISize = std::max(0, availISize - vScrollbarPrefSize.width); } } nsPresContext* presContext = PresContext(); // Pass false for aInit so we can pass in the correct padding. - nsHTMLReflowState + ReflowInput kidReflowState(presContext, aState->mReflowState, mHelper.mScrolledFrame, LogicalSize(wm, availISize, NS_UNCONSTRAINEDSIZE), - nullptr, nsHTMLReflowState::CALLER_WILL_INIT); + nullptr, ReflowInput::CALLER_WILL_INIT); const nsMargin physicalPadding = padding.GetPhysicalMargin(wm); kidReflowState.Init(presContext, nullptr, nullptr, &physicalPadding); kidReflowState.mFlags.mAssumingHScrollbar = aAssumeHScroll; kidReflowState.mFlags.mAssumingVScrollbar = aAssumeVScroll; kidReflowState.SetComputedBSize(computedBSize); kidReflowState.ComputedMinBSize() = computedMinBSize; kidReflowState.ComputedMaxBSize() = computedMaxBSize; @@ -826,17 +826,17 @@ GetBrowserRoot(nsIContent* aContent) } return nullptr; } void nsHTMLScrollFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsHTMLScrollFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); mHelper.HandleScrollbarStyleSwitching();
--- a/layout/generic/nsGfxScrollFrame.h +++ b/layout/generic/nsGfxScrollFrame.h @@ -696,17 +696,17 @@ public: virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override; virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override; virtual nsresult GetXULPadding(nsMargin& aPadding) override; virtual bool IsXULCollapsed() override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual bool ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas) override { return mHelper.ComputeCustomOverflow(aOverflowAreas); } // Called to set the child frames. We typically have three: the scroll area, // the vertical scrollbar, and the horizontal scrollbar.
--- a/layout/generic/nsGridContainerFrame.cpp +++ b/layout/generic/nsGridContainerFrame.cpp @@ -62,32 +62,32 @@ ReparentFrames(nsFrameList& aFrameList, nsContainerFrame* aNewParent) { for (auto f : aFrameList) { ReparentFrame(f, aOldParent, aNewParent); } } static nscoord -ClampToCSSMaxBSize(nscoord aSize, const nsHTMLReflowState* aReflowState) +ClampToCSSMaxBSize(nscoord aSize, const ReflowInput* aReflowState) { auto maxSize = aReflowState->ComputedMaxBSize(); if (MOZ_UNLIKELY(maxSize != NS_UNCONSTRAINEDSIZE)) { MOZ_ASSERT(aReflowState->ComputedMinBSize() <= maxSize); aSize = std::min(aSize, maxSize); } return aSize; } // Same as above and set aStatus INCOMPLETE if aSize wasn't clamped. // (If we clamp aSize it means our size is less than the break point, // i.e. we're effectively breaking in our overflow, so we should leave // aStatus as is (it will likely be set to OVERFLOW_INCOMPLETE later)). static nscoord -ClampToCSSMaxBSize(nscoord aSize, const nsHTMLReflowState* aReflowState, +ClampToCSSMaxBSize(nscoord aSize, const ReflowInput* aReflowState, nsReflowStatus* aStatus) { auto maxSize = aReflowState->ComputedMaxBSize(); if (MOZ_UNLIKELY(maxSize != NS_UNCONSTRAINEDSIZE)) { MOZ_ASSERT(aReflowState->ComputedMinBSize() <= maxSize); if (aSize < maxSize) { NS_FRAME_SET_INCOMPLETE(*aStatus); } else { @@ -1666,17 +1666,17 @@ struct nsGridContainerFrame::SharedGridD * GridReflowState from it. */ NS_DECLARE_FRAME_PROPERTY_DELETABLE(Prop, SharedGridData) }; struct MOZ_STACK_CLASS nsGridContainerFrame::GridReflowState { GridReflowState(nsGridContainerFrame* aFrame, - const nsHTMLReflowState& aRS) + const ReflowInput& aRS) : GridReflowState(aFrame, *aRS.rendContext, &aRS, aRS.mStylePosition, aRS.GetWritingMode()) {} GridReflowState(nsGridContainerFrame* aFrame, nsRenderingContext& aRC) : GridReflowState(aFrame, aRC, nullptr, aFrame->StylePosition(), aFrame->GetWritingMode()) {} @@ -1824,17 +1824,17 @@ struct MOZ_STACK_CLASS nsGridContainerFr */ nsTArray<GridItemInfo> mAbsPosItems; /** * @note mReflowState may be null when using the 2nd ctor above. In this case * we'll construct a dummy parent reflow state if we need it to calculate * min/max-content contributions when sizing tracks. */ - const nsHTMLReflowState* const mReflowState; + const ReflowInput* const mReflowState; nsRenderingContext& mRenderingContext; nsGridContainerFrame* const mFrame; SharedGridData* mSharedGridData; // [weak] owned by mFrame's first-in-flow. /** Computed border+padding with mSkipSides applied. */ LogicalMargin mBorderPadding; /** * BStart of this fragment in "grid space" (i.e. the concatenation of content * areas of all fragments). Equal to mRows.mSizes[mStartRow].mPosition, @@ -1845,17 +1845,17 @@ struct MOZ_STACK_CLASS nsGridContainerFr uint32_t mStartRow; /** Our tentative ApplySkipSides bits. */ LogicalSides mSkipSides; const WritingMode mWM; private: GridReflowState(nsGridContainerFrame* aFrame, nsRenderingContext& aRenderingContext, - const nsHTMLReflowState* aReflowState, + const ReflowInput* aReflowState, const nsStylePosition* aGridStyle, const WritingMode& aWM) : mIter(aFrame, kPrincipalList) , mGridStyle(aGridStyle) , mCols(eLogicalAxisInline) , mRows(eLogicalAxisBlock) , mColFunctions(mGridStyle->mGridTemplateColumns, mGridStyle->mGridAutoColumnsMin, @@ -2304,17 +2304,17 @@ SpaceToFill(WritingMode aWM, const Logic : aSize.ISize(aWM); return aCBSize - (size + aMargin); } // Align an item's margin box in its aAxis inside aCBSize. static void AlignJustifySelf(uint8_t aAlignment, bool aOverflowSafe, LogicalAxis aAxis, bool aSameSide, nscoord aBaselineAdjust, nscoord aCBSize, - const nsHTMLReflowState& aRS, const LogicalSize& aChildSize, + const ReflowInput& aRS, const LogicalSize& aChildSize, LogicalPoint* aPos) { MOZ_ASSERT(aAlignment != NS_STYLE_ALIGN_AUTO, "unexpected 'auto' " "computed value for normal flow grid item"); MOZ_ASSERT(aAlignment != NS_STYLE_ALIGN_LEFT && aAlignment != NS_STYLE_ALIGN_RIGHT, "caller should map that to the corresponding START/END"); @@ -2441,17 +2441,17 @@ SameSide(WritingMode aContainerWM, Logic aChildWM.PhysicalAxis(GetAxis(aChildSide))); return aContainerWM.PhysicalSide(aContainerSide) == aChildWM.PhysicalSide(aChildSide); } static void AlignSelf(const nsGridContainerFrame::GridItemInfo& aGridItem, uint8_t aAlignSelf, nscoord aCBSize, const WritingMode aCBWM, - const nsHTMLReflowState& aRS, const LogicalSize& aSize, + const ReflowInput& aRS, const LogicalSize& aSize, LogicalPoint* aPos) { auto alignSelf = aAlignSelf; bool overflowSafe = alignSelf & NS_STYLE_ALIGN_SAFE; alignSelf &= ~NS_STYLE_ALIGN_FLAG_BITS; // Grid's 'align-self' axis is never parallel to the container's inline axis. if (alignSelf == NS_STYLE_ALIGN_LEFT || alignSelf == NS_STYLE_ALIGN_RIGHT) { alignSelf = NS_STYLE_ALIGN_START; @@ -2475,17 +2475,17 @@ AlignSelf(const nsGridContainerFrame::Gr LogicalAxis axis = isOrthogonal ? eLogicalAxisInline : eLogicalAxisBlock; AlignJustifySelf(alignSelf, overflowSafe, axis, sameSide, baselineAdjust, aCBSize, aRS, aSize, aPos); } static void JustifySelf(const nsGridContainerFrame::GridItemInfo& aGridItem, uint8_t aJustifySelf, nscoord aCBSize, const WritingMode aCBWM, - const nsHTMLReflowState& aRS, const LogicalSize& aSize, + const ReflowInput& aRS, const LogicalSize& aSize, LogicalPoint* aPos) { auto justifySelf = aJustifySelf; bool overflowSafe = justifySelf & NS_STYLE_JUSTIFY_SAFE; justifySelf &= ~NS_STYLE_JUSTIFY_FLAG_BITS; if (MOZ_LIKELY(justifySelf == NS_STYLE_ALIGN_NORMAL)) { justifySelf = NS_STYLE_ALIGN_STRETCH; } @@ -3415,40 +3415,40 @@ nsGridContainerFrame::Tracks::Initialize mContentBoxSize = aContentBoxSize; } /** * Reflow aChild in the given aAvailableSize. */ static nscoord MeasuringReflow(nsIFrame* aChild, - const nsHTMLReflowState* aReflowState, + const ReflowInput* aReflowState, nsRenderingContext* aRC, const LogicalSize& aAvailableSize) { nsContainerFrame* parent = aChild->GetParent(); nsPresContext* pc = aChild->PresContext(); - Maybe<nsHTMLReflowState> dummyParentState; - const nsHTMLReflowState* rs = aReflowState; + Maybe<ReflowInput> dummyParentState; + const ReflowInput* rs = aReflowState; if (!aReflowState) { MOZ_ASSERT(!parent->HasAnyStateBits(NS_FRAME_IN_REFLOW)); dummyParentState.emplace(pc, parent, aRC, LogicalSize(parent->GetWritingMode(), 0, NS_UNCONSTRAINEDSIZE), - nsHTMLReflowState::DUMMY_PARENT_REFLOW_STATE); + ReflowInput::DUMMY_PARENT_REFLOW_STATE); rs = dummyParentState.ptr(); } #ifdef DEBUG // This will suppress various CRAZY_SIZE warnings for this reflow. parent->Properties().Set( nsContainerFrame::DebugReflowingWithInfiniteISize(), true); #endif - nsHTMLReflowState childRS(pc, *rs, aChild, aAvailableSize, nullptr, - nsHTMLReflowState::COMPUTE_SIZE_SHRINK_WRAP | - nsHTMLReflowState::COMPUTE_SIZE_USE_AUTO_BSIZE); + ReflowInput childRS(pc, *rs, aChild, aAvailableSize, nullptr, + ReflowInput::COMPUTE_SIZE_SHRINK_WRAP | + ReflowInput::COMPUTE_SIZE_USE_AUTO_BSIZE); nsHTMLReflowMetrics childSize(childRS); nsReflowStatus childStatus; const uint32_t flags = NS_FRAME_NO_MOVE_FRAME | NS_FRAME_NO_SIZE_VIEW; WritingMode wm = childRS.GetWritingMode(); parent->ReflowChild(aChild, pc, childSize, childRS, wm, LogicalPoint(wm), nsSize(), flags, childStatus); parent->FinishReflowChild(aChild, pc, childSize, &childRS, wm, LogicalPoint(wm), nsSize(), flags); @@ -4559,18 +4559,18 @@ nsGridContainerFrame::GridReflowState::C * continue traversing the ancestor chain as long as the CBs have * the same writing-mode and have overflow:visible. */ Maybe<nsGridContainerFrame::Fragmentainer> nsGridContainerFrame::GetNearestFragmentainer(const GridReflowState& aState) const { Maybe<nsGridContainerFrame::Fragmentainer> data; WritingMode wm = aState.mWM; - const nsHTMLReflowState* gridRS = aState.mReflowState; - const nsHTMLReflowState* cbRS = gridRS->mCBReflowState; + const ReflowInput* gridRS = aState.mReflowState; + const ReflowInput* cbRS = gridRS->mCBReflowState; for ( ; cbRS; cbRS = cbRS->mCBReflowState) { nsIScrollableFrame* sf = do_QueryFrame(cbRS->frame); if (sf) { break; } if (wm.IsOrthogonalTo(cbRS->GetWritingMode())) { break; } @@ -4688,17 +4688,17 @@ nsGridContainerFrame::ReflowInFlowChild( reflowSize.BSize(wm) = toFragmentainerEnd; } LogicalSize childCBSize = reflowSize.ConvertTo(childWM, wm); if (!isConstrainedBSize) { childCBSize.BSize(childWM) = NS_UNCONSTRAINEDSIZE; } LogicalSize percentBasis(cb.Size(wm).ConvertTo(childWM, wm)); - nsHTMLReflowState childRS(pc, *aState.mReflowState, aChild, childCBSize, + ReflowInput childRS(pc, *aState.mReflowState, aChild, childCBSize, &percentBasis); childRS.mFlags.mIsTopOfPage = aFragmentainer ? aFragmentainer->mIsTopOfPage : false; // If the child is stretching in its block axis, and we might be fragmenting // it in that axis, then setup a frame property to tell // nsBlockFrame::ComputeFinalSize the size. if (isConstrainedBSize && !wm.IsOrthogonalTo(childWM)) { bool stretch = false; @@ -5342,17 +5342,17 @@ nsGridContainerFrame::ReflowChildren(Gri } } return bSize; } void nsGridContainerFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsGridContainerFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); if (IsFrameTreeTooDeep(aReflowState, aDesiredSize, aStatus)) { return; @@ -5544,17 +5544,17 @@ nsGridContainerFrame::Reflow(nsPresConte LogicalSize computedSize(wm, computedISize, computedBSize); nscoord consumedBSize = 0; if (!prevInFlow) { // ComputedMinSize is zero rather than NS_UNCONSTRAINEDSIZE when indefinite // (unfortunately) so we have to check the style data and parent reflow state // to determine if it's indefinite. LogicalSize computedMinSize(aReflowState.ComputedMinSize()); - const nsHTMLReflowState* cbState = aReflowState.mCBReflowState; + const ReflowInput* cbState = aReflowState.mCBReflowState; if (!stylePos->MinISize(wm).IsCoordPercentCalcUnit() || (stylePos->MinISize(wm).HasPercent() && cbState && cbState->ComputedSize(wm).ISize(wm) == NS_UNCONSTRAINEDSIZE)) { computedMinSize.ISize(wm) = NS_UNCONSTRAINEDSIZE; } if (!stylePos->MinBSize(wm).IsCoordPercentCalcUnit() || (stylePos->MinBSize(wm).HasPercent() && cbState && cbState->ComputedSize(wm).BSize(wm) == NS_UNCONSTRAINEDSIZE)) {
--- a/layout/generic/nsGridContainerFrame.h +++ b/layout/generic/nsGridContainerFrame.h @@ -68,17 +68,17 @@ public: NS_DECL_QUERYFRAME_TARGET(nsGridContainerFrame) NS_DECL_QUERYFRAME typedef mozilla::ComputedGridTrackInfo ComputedGridTrackInfo; typedef mozilla::ComputedGridLineInfo ComputedGridLineInfo; // nsIFrame overrides void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; nscoord GetMinISize(nsRenderingContext* aRenderingContext) override; nscoord GetPrefISize(nsRenderingContext* aRenderingContext) override; void MarkIntrinsicISizesDirty() override; nsIAtom* GetType() const override; bool IsFrameOfType(uint32_t aFlags) const override { return nsContainerFrame::IsFrameOfType(aFlags &
--- a/layout/generic/nsHTMLCanvasFrame.cpp +++ b/layout/generic/nsHTMLCanvasFrame.cpp @@ -244,17 +244,17 @@ nsHTMLCanvasFrame::ComputeSize(nsRenderi aMargin, aBorder, aPadding); } void nsHTMLCanvasFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aMetrics, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsHTMLCanvasFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus); NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS, ("enter nsHTMLCanvasFrame::Reflow: availSize=%d,%d", aReflowState.AvailableWidth(), aReflowState.AvailableHeight())); @@ -287,17 +287,17 @@ nsHTMLCanvasFrame::Reflow(nsPresContext* // Reflow the single anon block child. nsReflowStatus childStatus; nsIFrame* childFrame = mFrames.FirstChild(); WritingMode childWM = childFrame->GetWritingMode(); LogicalSize availSize = aReflowState.ComputedSize(childWM); availSize.BSize(childWM) = NS_UNCONSTRAINEDSIZE; NS_ASSERTION(!childFrame->GetNextSibling(), "HTML canvas should have 1 kid"); nsHTMLReflowMetrics childDesiredSize(aReflowState.GetWritingMode(), aMetrics.mFlags); - nsHTMLReflowState childReflowState(aPresContext, aReflowState, childFrame, + ReflowInput childReflowState(aPresContext, aReflowState, childFrame, availSize); ReflowChild(childFrame, aPresContext, childDesiredSize, childReflowState, 0, 0, 0, childStatus, nullptr); FinishReflowChild(childFrame, aPresContext, childDesiredSize, &childReflowState, 0, 0, 0); NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS, ("exit nsHTMLCanvasFrame::Reflow: size=%d,%d",
--- a/layout/generic/nsHTMLCanvasFrame.h +++ b/layout/generic/nsHTMLCanvasFrame.h @@ -68,17 +68,17 @@ public: nscoord aAvailableISize, const mozilla::LogicalSize& aMargin, const mozilla::LogicalSize& aBorder, const mozilla::LogicalSize& aPadding, ComputeSizeFlags aFlags) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; nsRect GetInnerArea() const; #ifdef ACCESSIBILITY virtual mozilla::a11y::AccType AccessibleType() override; #endif
--- a/layout/generic/nsHTMLReflowMetrics.cpp +++ b/layout/generic/nsHTMLReflowMetrics.cpp @@ -31,17 +31,17 @@ nsOverflowAreas::UnionAllWith(const nsRe void nsOverflowAreas::SetAllTo(const nsRect& aRect) { NS_FOR_FRAME_OVERFLOW_TYPES(otype) { mRects[otype] = aRect; } } -nsHTMLReflowMetrics::nsHTMLReflowMetrics(const nsHTMLReflowState& aState, +nsHTMLReflowMetrics::nsHTMLReflowMetrics(const ReflowInput& aState, uint32_t aFlags) : mISize(0) , mBSize(0) , mBlockStartAscent(ASK_FOR_BASELINE) , mFlags(aFlags) , mWritingMode(aState.GetWritingMode()) { }
--- a/layout/generic/nsHTMLReflowMetrics.h +++ b/layout/generic/nsHTMLReflowMetrics.h @@ -10,17 +10,17 @@ #include "mozilla/WritingModes.h" #include "nsBoundingMetrics.h" #include "nsRect.h" //---------------------------------------------------------------------- namespace mozilla { -struct nsHTMLReflowState; +struct ReflowInput; } // namespace mozilla // Option flags #define NS_REFLOW_CALC_BOUNDING_METRICS 0x0001 /** * When we store overflow areas as an array of scrollable and visual * overflow, we use these indices. @@ -194,34 +194,34 @@ struct nsCollapsingMargin { /** * Reflow metrics used to return the frame's desired size and alignment * information. * * @see #Reflow() */ class nsHTMLReflowMetrics { - using nsHTMLReflowState = mozilla::nsHTMLReflowState; + using ReflowInput = mozilla::ReflowInput; public: // XXXldb Should |aFlags| generally be passed from parent to child? // Some places do it, and some don't. |aFlags| should perhaps go away // entirely. // XXX width/height/ascent are OUT parameters and so they shouldn't // have to be initialized, but there are some bad frame classes that // aren't properly setting them when returning from Reflow()... explicit nsHTMLReflowMetrics(mozilla::WritingMode aWritingMode, uint32_t aFlags = 0) : mISize(0) , mBSize(0) , mBlockStartAscent(ASK_FOR_BASELINE) , mFlags(aFlags) , mWritingMode(aWritingMode) {} - explicit nsHTMLReflowMetrics(const nsHTMLReflowState& aState, uint32_t aFlags = 0); + explicit nsHTMLReflowMetrics(const ReflowInput& aState, uint32_t aFlags = 0); // ISize and BSize are logical-coordinate dimensions: // ISize is the size in the writing mode's inline direction (which equates to // width in horizontal writing modes, height in vertical ones), and BSize is // the size in the block-progression direction. nscoord ISize(mozilla::WritingMode aWritingMode) const { NS_ASSERTION(!aWritingMode.IsOrthogonalTo(mWritingMode), "mismatched writing mode");
--- a/layout/generic/nsIFrame.h +++ b/layout/generic/nsIFrame.h @@ -88,17 +88,17 @@ struct nsRect; struct nsSize; struct nsMargin; struct CharacterDataChangeInfo; namespace mozilla { enum class CSSPseudoElementType : uint8_t; class EventStates; -struct nsHTMLReflowState; +struct ReflowInput; namespace layers { class Layer; } // namespace layers namespace gfx { class Matrix; } // namespace gfx @@ -418,17 +418,17 @@ static void ReleaseValue(T* aPropertyVal class nsIFrame : public nsQueryFrame { public: template <typename T> using Maybe = mozilla::Maybe<T>; using Nothing = mozilla::Nothing; using OnNonvisible = mozilla::OnNonvisible; template<typename T=void> using PropertyDescriptor = const mozilla::FramePropertyDescriptor<T>*; - using nsHTMLReflowState = mozilla::nsHTMLReflowState; + using ReflowInput = mozilla::ReflowInput; using Visibility = mozilla::Visibility; using VisibilityCounter = mozilla::VisibilityCounter; typedef mozilla::FrameProperties FrameProperties; typedef mozilla::layers::Layer Layer; typedef mozilla::layout::FrameChildList ChildList; typedef mozilla::layout::FrameChildListID ChildListID; typedef mozilla::layout::FrameChildListIDs ChildListIDs; @@ -807,19 +807,19 @@ public: } /** * Move the frame, accounting for relative positioning. Use this when * adjusting the frame's position by a known amount, to properly update its * saved normal position (see GetNormalPosition below). * * This must be used only when moving a frame *after* - * nsHTMLReflowState::ApplyRelativePositioning is called. When moving + * ReflowInput::ApplyRelativePositioning is called. When moving * a frame during the reflow process prior to calling - * nsHTMLReflowState::ApplyRelativePositioning, the position should + * ReflowInput::ApplyRelativePositioning, the position should * simply be adjusted directly (e.g., using SetPosition()). */ void MovePositionBy(const nsPoint& aTranslation); /** * As above, using a logical-point delta in a given writing mode. */ void MovePositionBy(mozilla::WritingMode aWritingMode, @@ -1914,17 +1914,17 @@ public: /* Set if we'd like to compute our 'auto' bsize, regardless of our actual * corresponding computed value. (e.g. to get an intrinsic height for flex * items with "min-height: auto" to use during flexbox layout.) */ eUseAutoBSize = 1 << 1 }; /** * Compute the size that a frame will occupy. Called while - * constructing the nsHTMLReflowState to be used to Reflow the frame, + * constructing the ReflowInput to be used to Reflow the frame, * in order to fill its mComputedWidth and mComputedHeight member * variables. * * The |height| member of the return value may be * NS_UNCONSTRAINEDSIZE, but the |width| member must not be. * * Note that the reason that border and padding need to be passed * separately is so that the 'box-sizing' property can be handled. @@ -2042,17 +2042,17 @@ public: * you must <b>always</b> reflow at least one frame regardless of the * available space * * @param aStatus a return value indicating whether the frame is complete * and whether the next-in-flow is dirty and needs to be reflowed */ virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aReflowMetrics, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) = 0; /** * Post-reflow hook. After a frame is reflowed this method will be called * informing the frame that this reflow process is complete, and telling the * frame the status returned by the Reflow member function. * * This call may be invoked many times, while NS_FRAME_IN_REFLOW is set, before @@ -2061,17 +2061,17 @@ public: * frame state will be cleared. * * XXX This doesn't make sense. If the frame is reflowed but not complete, then * the status should be NS_FRAME_NOT_COMPLETE and not NS_FRAME_COMPLETE * XXX Don't we want the semantics to dictate that we only call this once for * a given reflow? */ virtual void DidReflow(nsPresContext* aPresContext, - const nsHTMLReflowState* aReflowState, + const ReflowInput* aReflowState, nsDidReflowStatus aStatus) = 0; /** * Updates the overflow areas of the frame. This can be called if an * overflow area of the frame's children has changed without reflowing. * @return true if either of the overflow areas for this frame have changed. */ bool UpdateOverflow(); @@ -2289,17 +2289,17 @@ public: eSVGPaintServer = 1 << 5, eBidiInlineContainer = 1 << 6, // the frame is for a replaced element, such as an image eReplaced = 1 << 7, // Frame that contains a block but looks like a replaced element // from the outside eReplacedContainsBlock = 1 << 8, // A frame that participates in inline reflow, i.e., one that - // requires nsHTMLReflowState::mLineLayout. + // requires ReflowInput::mLineLayout. eLineParticipant = 1 << 9, eXULBox = 1 << 10, eCanContainOverflowContainers = 1 << 11, eBlockFrame = 1 << 12, eTablePart = 1 << 13, // If this bit is set, the frame doesn't allow ignorable whitespace as // children. For example, the whitespace between <table>\n<tr>\n<td> // will be excluded during the construction of children. @@ -2658,23 +2658,23 @@ public: * on certain sides of the frame. * @see mozilla::Sides in gfx/2d/BaseMargin.h * @see mozilla::LogicalSides in layout/generic/WritingModes.h * * @note (See also bug 743402, comment 11) GetSkipSides() checks to see * if this frame has a previous or next continuation to determine * if a side should be skipped. * Unfortunately, this only works after reflow has been completed. In - * lieu of this, during reflow, an nsHTMLReflowState parameter can be + * lieu of this, during reflow, an ReflowInput parameter can be * passed in, indicating that it should be used to determine if sides * should be skipped during reflow. */ - Sides GetSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const; + Sides GetSkipSides(const ReflowInput* aReflowState = nullptr) const; virtual LogicalSides - GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const { + GetLogicalSkipSides(const ReflowInput* aReflowState = nullptr) const { return LogicalSides(); } /** * @returns true if this frame is selected. */ bool IsSelected() const;
--- a/layout/generic/nsImageFrame.cpp +++ b/layout/generic/nsImageFrame.cpp @@ -111,17 +111,17 @@ static bool HaveSpecifiedSize(const nsSt // - if width and height are specified as either coord or percentage, then // the size of the image frame is constrained return aStylePosition->mWidth.IsCoordPercentCalcUnit() && aStylePosition->mHeight.IsCoordPercentCalcUnit(); } // Decide whether we can optimize away reflows that result from the // image's intrinsic size changing. -inline bool HaveFixedSize(const nsHTMLReflowState& aReflowState) +inline bool HaveFixedSize(const ReflowInput& aReflowState) { NS_ASSERTION(aReflowState.mStylePosition, "crappy reflowState - null stylePosition"); // Don't try to make this optimization when an image has percentages // in its 'width' or 'height'. The percentages might be treated like // auto (especially for intrinsic width calculations and for heights). return aReflowState.mStylePosition->mHeight.ConvertsToLength() && aReflowState.mStylePosition->mWidth.ConvertsToLength(); } @@ -944,17 +944,17 @@ nsImageFrame::GetIntrinsicSize() nsImageFrame::GetIntrinsicRatio() { return mIntrinsicRatio; } void nsImageFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aMetrics, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsImageFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus); NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS, ("enter nsImageFrame::Reflow: availSize=%d,%d", aReflowState.AvailableWidth(), aReflowState.AvailableHeight())); @@ -2147,17 +2147,17 @@ nsImageFrame::List(FILE* out, const char str += nsPrintfCString(" [src=%s]", uristr.get()); } } fprintf_stderr(out, "%s\n", str.get()); } #endif nsIFrame::LogicalSides -nsImageFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const +nsImageFrame::GetLogicalSkipSides(const ReflowInput* aReflowState) const { if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak == NS_STYLE_BOX_DECORATION_BREAK_CLONE)) { return LogicalSides(); } LogicalSides skip; if (nullptr != GetPrevInFlow()) { skip |= eLogicalSideBitsBStart;
--- a/layout/generic/nsImageFrame.h +++ b/layout/generic/nsImageFrame.h @@ -86,17 +86,17 @@ public: const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override; virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override; virtual mozilla::IntrinsicSize GetIntrinsicSize() override; virtual nsSize GetIntrinsicRatio() override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsresult GetContentForEvent(mozilla::WidgetEvent* aEvent, nsIContent** aContent) override; virtual nsresult HandleEvent(nsPresContext* aPresContext, mozilla::WidgetGUIEvent* aEvent, nsEventStatus* aEventStatus) override; virtual nsresult GetCursor(const nsPoint& aPoint, @@ -127,17 +127,17 @@ public: uint32_t aFlags = 0) const override; #endif nsSplittableType GetSplittableType() const override { return NS_FRAME_SPLITTABLE; } - virtual LogicalSides GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const override; + virtual LogicalSides GetLogicalSkipSides(const ReflowInput* aReflowState = nullptr) const override; nsresult GetIntrinsicImageSize(nsSize& aSize); static void ReleaseGlobals() { if (gIconLoad) { gIconLoad->Shutdown(); NS_RELEASE(gIconLoad); }
--- a/layout/generic/nsInlineFrame.cpp +++ b/layout/generic/nsInlineFrame.cpp @@ -357,17 +357,17 @@ ReparentChildListStyle(nsPresContext* aP restyleManager->ReparentStyleContext(e.get()); nsLayoutUtils::MarkDescendantsDirty(e.get()); } } void nsInlineFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aMetrics, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsInlineFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus); if (nullptr == aReflowState.mLineLayout) { NS_ERROR("must have non-null aReflowState.mLineLayout"); return; @@ -564,17 +564,17 @@ nsInlineFrame::PullOverflowsFromPrevInFl this); mFrames.InsertFrames(this, nullptr, *prevOverflowFrames); } } } void nsInlineFrame::ReflowFrames(nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, InlineReflowState& irs, nsHTMLReflowMetrics& aMetrics, nsReflowStatus& aStatus) { aStatus = NS_FRAME_COMPLETE; nsLineLayout* lineLayout = aReflowState.mLineLayout; bool inFirstLine = aReflowState.mLineLayout->GetInFirstLine(); @@ -789,17 +789,17 @@ nsInlineFrame::ReflowFrames(nsPresContex ListTag(stdout); printf(": metrics=%d,%d ascent=%d\n", aMetrics.Width(), aMetrics.Height(), aMetrics.TopAscent()); #endif } void nsInlineFrame::ReflowInlineFrame(nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, InlineReflowState& irs, nsIFrame* aFrame, nsReflowStatus& aStatus) { nsLineLayout* lineLayout = aReflowState.mLineLayout; bool reflowingFirstLetter = lineLayout->GetFirstLetterStyleOK(); bool pushedFrame; lineLayout->ReflowFrame(aFrame, aStatus, nullptr, pushedFrame); @@ -936,17 +936,17 @@ nsInlineFrame::PushFrames(nsPresContext* aState.mLineLayout->SetDirtyNextLine(); } } ////////////////////////////////////////////////////////////////////// nsIFrame::LogicalSides -nsInlineFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const +nsInlineFrame::GetLogicalSkipSides(const ReflowInput* aReflowState) const { if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak == NS_STYLE_BOX_DECORATION_BREAK_CLONE)) { return LogicalSides(); } LogicalSides skip; if (!IsFirst()) { @@ -1088,17 +1088,17 @@ nsFirstLineFrame::PullOneFrame(nsPresCon nsLayoutUtils::MarkDescendantsDirty(frame); } return frame; } void nsFirstLineFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aMetrics, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); if (nullptr == aReflowState.mLineLayout) { return; // XXX does this happen? why? } nsIFrame* lineContainer = aReflowState.mLineLayout->LineContainerFrame();
--- a/layout/generic/nsInlineFrame.h +++ b/layout/generic/nsInlineFrame.h @@ -76,17 +76,17 @@ public: nscoord aAvailableISize, const mozilla::LogicalSize& aMargin, const mozilla::LogicalSize& aBorder, const mozilla::LogicalSize& aPadding, ComputeSizeFlags aFlags) override; virtual nsRect ComputeTightBounds(DrawTarget* aDrawTarget) const override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsresult AttributeChanged(int32_t aNameSpaceID, nsIAtom* aAttribute, int32_t aModType) override; virtual bool CanContinueTextRun() const override; @@ -132,26 +132,26 @@ protected: mLineContainer = nullptr; mLineLayout = nullptr; mSetParentPointer = false; } }; explicit nsInlineFrame(nsStyleContext* aContext) : nsContainerFrame(aContext) {} - virtual LogicalSides GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const override; + virtual LogicalSides GetLogicalSkipSides(const ReflowInput* aReflowState = nullptr) const override; void ReflowFrames(nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, InlineReflowState& rs, nsHTMLReflowMetrics& aMetrics, nsReflowStatus& aStatus); void ReflowInlineFrame(nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, InlineReflowState& rs, nsIFrame* aFrame, nsReflowStatus& aStatus); /** * Reparent floats whose placeholders are inline descendants of aFrame from * whatever block they're currently parented by to aOurBlock. * @param aReparentSiblings if this is true, we follow aFrame's @@ -205,17 +205,17 @@ public: nsStyleContext* aContext); #ifdef DEBUG_FRAME_DUMP virtual nsresult GetFrameName(nsAString& aResult) const override; #endif virtual nsIAtom* GetType() const override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual void Init(nsIContent* aContent, nsContainerFrame* aParent, nsIFrame* aPrevInFlow) override; virtual void PullOverflowsFromPrevInFlow() override; virtual bool DrainSelfOverflowList() override;
--- a/layout/generic/nsLeafFrame.cpp +++ b/layout/generic/nsLeafFrame.cpp @@ -46,17 +46,17 @@ nsLeafFrame::ComputeAutoSize(nsRendering const WritingMode wm = GetWritingMode(); LogicalSize result(wm, GetIntrinsicISize(), GetIntrinsicBSize()); return result.ConvertTo(aWM, wm); } void nsLeafFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aMetrics, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsLeafFrame"); NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS, ("enter nsLeafFrame::Reflow: aMaxSize=%d,%d", aReflowState.AvailableWidth(), aReflowState.AvailableHeight())); @@ -65,17 +65,17 @@ nsLeafFrame::Reflow(nsPresContext* aPres DoReflow(aPresContext, aMetrics, aReflowState, aStatus); FinishAndStoreOverflow(&aMetrics); } void nsLeafFrame::DoReflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aMetrics, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { NS_ASSERTION(aReflowState.ComputedWidth() != NS_UNCONSTRAINEDSIZE, "Shouldn't have unconstrained stuff here " "thanks to the rules of reflow"); NS_ASSERTION(NS_INTRINSICSIZE != aReflowState.ComputedHeight(), "Shouldn't have unconstrained stuff here " "thanks to ComputeAutoSize"); @@ -98,17 +98,17 @@ nsLeafFrame::DoReflow(nsPresContext* aPr nscoord nsLeafFrame::GetIntrinsicBSize() { NS_NOTREACHED("Someone didn't override Reflow or ComputeAutoSize"); return 0; } void -nsLeafFrame::SizeToAvailSize(const nsHTMLReflowState& aReflowState, +nsLeafFrame::SizeToAvailSize(const ReflowInput& aReflowState, nsHTMLReflowMetrics& aDesiredSize) { WritingMode wm = aReflowState.GetWritingMode(); LogicalSize size(wm, aReflowState.AvailableISize(), // FRAME aReflowState.AvailableBSize()); aDesiredSize.SetSize(wm, size); aDesiredSize.SetOverflowAreasToDesiredBounds(); FinishAndStoreOverflow(&aDesiredSize);
--- a/layout/generic/nsLeafFrame.h +++ b/layout/generic/nsLeafFrame.h @@ -53,25 +53,25 @@ public: /** * Reflow our frame. This will use the computed width plus borderpadding for * the desired width, and use the return value of GetIntrinsicBSize plus * borderpadding for the desired height. Ascent will be set to the height, * and descent will be set to 0. */ virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; /** * This method does most of the work that Reflow() above need done. */ virtual void DoReflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus); virtual bool IsFrameOfType(uint32_t aFlags) const override { // We don't actually contain a block, but we do always want a // computed width, so tell a little white lie here. return nsFrame::IsFrameOfType(aFlags & ~(nsIFrame::eReplacedContainsBlock)); } @@ -94,13 +94,13 @@ protected: * Reflow and ComputeAutoSize; the default Reflow and ComputeAutoSize impls * call this method. */ virtual nscoord GetIntrinsicBSize(); /** * Set aDesiredSize to be the available size */ - void SizeToAvailSize(const nsHTMLReflowState& aReflowState, + void SizeToAvailSize(const ReflowInput& aReflowState, nsHTMLReflowMetrics& aDesiredSize); }; #endif /* nsLeafFrame_h___ */
--- a/layout/generic/nsLineLayout.cpp +++ b/layout/generic/nsLineLayout.cpp @@ -49,17 +49,17 @@ using namespace mozilla; //---------------------------------------------------------------------- #define FIX_BUG_50257 nsLineLayout::nsLineLayout(nsPresContext* aPresContext, nsFloatManager* aFloatManager, - const nsHTMLReflowState* aOuterReflowState, + const ReflowInput* aOuterReflowState, const nsLineList::iterator* aLine, nsLineLayout* aBaseLineLayout) : mPresContext(aPresContext), mFloatManager(aFloatManager), mBlockReflowState(aOuterReflowState), mBaseLineLayout(aBaseLineLayout), mLastOptionalBreakFrame(nullptr), mForceBreakFrame(nullptr), @@ -411,17 +411,17 @@ nsLineLayout::NewPerSpanData() #ifdef DEBUG outerLineLayout->mSpansAllocated++; #endif return psd; } void nsLineLayout::BeginSpan(nsIFrame* aFrame, - const nsHTMLReflowState* aSpanReflowState, + const ReflowInput* aSpanReflowState, nscoord aIStart, nscoord aIEnd, nscoord* aBaseline) { NS_ASSERTION(aIEnd != NS_UNCONSTRAINEDSIZE, "should no longer be using unconstrained sizes"); #ifdef NOISY_REFLOW nsFrame::IndentBy(stdout, mSpanDepth+1); nsFrame::ListTag(stdout, aFrame); @@ -868,26 +868,26 @@ nsLineLayout::ReflowFrame(nsIFrame* aFra // reflects the space left on the line. LAYOUT_WARN_IF_FALSE(psd->mIEnd != NS_UNCONSTRAINEDSIZE, "have unconstrained width; this should only result from " "very large sizes, not attempts at intrinsic width " "calculation"); nscoord availableSpaceOnLine = psd->mIEnd - psd->mICoord; // Setup reflow state for reflowing the frame - Maybe<nsHTMLReflowState> reflowStateHolder; + Maybe<ReflowInput> reflowStateHolder; if (!isText) { // Compute the available size for the frame. This available width // includes room for the side margins. // For now, set the available block-size to unconstrained always. LogicalSize availSize = mBlockReflowState->ComputedSize(frameWM); availSize.BSize(frameWM) = NS_UNCONSTRAINEDSIZE; reflowStateHolder.emplace(mPresContext, *psd->mReflowState, aFrame, availSize); - nsHTMLReflowState& reflowState = *reflowStateHolder; + ReflowInput& reflowState = *reflowStateHolder; reflowState.mLineLayout = this; reflowState.mFlags.mIsTopOfPage = mIsTopOfPage; if (reflowState.ComputedISize() == NS_UNCONSTRAINEDSIZE) { reflowState.AvailableISize() = availableSpaceOnLine; } WritingMode stateWM = reflowState.GetWritingMode(); pfd->mMargin = reflowState.ComputedLogicalMargin().ConvertTo(lineWM, stateWM); @@ -909,17 +909,17 @@ nsLineLayout::ReflowFrame(nsIFrame* aFra // if isText(), no need to propagate NS_FRAME_IS_DIRTY from the parent, // because reflow doesn't look at the dirty bits on the frame being reflowed. // See if this frame depends on the width of its containing block. If // so, disable resize reflow optimizations for the line. (Note that, // to be conservative, we do this if we *try* to fit a frame on a // line, even if we don't succeed.) (Note also that we can only make // this IsPercentageAware check *after* we've constructed our - // nsHTMLReflowState, because that construction may be what forces aFrame + // ReflowInput, because that construction may be what forces aFrame // to lazily initialize its (possibly-percent-valued) intrinsic size.) if (mGotLineBox && IsPercentageAware(aFrame)) { mLineBox->DisableResizeReflowOptimization(); } // Note that we don't bother positioning the frame yet, because we're probably // going to end up moving it when we do the block-direction alignment. @@ -1165,17 +1165,17 @@ nsLineLayout::ReflowFrame(nsIFrame* aFra printf("End ReflowFrame "); nsFrame::ListTag(stdout, aFrame); printf(" status=%x\n", aReflowStatus); #endif } void nsLineLayout::AllowForStartMargin(PerFrameData* pfd, - nsHTMLReflowState& aReflowState) + ReflowInput& aReflowState) { NS_ASSERTION(!aReflowState.IsFloating(), "How'd we get a floated inline frame? " "The frame ctor should've dealt with this."); WritingMode lineWM = mRootSpan->mWritingMode; // Only apply start-margin on the first-in flow for inline frames, @@ -1897,17 +1897,17 @@ nsLineLayout::VerticalAlignFrames(PerSpa #endif } else { // Compute the logical block size for this span. The logical block size // is based on the "line-height" value, not the font-size. Also // compute the top leading. float inflation = GetInflationForBlockDirAlignment(spanFrame, mInflationMinFontSize); - nscoord logicalBSize = nsHTMLReflowState:: + nscoord logicalBSize = ReflowInput:: CalcLineHeight(spanFrame->GetContent(), spanFrame->StyleContext(), mBlockReflowState->ComputedHeight(), inflation); nscoord contentBSize = spanFramePFD->mBounds.BSize(lineWM) - spanFramePFD->mBorderPadding.BStartEnd(lineWM); // Special-case for a ::first-letter frame, set the line height to // the frame block size if the user has left line-height == normal @@ -2186,17 +2186,17 @@ nsLineLayout::VerticalAlignFrames(PerSpa } else { // We have either a coord, a percent, or a calc(). nscoord pctBasis = 0; if (verticalAlign.HasPercent()) { // Percentages are like lengths, except treated as a percentage // of the elements line block size value. float inflation = GetInflationForBlockDirAlignment(frame, mInflationMinFontSize); - pctBasis = nsHTMLReflowState::CalcLineHeight(frame->GetContent(), + pctBasis = ReflowInput::CalcLineHeight(frame->GetContent(), frame->StyleContext(), mBlockReflowState->ComputedBSize(), inflation); } nscoord offset = nsRuleNode::ComputeCoordPercentCalc(verticalAlign, pctBasis); // According to the CSS2 spec (10.8.1), a positive value // "raises" the box by the given distance while a negative value // "lowers" the box by the given distance (with zero being the @@ -3259,18 +3259,18 @@ nsLineLayout::ApplyRelativePositioning(P if (!aPFD->mRelativePos) { return; } nsIFrame* frame = aPFD->mFrame; WritingMode frameWM = aPFD->mWritingMode; LogicalPoint origin = frame->GetLogicalPosition(ContainerSize()); // right and bottom are handled by - // nsHTMLReflowState::ComputeRelativeOffsets - nsHTMLReflowState::ApplyRelativePositioning(frame, frameWM, + // ReflowInput::ComputeRelativeOffsets + ReflowInput::ApplyRelativePositioning(frame, frameWM, aPFD->mOffsets, &origin, ContainerSize()); frame->SetPosition(frameWM, origin, ContainerSize()); } // This method do relative positioning for ruby annotations. void nsLineLayout::RelativePositionAnnotations(PerSpanData* aRubyPSD,
--- a/layout/generic/nsLineLayout.h +++ b/layout/generic/nsLineLayout.h @@ -23,26 +23,26 @@ #include "nsBlockReflowState.h" #include "nsLineBox.h" #include "plarena.h" class nsFloatManager; struct nsStyleText; class nsLineLayout { - using nsHTMLReflowState = mozilla::nsHTMLReflowState; + using ReflowInput = mozilla::ReflowInput; public: /** * @param aBaseLineLayout the nsLineLayout for ruby base, * nullptr if no separate base nsLineLayout is needed. */ nsLineLayout(nsPresContext* aPresContext, nsFloatManager* aFloatManager, - const nsHTMLReflowState* aOuterReflowState, + const ReflowInput* aOuterReflowState, const nsLineList::iterator* aLine, nsLineLayout* aBaseLineLayout); ~nsLineLayout(); void Init(nsBlockReflowState* aState, nscoord aMinLineBSize, int32_t aLineNumber) { mBlockRS = aState; mMinLineBSize = aMinLineBSize; @@ -69,17 +69,17 @@ public: * @param aX/aY/aWidth/aHeight are the new available * space rectangle, relative to the containing block. * @param aFloatFrame the float frame that was placed. */ void UpdateBand(mozilla::WritingMode aWM, const mozilla::LogicalRect& aNewAvailableSpace, nsIFrame* aFloatFrame); - void BeginSpan(nsIFrame* aFrame, const nsHTMLReflowState* aSpanReflowState, + void BeginSpan(nsIFrame* aFrame, const ReflowInput* aSpanReflowState, nscoord aLeftEdge, nscoord aRightEdge, nscoord* aBaseline); // Returns the width of the span nscoord EndSpan(nsIFrame* aFrame); // This method attaches the last frame reflowed in this line layout // to that in the base line layout. void AttachLastFrameToBaseLineLayout() @@ -336,17 +336,17 @@ public: } /** * This can't be null. It usually returns a block frame but may return * some other kind of frame when inline frames are reflowed in a non-block * context (e.g. MathML or floating first-letter). */ nsIFrame* LineContainerFrame() const { return mBlockReflowState->frame; } - const nsHTMLReflowState* LineContainerRS() const { return mBlockReflowState; } + const ReflowInput* LineContainerRS() const { return mBlockReflowState; } const nsLineList::iterator* GetLine() const { return mGotLineBox ? &mLineBox : nullptr; } nsLineList::iterator* GetLine() { return mGotLineBox ? &mLineBox : nullptr; } /** @@ -376,17 +376,17 @@ public: nscoord GetCurrentICoord() { return mCurrentSpan->mICoord; } void SetSuppressLineWrap(bool aEnabled) { mSuppressLineWrap = aEnabled; } protected: // This state is constant for a given block frame doing line layout nsFloatManager* mFloatManager; const nsStyleText* mStyleText; // for the block - const nsHTMLReflowState* mBlockReflowState; + const ReflowInput* mBlockReflowState; // The line layout for the base text. It is usually nullptr. // It becomes not null when the current line layout is for ruby // annotations. When there is nested ruby inside annotation, it // forms a linked list from the inner annotation to the outermost // line layout. The outermost line layout, which has this member // being nullptr, is responsible for managing the life cycle of // per-frame data and per-span data, and handling floats. @@ -527,17 +527,17 @@ protected: PerFrameData* mFirstFrame; // The last PerFrameData structure in the span. PerFrameData structures are // added to the span as they are reflowed. mLastFrame may also be directly // manipulated if a line is split, or if frames are pushed from one line to // the next. PerFrameData* mLastFrame; - const nsHTMLReflowState* mReflowState; + const ReflowInput* mReflowState; bool mNoWrap; mozilla::WritingMode mWritingMode; bool mContainsFloat; bool mHasNonemptyContent; nscoord mIStart; nscoord mICoord; nscoord mIEnd; @@ -660,17 +660,17 @@ protected: bool InBlockContext() const { return mSpanDepth == 0; } void PushFrame(nsIFrame* aFrame); void AllowForStartMargin(PerFrameData* pfd, - nsHTMLReflowState& aReflowState); + ReflowInput& aReflowState); void SyncAnnotationBounds(PerFrameData* aRubyFrame); bool CanPlaceFrame(PerFrameData* pfd, bool aNotSafeToBreak, bool aFrameCanContinueTextRun, bool aCanRollBackBeforeFrame, nsHTMLReflowMetrics& aMetrics,
--- a/layout/generic/nsPageContentFrame.cpp +++ b/layout/generic/nsPageContentFrame.cpp @@ -18,17 +18,17 @@ NS_NewPageContentFrame(nsIPresShell* aPr return new (aPresShell) nsPageContentFrame(aContext); } NS_IMPL_FRAMEARENA_HELPERS(nsPageContentFrame) void nsPageContentFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsPageContentFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); aStatus = NS_FRAME_COMPLETE; // initialize out parameter if (GetPrevInFlow() && (GetStateBits() & NS_FRAME_FIRST_REFLOW)) { @@ -48,17 +48,17 @@ nsPageContentFrame::Reflow(nsPresContext // A PageContentFrame must always have one child: the canvas frame. // 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()) { nsIFrame* frame = mFrames.FirstChild(); WritingMode wm = frame->GetWritingMode(); LogicalSize logicalSize(wm, maxSize); - nsHTMLReflowState kidReflowState(aPresContext, aReflowState, + ReflowInput kidReflowState(aPresContext, aReflowState, frame, logicalSize); kidReflowState.SetComputedBSize(logicalSize.BSize(wm)); // Reflow the page content area ReflowChild(frame, aPresContext, aDesiredSize, kidReflowState, 0, 0, 0, aStatus); // The document element's background should cover the entire canvas, so // take into account the combined area and any space taken up by
--- a/layout/generic/nsPageContentFrame.h +++ b/layout/generic/nsPageContentFrame.h @@ -18,17 +18,17 @@ public: friend nsPageContentFrame* NS_NewPageContentFrame(nsIPresShell* aPresShell, nsStyleContext* aContext); friend class nsPageFrame; // nsIFrame virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aMaxSize, + const ReflowInput& aMaxSize, nsReflowStatus& aStatus) override; virtual bool IsFrameOfType(uint32_t aFlags) const override { return ViewportFrame::IsFrameOfType(aFlags & ~(nsIFrame::eCanContainOverflowContainers)); }
--- a/layout/generic/nsPageFrame.cpp +++ b/layout/generic/nsPageFrame.cpp @@ -47,17 +47,17 @@ nsPageFrame::nsPageFrame(nsStyleContext* nsPageFrame::~nsPageFrame() { } void nsPageFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsPageFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); aStatus = NS_FRAME_COMPLETE; // initialize out parameter NS_ASSERTION(mFrames.FirstChild() && @@ -89,17 +89,17 @@ nsPageFrame::Reflow(nsPresContext* // XXX Shouldn't we do something more friendly when invalid margins // are set? if (maxSize.width < onePixelInTwips || maxSize.height < onePixelInTwips) { aDesiredSize.ClearSize(); NS_WARNING("Reflow aborted; no space for content"); return; } - nsHTMLReflowState kidReflowState(aPresContext, aReflowState, frame, + ReflowInput kidReflowState(aPresContext, aReflowState, frame, LogicalSize(frame->GetWritingMode(), maxSize)); kidReflowState.mFlags.mIsTopOfPage = true; kidReflowState.mFlags.mTableIsSplittable = true; // Use the margins given in the @page rule. // If a margin is 'auto', use the margin from the print settings for that side. const nsStyleSides& marginStyle = kidReflowState.mStyleMargin->mMargin; @@ -704,17 +704,17 @@ nscoord nsPageBreakFrame::GetIntrinsicBSize() { return 0; } void nsPageBreakFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { DO_GLOBAL_REFLOW_COUNT("nsPageBreakFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); // Override reflow, since we don't want to deal with what our // computed values are. WritingMode wm = aReflowState.GetWritingMode();
--- a/layout/generic/nsPageFrame.h +++ b/layout/generic/nsPageFrame.h @@ -20,17 +20,17 @@ public: NS_DECL_QUERYFRAME NS_DECL_FRAMEARENA_HELPERS friend nsPageFrame* NS_NewPageFrame(nsIPresShell* aPresShell, nsStyleContext* aContext); virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aMaxSize, + const ReflowInput& aMaxSize, nsReflowStatus& aStatus) override; virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; /** * Get the "type" of the frame @@ -108,17 +108,17 @@ class nsPageBreakFrame : public nsLeafFr { NS_DECL_FRAMEARENA_HELPERS explicit nsPageBreakFrame(nsStyleContext* aContext); ~nsPageBreakFrame(); virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsIAtom* GetType() const override; #ifdef DEBUG_FRAME_DUMP virtual nsresult GetFrameName(nsAString& aResult) const override; #endif
--- a/layout/generic/nsPlaceholderFrame.cpp +++ b/layout/generic/nsPlaceholderFrame.cpp @@ -101,17 +101,17 @@ nsPlaceholderFrame::AddInlinePrefISize(n aData->mFloats.AppendElement( InlineIntrinsicISizeData::FloatInfo(mOutOfFlowFrame, floatWidth)); } } void nsPlaceholderFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { #ifdef DEBUG // We should be getting reflowed before our out-of-flow. // If this is our first reflow, and our out-of-flow has already received its // first reflow (before us), complain. // XXXdholbert This "look for a previous continuation or IB-split sibling" // code could use nsLayoutUtils::GetPrevContinuationOrIBSplitSibling(), if
--- a/layout/generic/nsPlaceholderFrame.h +++ b/layout/generic/nsPlaceholderFrame.h @@ -95,17 +95,17 @@ public: virtual void AddInlinePrefISize(nsRenderingContext* aRenderingContext, InlinePrefISizeData* aData) override; virtual nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) override; virtual nsSize GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) override; virtual nsSize GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual void DestroyFrom(nsIFrame* aDestructRoot) override; #if defined(DEBUG) || (defined(MOZ_REFLOW_PERF_DSP) && defined(MOZ_REFLOW_PERF)) virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override;
--- a/layout/generic/nsPluginFrame.cpp +++ b/layout/generic/nsPluginFrame.cpp @@ -420,17 +420,17 @@ nsPluginFrame::GetWidgetConfiguration(ns configuration->mVisible = mWidget->IsVisible(); } #endif // defined(XP_WIN) || defined(MOZ_WIDGET_GTK) } void nsPluginFrame::GetDesiredSize(nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsHTMLReflowMetrics& aMetrics) { // By default, we have no area aMetrics.ClearSize(); if (IsHidden(false)) { return; } @@ -486,17 +486,17 @@ nsPluginFrame::GetDesiredSize(nsPresCont // paint borders, though! At that point, we will need to adjust the desired // size either here or in Reflow.... Further, we will need to fix Paint() to // call the superclass in all cases. } void nsPluginFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aMetrics, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsPluginFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus); // Get our desired size GetDesiredSize(aPresContext, aReflowState, aMetrics); @@ -817,17 +817,17 @@ nsPluginFrame::GetWindowOriginInPixels(b pt += nsIntPoint(lpt.x, lpt.y); } return pt; } void nsPluginFrame::DidReflow(nsPresContext* aPresContext, - const nsHTMLReflowState* aReflowState, + const ReflowInput* aReflowState, nsDidReflowStatus aStatus) { // Do this check before calling the superclass, as that clears // NS_FRAME_FIRST_REFLOW if (aStatus == nsDidReflowStatus::FINISHED && (GetStateBits() & NS_FRAME_FIRST_REFLOW)) { nsCOMPtr<nsIObjectLoadingContent> objContent(do_QueryInterface(mContent)); NS_ASSERTION(objContent, "Why not an object loading content?");
--- a/layout/generic/nsPluginFrame.h +++ b/layout/generic/nsPluginFrame.h @@ -69,20 +69,20 @@ public: virtual void Init(nsIContent* aContent, nsContainerFrame* aParent, nsIFrame* aPrevInFlow) override; virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override; virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual void DidReflow(nsPresContext* aPresContext, - const nsHTMLReflowState* aReflowState, + const ReflowInput* aReflowState, nsDidReflowStatus aStatus) override; virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; virtual nsresult HandleEvent(nsPresContext* aPresContext, mozilla::WidgetGUIEvent* aEvent, nsEventStatus* aEventStatus) override; @@ -228,17 +228,17 @@ public: protected: explicit nsPluginFrame(nsStyleContext* aContext); virtual ~nsPluginFrame(); // NOTE: This frame class does not inherit from |nsLeafFrame|, so // this is not a virtual method implementation. void GetDesiredSize(nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsHTMLReflowMetrics& aDesiredSize); bool IsFocusable(int32_t *aTabIndex = nullptr, bool aWithMouse = false) override; // check attributes and optionally CSS to see if we should display anything bool IsHidden(bool aCheckVisibilityStyle = true) const;
--- a/layout/generic/nsRubyBaseContainerFrame.cpp +++ b/layout/generic/nsRubyBaseContainerFrame.cpp @@ -288,24 +288,24 @@ nsRubyBaseContainerFrame::GetLogicalBase return mBaseline; } struct nsRubyBaseContainerFrame::ReflowState { bool mAllowInitialLineBreak; bool mAllowLineBreak; const AutoRubyTextContainerArray& mTextContainers; - const nsHTMLReflowState& mBaseReflowState; - const nsTArray<UniquePtr<nsHTMLReflowState>>& mTextReflowStates; + const ReflowInput& mBaseReflowState; + const nsTArray<UniquePtr<ReflowInput>>& mTextReflowStates; }; /* virtual */ void nsRubyBaseContainerFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsRubyBaseContainerFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); aStatus = NS_FRAME_COMPLETE; if (!aReflowState.mLineLayout) { @@ -329,30 +329,30 @@ nsRubyBaseContainerFrame::Reflow(nsPresC // We have a reflow state and a line layout for each RTC. // They are conceptually the state of the RTCs, but we don't actually // reflow those RTCs in this code. These two arrays are holders of // the reflow states and line layouts. // Since there are pointers refer to reflow states and line layouts, // it is necessary to guarantee that they won't be moved. For this // reason, they are wrapped in UniquePtr here. - AutoTArray<UniquePtr<nsHTMLReflowState>, RTC_ARRAY_SIZE> reflowStates; + AutoTArray<UniquePtr<ReflowInput>, RTC_ARRAY_SIZE> reflowStates; AutoTArray<UniquePtr<nsLineLayout>, RTC_ARRAY_SIZE> lineLayouts; reflowStates.SetCapacity(rtcCount); lineLayouts.SetCapacity(rtcCount); // Begin the line layout for each ruby text container in advance. bool hasSpan = false; for (uint32_t i = 0; i < rtcCount; i++) { nsRubyTextContainerFrame* textContainer = textContainers[i]; if (textContainer->IsSpanContainer()) { hasSpan = true; } - nsHTMLReflowState* reflowState = new nsHTMLReflowState( + ReflowInput* reflowState = new ReflowInput( aPresContext, *aReflowState.mParentReflowState, textContainer, availSize.ConvertTo(textContainer->GetWritingMode(), lineWM)); reflowStates.AppendElement(reflowState); nsLineLayout* lineLayout = new nsLineLayout(aPresContext, reflowState->mFloatManager, reflowState, nullptr, aReflowState.mLineLayout); lineLayout->SetSuppressLineWrap(true); @@ -568,17 +568,17 @@ nsRubyBaseContainerFrame::ReflowColumns( } nscoord nsRubyBaseContainerFrame::ReflowOneColumn(const ReflowState& aReflowState, uint32_t aColumnIndex, const RubyColumn& aColumn, nsReflowStatus& aStatus) { - const nsHTMLReflowState& baseReflowState = aReflowState.mBaseReflowState; + const ReflowInput& baseReflowState = aReflowState.mBaseReflowState; const auto& textReflowStates = aReflowState.mTextReflowStates; nscoord istart = baseReflowState.mLineLayout->GetCurrentICoord(); if (aColumn.mBaseFrame) { bool allowBreakBefore = aColumnIndex ? aReflowState.mAllowLineBreak : aReflowState.mAllowInitialLineBreak; if (allowBreakBefore) { gfxBreakPriority breakPriority = LineBreakBefore(
--- a/layout/generic/nsRubyBaseContainerFrame.h +++ b/layout/generic/nsRubyBaseContainerFrame.h @@ -43,17 +43,17 @@ public: const mozilla::LogicalSize& aCBSize, nscoord aAvailableISize, const mozilla::LogicalSize& aMargin, const mozilla::LogicalSize& aBorder, const mozilla::LogicalSize& aPadding, ComputeSizeFlags aFlags) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nscoord GetLogicalBaseline(mozilla::WritingMode aWritingMode) const override; #ifdef DEBUG_FRAME_DUMP virtual nsresult GetFrameName(nsAString& aResult) const override; #endif
--- a/layout/generic/nsRubyFrame.cpp +++ b/layout/generic/nsRubyFrame.cpp @@ -87,17 +87,17 @@ nsRubyFrame::AddInlinePrefISize(nsRender e.GetBaseContainer()->AddInlinePrefISize(aRenderingContext, aData); } } } /* virtual */ void nsRubyFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsRubyFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); if (!aReflowState.mLineLayout) { NS_ASSERTION(aReflowState.mLineLayout, @@ -162,17 +162,17 @@ nsRubyFrame::Reflow(nsPresContext* aPres } nsLayoutUtils::SetBSizeFromFontMetrics(this, aDesiredSize, borderPadding, lineWM, frameWM); } void nsRubyFrame::ReflowSegment(nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsRubyBaseContainerFrame* aBaseContainer, nsReflowStatus& aStatus) { WritingMode lineWM = aReflowState.mLineLayout->GetWritingMode(); LogicalSize availSize(lineWM, aReflowState.AvailableISize(), aReflowState.AvailableBSize()); WritingMode rubyWM = GetWritingMode(); NS_ASSERTION(!rubyWM.IsOrthogonalTo(lineWM), @@ -267,17 +267,17 @@ nsRubyFrame::ReflowSegment(nsPresContext baseRect.BStart(lineWM) = 0; // The rect for offsets of text containers. LogicalRect offsetRect = baseRect; for (uint32_t i = 0; i < rtcCount; i++) { nsRubyTextContainerFrame* textContainer = textContainers[i]; WritingMode rtcWM = textContainer->GetWritingMode(); nsReflowStatus textReflowStatus; nsHTMLReflowMetrics textMetrics(aReflowState); - nsHTMLReflowState textReflowState(aPresContext, aReflowState, textContainer, + ReflowInput textReflowState(aPresContext, aReflowState, textContainer, 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. textReflowState.mLineLayout = aReflowState.mLineLayout; textContainer->Reflow(aPresContext, textMetrics, textReflowState, textReflowStatus);
--- a/layout/generic/nsRubyFrame.h +++ b/layout/generic/nsRubyFrame.h @@ -31,17 +31,17 @@ public: virtual nsIAtom* GetType() const override; virtual bool IsFrameOfType(uint32_t aFlags) const override; virtual void AddInlineMinISize(nsRenderingContext *aRenderingContext, InlineMinISizeData *aData) override; virtual void AddInlinePrefISize(nsRenderingContext *aRenderingContext, InlinePrefISizeData *aData) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; #ifdef DEBUG_FRAME_DUMP virtual nsresult GetFrameName(nsAString& aResult) const override; #endif void GetBlockLeadings(nscoord& aStartLeading, nscoord& aEndLeading) { @@ -51,17 +51,17 @@ public: protected: friend nsContainerFrame* NS_NewRubyFrame(nsIPresShell* aPresShell, nsStyleContext* aContext); explicit nsRubyFrame(nsStyleContext* aContext) : nsInlineFrame(aContext) {} void ReflowSegment(nsPresContext* aPresContext, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsRubyBaseContainerFrame* aBaseContainer, nsReflowStatus& aStatus); nsRubyBaseContainerFrame* PullOneSegment(const nsLineLayout* aLineLayout, ContinuationTraversingState& aState); // The leading required to put the annotations. // They are not initialized until the first reflow.
--- a/layout/generic/nsRubyTextContainerFrame.cpp +++ b/layout/generic/nsRubyTextContainerFrame.cpp @@ -117,17 +117,17 @@ nsRubyTextContainerFrame::UpdateSpanFlag } else { RemoveStateBits(NS_RUBY_TEXT_CONTAINER_IS_SPAN); } } /* virtual */ void nsRubyTextContainerFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsRubyTextContainerFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); // Although a ruby text container may have continuations, returning // NS_FRAME_COMPLETE here is still safe, since its parent, ruby frame,
--- a/layout/generic/nsRubyTextContainerFrame.h +++ b/layout/generic/nsRubyTextContainerFrame.h @@ -25,17 +25,17 @@ public: NS_DECL_QUERYFRAME_TARGET(nsRubyTextContainerFrame) NS_DECL_QUERYFRAME // nsIFrame overrides virtual nsIAtom* GetType() const override; virtual bool IsFrameOfType(uint32_t aFlags) const override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; #ifdef DEBUG_FRAME_DUMP virtual nsresult GetFrameName(nsAString& aResult) const override; #endif // nsContainerFrame overrides virtual void SetInitialChildList(ChildListID aListID,
--- a/layout/generic/nsRubyTextFrame.cpp +++ b/layout/generic/nsRubyTextFrame.cpp @@ -71,17 +71,17 @@ nsRubyTextFrame::BuildDisplayList(nsDisp } nsRubyContentFrame::BuildDisplayList(aBuilder, aDirtyRect, aLists); } /* virtual */ void nsRubyTextFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { // Even if we want to hide this frame, we have to reflow it first. // If we leave it dirty, changes to its content will never be // propagated to the ancestors, then it won't be displayed even if // the content is no longer the same, until next reflow triggered by // some other change. In general, we always reflow all the frames we // created. There might be other problems if we don't do that.
--- a/layout/generic/nsRubyTextFrame.h +++ b/layout/generic/nsRubyTextFrame.h @@ -34,17 +34,17 @@ public: #endif virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; bool IsAutoHidden() const { return GetStateBits() & NS_RUBY_TEXT_FRAME_AUTOHIDE; } protected:
--- a/layout/generic/nsSimplePageSequenceFrame.cpp +++ b/layout/generic/nsSimplePageSequenceFrame.cpp @@ -86,17 +86,17 @@ nsSimplePageSequenceFrame::~nsSimplePage NS_QUERYFRAME_HEAD(nsSimplePageSequenceFrame) NS_QUERYFRAME_ENTRY(nsIPageSequenceFrame) NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame) //---------------------------------------------------------------------- void nsSimplePageSequenceFrame::SetDesiredSize(nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nscoord aWidth, nscoord aHeight) { // Aim to fill the whole size of the document, not only so we // can act as a background in print preview but also handle overflow // in child page frames correctly. // Use availableWidth so we don't cause a needless horizontal scrollbar. aDesiredSize.Width() = std::max(aReflowState.AvailableWidth(), @@ -140,17 +140,17 @@ nsSimplePageSequenceFrame::ComputeCenter // that it'll produce the correct scaled-up amount when we render (because // rendering will scale it back up): return NSToCoordRound(scaledExtraSpace * 0.5 / ppScale); } void nsSimplePageSequenceFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); NS_PRECONDITION(aPresContext->IsRootPaginatedDocument(), "A Page Sequence is only for real pages"); DO_GLOBAL_REFLOW_COUNT("nsSimplePageSequenceFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); NS_FRAME_TRACE_REFLOW_IN("nsSimplePageSequenceFrame::Reflow"); @@ -245,17 +245,17 @@ nsSimplePageSequenceFrame::Reflow(nsPres nsHTMLReflowMetrics kidSize(aReflowState); for (nsFrameList::Enumerator e(mFrames); !e.AtEnd(); e.Next()) { nsIFrame* kidFrame = e.get(); // Set the shared data into the page frame before reflow nsPageFrame * pf = static_cast<nsPageFrame*>(kidFrame); pf->SetSharedPageData(mPageData); // Reflow the page - nsHTMLReflowState kidReflowState(aPresContext, aReflowState, kidFrame, + ReflowInput kidReflowState(aPresContext, aReflowState, kidFrame, LogicalSize(kidFrame->GetWritingMode(), pageSize)); nsReflowStatus status; kidReflowState.SetComputedWidth(kidReflowState.AvailableWidth()); //kidReflowState.SetComputedHeight(kidReflowState.AvailableHeight()); PR_PL(("AV W: %d H: %d\n", kidReflowState.AvailableWidth(), kidReflowState.AvailableHeight()));
--- a/layout/generic/nsSimplePageSequenceFrame.h +++ b/layout/generic/nsSimplePageSequenceFrame.h @@ -62,17 +62,17 @@ public: nsStyleContext* aContext); NS_DECL_QUERYFRAME NS_DECL_FRAMEARENA_HELPERS // nsIFrame virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aMaxSize, + const ReflowInput& aMaxSize, nsReflowStatus& aStatus) override; virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; // nsIPageSequenceFrame NS_IMETHOD SetPageNo(int32_t aPageNo) { return NS_OK;} @@ -121,17 +121,17 @@ protected: // SharedPageData Helper methods void SetDateTimeStr(const nsAString& aDateTimeStr); void SetPageNumberFormat(const nsAString& aFormatStr, bool aForPageNumOnly); // Sets the frame desired size to the size of the viewport, or the given // nscoords, whichever is larger. Print scaling is applied in this function. void SetDesiredSize(nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nscoord aWidth, nscoord aHeight); // Helper function to compute the offset needed to center a child // page-frame's margin-box inside our content-box. nscoord ComputeCenteringMargin(nscoord aContainerContentBoxWidth, nscoord aChildPaddingBoxWidth, const nsMargin& aChildPhysicalMargin);
--- a/layout/generic/nsSplittableFrame.cpp +++ b/layout/generic/nsSplittableFrame.cpp @@ -212,17 +212,17 @@ nsSplittableFrame::GetConsumedBSize() co nscoord height = 0; for (nsIFrame* prev = GetPrevInFlow(); prev; prev = prev->GetPrevInFlow()) { height += prev->GetContentRectRelativeToSelf().height; } return height; } nscoord -nsSplittableFrame::GetEffectiveComputedBSize(const nsHTMLReflowState& aReflowState, +nsSplittableFrame::GetEffectiveComputedBSize(const ReflowInput& aReflowState, nscoord aConsumedBSize) const { nscoord bSize = aReflowState.ComputedBSize(); if (bSize == NS_INTRINSICSIZE) { return NS_INTRINSICSIZE; } if (aConsumedBSize == NS_INTRINSICSIZE) { @@ -231,17 +231,17 @@ nsSplittableFrame::GetEffectiveComputedB bSize -= aConsumedBSize; // We may have stretched the frame beyond its computed height. Oh well. return std::max(0, bSize); } nsIFrame::LogicalSides -nsSplittableFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const +nsSplittableFrame::GetLogicalSkipSides(const ReflowInput* aReflowState) const { if (IS_TRUE_OVERFLOW_CONTAINER(this)) { return LogicalSides(eLogicalSideBitsBBoth); } if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak == NS_STYLE_BOX_DECORATION_BREAK_CLONE)) { return LogicalSides();
--- a/layout/generic/nsSplittableFrame.h +++ b/layout/generic/nsSplittableFrame.h @@ -84,23 +84,23 @@ protected: * of calls to this method. */ nscoord GetConsumedBSize() const; /** * Retrieve the effective computed block size of this frame, which is the * computed block size, minus the block size consumed by any previous in-flows. */ - nscoord GetEffectiveComputedBSize(const nsHTMLReflowState& aReflowState, + nscoord GetEffectiveComputedBSize(const ReflowInput& aReflowState, nscoord aConsumed = NS_INTRINSICSIZE) const; /** * @see nsIFrame::GetLogicalSkipSides() */ - virtual LogicalSides GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const override; + virtual LogicalSides GetLogicalSkipSides(const ReflowInput* aReflowState = nullptr) const override; /** * A faster version of GetLogicalSkipSides() that is intended to be used * inside Reflow before it's known if |this| frame will be COMPLETE or not. * It returns a result that assumes this fragment is the last and thus * should apply the block-end border/padding etc (except for "true" overflow * containers which always skip block sides). You're then expected to * recalculate the block-end side (as needed) when you know |this| frame's
--- a/layout/generic/nsSubDocumentFrame.cpp +++ b/layout/generic/nsSubDocumentFrame.cpp @@ -755,17 +755,17 @@ nsSubDocumentFrame::ComputeSize(nsRender aCBSize, aAvailableISize, aMargin, aBorder, aPadding, aFlags); } void nsSubDocumentFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsSubDocumentFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS, ("enter nsSubDocumentFrame::Reflow: maxSize=%d,%d", aReflowState.AvailableWidth(), aReflowState.AvailableHeight()));
--- a/layout/generic/nsSubDocumentFrame.h +++ b/layout/generic/nsSubDocumentFrame.h @@ -70,17 +70,17 @@ public: nscoord aAvailableISize, const mozilla::LogicalSize& aMargin, const mozilla::LogicalSize& aBorder, const mozilla::LogicalSize& aPadding, ComputeSizeFlags aFlags) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; virtual nsresult AttributeChanged(int32_t aNameSpaceID, nsIAtom* aAttribute,
--- a/layout/generic/nsTextFrame.cpp +++ b/layout/generic/nsTextFrame.cpp @@ -5420,17 +5420,17 @@ nsTextFrame::UnionAdditionalOverflow(nsP gfxFloat nsTextFrame::ComputeDescentLimitForSelectionUnderline( nsPresContext* aPresContext, const gfxFont::Metrics& aFontMetrics) { gfxFloat app = aPresContext->AppUnitsPerDevPixel(); nscoord lineHeightApp = - nsHTMLReflowState::CalcLineHeight(GetContent(), + ReflowInput::CalcLineHeight(GetContent(), StyleContext(), NS_AUTOHEIGHT, GetFontSizeInflation()); gfxFloat lineHeight = gfxFloat(lineHeightApp) / app; if (lineHeight <= aFontMetrics.maxHeight) { return aFontMetrics.maxDescent; } return aFontMetrics.maxDescent + (lineHeight - aFontMetrics.maxHeight) / 2; } @@ -8645,17 +8645,17 @@ struct NewlineProperty { int32_t mStartOffset; // The offset of the first \n after mStartOffset, or -1 if there is none int32_t mNewlineOffset; }; void nsTextFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aMetrics, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsTextFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, 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
--- a/layout/generic/nsTextFrame.h +++ b/layout/generic/nsTextFrame.h @@ -243,17 +243,17 @@ public: const mozilla::LogicalSize& aPadding, ComputeSizeFlags aFlags) override; virtual nsRect ComputeTightBounds(DrawTarget* aDrawTarget) const override; virtual nsresult GetPrefWidthTightBounds(nsRenderingContext* aContext, nscoord* aX, nscoord* aXMost) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aMetrics, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual bool CanContinueTextRun() const override; // Method that is called for a text frame that is logically // adjacent to the end of the line (i.e. followed only by empty text frames, // placeholders or inlines containing such). struct TrimOutput { // true if we trimmed some space or changed metrics in some other way. // In this case, we should call RecomputeOverflow on this frame.
--- a/layout/generic/nsVideoFrame.cpp +++ b/layout/generic/nsVideoFrame.cpp @@ -278,17 +278,17 @@ public: return NS_OK; } nsCOMPtr<nsIContent> mContent; }; void nsVideoFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aMetrics, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsVideoFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus); NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS, ("enter nsVideoFrame::Reflow: availSize=%d,%d", aReflowState.AvailableWidth(), aReflowState.AvailableHeight())); @@ -312,17 +312,17 @@ nsVideoFrame::Reflow(nsPresContext* if (child->GetContent() == mPosterImage) { // Reflow the poster frame. nsImageFrame* imageFrame = static_cast<nsImageFrame*>(child); nsHTMLReflowMetrics kidDesiredSize(aReflowState); WritingMode wm = imageFrame->GetWritingMode(); LogicalSize availableSize = aReflowState.AvailableSize(wm); LogicalSize cbSize = aMetrics.Size(aMetrics.GetWritingMode()). ConvertTo(wm, aMetrics.GetWritingMode()); - nsHTMLReflowState kidReflowState(aPresContext, + ReflowInput kidReflowState(aPresContext, aReflowState, imageFrame, availableSize, &cbSize); nsRect posterRenderRect; if (ShouldDisplayPoster()) { posterRenderRect = @@ -353,17 +353,17 @@ nsVideoFrame::Reflow(nsPresContext* } } else if (child->GetContent() == mCaptionDiv) { // Reflow to caption div nsHTMLReflowMetrics kidDesiredSize(aReflowState); WritingMode wm = child->GetWritingMode(); LogicalSize availableSize = aReflowState.AvailableSize(wm); LogicalSize cbSize = aMetrics.Size(aMetrics.GetWritingMode()). ConvertTo(wm, aMetrics.GetWritingMode()); - nsHTMLReflowState kidReflowState(aPresContext, + ReflowInput kidReflowState(aPresContext, aReflowState, child, availableSize, &cbSize); nsSize size(aReflowState.ComputedWidth(), aReflowState.ComputedHeight()); size.width -= kidReflowState.ComputedPhysicalBorderPadding().LeftRight(); size.height -= kidReflowState.ComputedPhysicalBorderPadding().TopBottom();
--- a/layout/generic/nsVideoFrame.h +++ b/layout/generic/nsVideoFrame.h @@ -70,17 +70,17 @@ public: ComputeSizeFlags aFlags) override; virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override; virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override; virtual void DestroyFrom(nsIFrame* aDestructRoot) override; virtual bool IsLeaf() const override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; #ifdef ACCESSIBILITY virtual mozilla::a11y::AccType AccessibleType() override; #endif virtual nsIAtom* GetType() const override;
--- a/layout/generic/nsViewportFrame.cpp +++ b/layout/generic/nsViewportFrame.cpp @@ -218,17 +218,17 @@ ViewportFrame::GetPrefISize(nsRenderingC result = 0; else result = mFrames.FirstChild()->GetPrefISize(aRenderingContext); return result; } nsPoint -ViewportFrame::AdjustReflowStateForScrollbars(nsHTMLReflowState* aReflowState) const +ViewportFrame::AdjustReflowStateForScrollbars(ReflowInput* aReflowState) const { // Get our prinicpal child frame and see if we're scrollable nsIFrame* kidFrame = mFrames.FirstChild(); nsIScrollableFrame* scrollingFrame = do_QueryFrame(kidFrame); if (scrollingFrame) { WritingMode wm = aReflowState->GetWritingMode(); LogicalMargin scrollbars(wm, scrollingFrame->GetActualScrollbarSizes()); @@ -238,17 +238,17 @@ ViewportFrame::AdjustReflowStateForScrol aReflowState->SetComputedBSizeWithoutResettingResizeFlags( aReflowState->ComputedBSize() - scrollbars.BStartEnd(wm)); return nsPoint(scrollbars.Left(wm), scrollbars.Top(wm)); } return nsPoint(0, 0); } nsRect -ViewportFrame::AdjustReflowStateAsContainingBlock(nsHTMLReflowState* aReflowState) const +ViewportFrame::AdjustReflowStateAsContainingBlock(ReflowInput* aReflowState) const { #ifdef DEBUG nsPoint offset = #endif AdjustReflowStateForScrollbars(aReflowState); NS_ASSERTION(GetAbsoluteContainingBlock()->GetChildList().IsEmpty() || (offset.x == 0 && offset.y == 0), @@ -264,17 +264,17 @@ ViewportFrame::AdjustReflowStateAsContai } return rect; } void ViewportFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("ViewportFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); NS_FRAME_TRACE_REFLOW_IN("ViewportFrame::Reflow"); // Initialize OUT parameters @@ -301,17 +301,17 @@ ViewportFrame::Reflow(nsPresContext* if (aReflowState.ShouldReflowAllKids() || aReflowState.IsBResize() || NS_SUBTREE_DIRTY(mFrames.FirstChild())) { // Reflow our one-and-only principal child frame nsIFrame* kidFrame = mFrames.FirstChild(); nsHTMLReflowMetrics kidDesiredSize(aReflowState); WritingMode wm = kidFrame->GetWritingMode(); LogicalSize availableSpace = aReflowState.AvailableSize(wm); - nsHTMLReflowState kidReflowState(aPresContext, aReflowState, + ReflowInput kidReflowState(aPresContext, aReflowState, kidFrame, availableSpace); // Reflow the frame kidReflowState.SetComputedBSize(aReflowState.ComputedBSize()); ReflowChild(kidFrame, aPresContext, kidDesiredSize, kidReflowState, 0, 0, 0, aStatus); kidBSize = kidDesiredSize.BSize(wm); @@ -332,17 +332,17 @@ ViewportFrame::Reflow(nsPresContext* ? aReflowState.ComputedBSize() : kidBSize); aDesiredSize.SetSize(wm, maxSize); aDesiredSize.SetOverflowAreasToDesiredBounds(); if (HasAbsolutelyPositionedChildren()) { // Make a copy of the reflow state and change the computed width and height // to reflect the available space for the fixed items - nsHTMLReflowState reflowState(aReflowState); + ReflowInput reflowState(aReflowState); if (reflowState.AvailableBSize() == NS_UNCONSTRAINEDSIZE) { // We have an intrinsic-height document with abs-pos/fixed-pos children. // Set the available height and mComputedHeight to our chosen height. reflowState.AvailableBSize() = maxSize.BSize(wm); // Not having border/padding simplifies things NS_ASSERTION(reflowState.ComputedPhysicalBorderPadding() == nsMargin(0,0,0,0), "Viewports can't have border/padding");
--- a/layout/generic/nsViewportFrame.h +++ b/layout/generic/nsViewportFrame.h @@ -61,17 +61,17 @@ public: void BuildDisplayListForTopLayer(nsDisplayListBuilder* aBuilder, nsDisplayList* aList); virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override; virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; /** * Get the "type" of the frame * * @see nsGkAtoms::viewportFrame */ virtual nsIAtom* GetType() const override; @@ -79,30 +79,30 @@ public: virtual bool ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas) override; /** * Adjust aReflowState to account for scrollbars and pres shell * GetScrollPositionClampingScrollPortSizeSet and * GetContentDocumentFixedPositionMargins adjustments. * @return the rect to use as containing block rect */ - nsRect AdjustReflowStateAsContainingBlock(nsHTMLReflowState* aReflowState) const; + nsRect AdjustReflowStateAsContainingBlock(ReflowInput* aReflowState) const; #ifdef DEBUG_FRAME_DUMP virtual nsresult GetFrameName(nsAString& aResult) const override; #endif private: virtual mozilla::layout::FrameChildListID GetAbsoluteListID() const override { return kFixedList; } protected: /** * Calculate how much room is available for fixed frames. That means * determining if the viewport is scrollable and whether the vertical and/or * horizontal scrollbars are visible. Adjust the computed width/height and * available width for aReflowState accordingly. * @return the current scroll position, or 0,0 if not scrollable */ - nsPoint AdjustReflowStateForScrollbars(nsHTMLReflowState* aReflowState) const; + nsPoint AdjustReflowStateForScrollbars(ReflowInput* aReflowState) const; }; #endif // nsViewportFrame_h___
--- a/layout/mathml/nsMathMLContainerFrame.cpp +++ b/layout/mathml/nsMathMLContainerFrame.cpp @@ -815,17 +815,17 @@ nsMathMLContainerFrame::ComputeCustomOve aOverflowAreas.UnionAllWith(boundingBox); return nsContainerFrame::ComputeCustomOverflow(aOverflowAreas); } void nsMathMLContainerFrame::ReflowChild(nsIFrame* aChildFrame, nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { // Having foreign/hybrid children, e.g., from html markups, is not defined by // the MathML spec. But it can happen in practice, e.g., <html:img> allows us // to do some cool demos... or we may have a child that is an nsInlineFrame // from a generated content such as :before { content: open-quote } or // :after { content: close-quote }. Unfortunately, the other frames out-there // may expect their own invariants that are not met when we mix things. @@ -864,17 +864,17 @@ nsMathMLContainerFrame::ReflowChild(nsIF aDesiredSize.mBoundingMetrics.descent = r.YMost() - aDesiredSize.BlockStartAscent(); aDesiredSize.mBoundingMetrics.width = aDesiredSize.Width(); } } void nsMathMLContainerFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); mPresentationData.flags &= ~NS_MATHML_ERROR; aDesiredSize.Width() = aDesiredSize.Height() = 0; aDesiredSize.SetBlockStartAscent(0); aDesiredSize.mBoundingMetrics = nsBoundingMetrics(); @@ -885,17 +885,17 @@ nsMathMLContainerFrame::Reflow(nsPresCon nsReflowStatus childStatus; nsIFrame* childFrame = mFrames.FirstChild(); while (childFrame) { nsHTMLReflowMetrics childDesiredSize(aReflowState, // ??? aDesiredSize.mFlags); WritingMode wm = childFrame->GetWritingMode(); LogicalSize availSize = aReflowState.ComputedSize(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; - nsHTMLReflowState childReflowState(aPresContext, aReflowState, + ReflowInput childReflowState(aPresContext, aReflowState, childFrame, availSize); ReflowChild(childFrame, aPresContext, childDesiredSize, childReflowState, childStatus); //NS_ASSERTION(NS_FRAME_IS_COMPLETE(childStatus), "bad status"); SaveReflowAndBoundingMetricsFor(childFrame, childDesiredSize, childDesiredSize.mBoundingMetrics); childFrame = childFrame->GetNextSibling(); }
--- a/layout/mathml/nsMathMLContainerFrame.h +++ b/layout/mathml/nsMathMLContainerFrame.h @@ -108,21 +108,21 @@ public: */ virtual void GetIntrinsicISizeMetrics(nsRenderingContext* aRenderingContext, nsHTMLReflowMetrics& aDesiredSize); virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual void DidReflow(nsPresContext* aPresContext, - const nsHTMLReflowState* aReflowState, + const ReflowInput* aReflowState, nsDidReflowStatus aStatus) override { mPresentationData.flags &= ~NS_MATHML_STRETCH_DONE; return nsContainerFrame::DidReflow(aPresContext, aReflowState, aStatus); } virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, @@ -273,17 +273,17 @@ public: // helper method to reflow a child frame. We are inline frames, and we don't // know our positions until reflow is finished. That's why we ask the // base method not to worry about our position. void ReflowChild(nsIFrame* aKidFrame, nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus); protected: // helper to add the inter-spacing when <math> is the immediate parent. // Since we don't (yet) handle the root <math> element ourselves, we need to // take special care of the inter-frame spacing on elements for which <math> // is the direct xml parent. This function will be repeatedly called from // left to right on the childframes of <math>, and by so doing it will
--- a/layout/mathml/nsMathMLSelectedFrame.cpp +++ b/layout/mathml/nsMathMLSelectedFrame.cpp @@ -130,31 +130,31 @@ nsMathMLSelectedFrame::ComputeSize(nsRen } return LogicalSize(aWM); } // Only reflow the selected child ... void nsMathMLSelectedFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); mPresentationData.flags &= ~NS_MATHML_ERROR; aStatus = NS_FRAME_COMPLETE; aDesiredSize.ClearSize(); aDesiredSize.SetBlockStartAscent(0); mBoundingMetrics = nsBoundingMetrics(); nsIFrame* childFrame = GetSelectedFrame(); if (childFrame) { WritingMode wm = childFrame->GetWritingMode(); LogicalSize availSize = aReflowState.ComputedSize(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; - nsHTMLReflowState childReflowState(aPresContext, aReflowState, + ReflowInput childReflowState(aPresContext, aReflowState, childFrame, availSize); ReflowChild(childFrame, aPresContext, aDesiredSize, childReflowState, aStatus); SaveReflowAndBoundingMetricsFor(childFrame, aDesiredSize, aDesiredSize.mBoundingMetrics); mBoundingMetrics = aDesiredSize.mBoundingMetrics; } FinalizeReflow(aReflowState.rendContext->GetDrawTarget(), aDesiredSize);
--- a/layout/mathml/nsMathMLSelectedFrame.h +++ b/layout/mathml/nsMathMLSelectedFrame.h @@ -42,17 +42,17 @@ public: const mozilla::LogicalSize& aMargin, const mozilla::LogicalSize& aBorder, const mozilla::LogicalSize& aPadding, ComputeSizeFlags aFlags) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsQueryFrame::FrameIID GetFrameId() override = 0; protected: explicit nsMathMLSelectedFrame(nsStyleContext* aContext) : nsMathMLContainerFrame(aContext) {} virtual ~nsMathMLSelectedFrame();
--- a/layout/mathml/nsMathMLTokenFrame.cpp +++ b/layout/mathml/nsMathMLTokenFrame.cpp @@ -116,17 +116,17 @@ nsMathMLTokenFrame::InsertFrames(ChildLi { nsMathMLContainerFrame::InsertFrames(aListID, aPrevFrame, aChildList); MarkTextFramesAsTokenMathML(); } void nsMathMLTokenFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); mPresentationData.flags &= ~NS_MATHML_ERROR; // initializations needed for empty markup like <mtag></mtag> aDesiredSize.ClearSize(); aDesiredSize.SetBlockStartAscent(0); @@ -135,17 +135,17 @@ nsMathMLTokenFrame::Reflow(nsPresContext for (nsIFrame* childFrame : PrincipalChildList()) { // ask our children to compute their bounding metrics nsHTMLReflowMetrics childDesiredSize(aReflowState.GetWritingMode(), aDesiredSize.mFlags | NS_REFLOW_CALC_BOUNDING_METRICS); WritingMode wm = childFrame->GetWritingMode(); LogicalSize availSize = aReflowState.ComputedSize(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; - nsHTMLReflowState childReflowState(aPresContext, aReflowState, + ReflowInput childReflowState(aPresContext, aReflowState, childFrame, availSize); ReflowChild(childFrame, aPresContext, childDesiredSize, childReflowState, aStatus); //NS_ASSERTION(NS_FRAME_IS_COMPLETE(aStatus), "bad status"); SaveReflowAndBoundingMetricsFor(childFrame, childDesiredSize, childDesiredSize.mBoundingMetrics); }
--- a/layout/mathml/nsMathMLTokenFrame.h +++ b/layout/mathml/nsMathMLTokenFrame.h @@ -45,17 +45,17 @@ public: virtual void InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame, nsFrameList& aChildList) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsresult Place(DrawTarget* aDrawTarget, bool aPlaceOrigin, nsHTMLReflowMetrics& aDesiredSize) override; protected:
--- a/layout/mathml/nsMathMLmfencedFrame.cpp +++ b/layout/mathml/nsMathMLmfencedFrame.cpp @@ -206,17 +206,17 @@ ApplyUnstretchedMetrics(nsPresContext* charSize, NS_STRETCH_NONE, aIsRTL); aMetrics += charSize; } } void nsMathMLmfencedFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); mPresentationData.flags &= ~NS_MATHML_ERROR; aDesiredSize.ClearSize(); aDesiredSize.SetBlockStartAscent(0); aDesiredSize.mBoundingMetrics = nsBoundingMetrics(); @@ -256,17 +256,17 @@ nsMathMLmfencedFrame::Reflow(nsPresConte } while (childFrame) { nsHTMLReflowMetrics childDesiredSize(aReflowState, aDesiredSize.mFlags | NS_REFLOW_CALC_BOUNDING_METRICS); WritingMode wm = childFrame->GetWritingMode(); LogicalSize availSize = aReflowState.ComputedSize(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; - nsHTMLReflowState childReflowState(aPresContext, aReflowState, + ReflowInput childReflowState(aPresContext, aReflowState, childFrame, availSize); ReflowChild(childFrame, aPresContext, childDesiredSize, childReflowState, childStatus); //NS_ASSERTION(NS_FRAME_IS_COMPLETE(childStatus), "bad status"); SaveReflowAndBoundingMetricsFor(childFrame, childDesiredSize, childDesiredSize.mBoundingMetrics); mozilla::WritingMode outerWM = aReflowState.GetWritingMode();
--- a/layout/mathml/nsMathMLmfencedFrame.h +++ b/layout/mathml/nsMathMLmfencedFrame.h @@ -32,17 +32,17 @@ public: virtual void SetInitialChildList(ChildListID aListID, nsFrameList& aChildList) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; virtual void GetIntrinsicISizeMetrics(nsRenderingContext* aRenderingContext,
--- a/layout/mathml/nsMathMLmoFrame.cpp +++ b/layout/mathml/nsMathMLmoFrame.cpp @@ -940,17 +940,17 @@ nsMathMLmoFrame::SetInitialChildList(Chi // First, let the parent class do its work nsMathMLTokenFrame::SetInitialChildList(aListID, aChildList); ProcessTextData(); } void nsMathMLmoFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { // certain values use units that depend on our style context, so // it is safer to just process the whole lot here ProcessOperatorData(); nsMathMLTokenFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
--- a/layout/mathml/nsMathMLmoFrame.h +++ b/layout/mathml/nsMathMLmoFrame.h @@ -40,17 +40,17 @@ public: virtual void SetInitialChildList(ChildListID aListID, nsFrameList& aChildList) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsresult Place(DrawTarget* aDrawTarget, bool aPlaceOrigin, nsHTMLReflowMetrics& aDesiredSize) override; virtual void MarkIntrinsicISizesDirty() override;
--- a/layout/mathml/nsMathMLmpaddedFrame.cpp +++ b/layout/mathml/nsMathMLmpaddedFrame.cpp @@ -300,17 +300,17 @@ nsMathMLmpaddedFrame::UpdateValue(int32_ else aValueToUpdate = amount; } } void nsMathMLmpaddedFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { mPresentationData.flags &= ~NS_MATHML_ERROR; ProcessAttributes(); /////////////// // Let the base class format our content like an inferred mrow nsMathMLContainerFrame::Reflow(aPresContext, aDesiredSize,
--- a/layout/mathml/nsMathMLmpaddedFrame.h +++ b/layout/mathml/nsMathMLmpaddedFrame.h @@ -25,17 +25,17 @@ public: NS_IMETHOD TransmitAutomaticData() override { return TransmitAutomaticDataForMrowLikeElement(); } virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsresult Place(DrawTarget* aDrawTarget, bool aPlaceOrigin, nsHTMLReflowMetrics& aDesiredSize) override; bool
--- a/layout/mathml/nsMathMLmrootFrame.cpp +++ b/layout/mathml/nsMathMLmrootFrame.cpp @@ -156,17 +156,17 @@ nsMathMLmrootFrame::GetRadicalXOffsets(n *aIndexOffset = dxIndex; if (aSqrOffset) *aSqrOffset = dxSqr; } void nsMathMLmrootFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); nsReflowStatus childStatus; mPresentationData.flags &= ~NS_MATHML_ERROR; aDesiredSize.ClearSize(); aDesiredSize.SetBlockStartAscent(0); @@ -186,17 +186,17 @@ nsMathMLmrootFrame::Reflow(nsPresContext while (childFrame) { // ask our children to compute their bounding metrics nsHTMLReflowMetrics childDesiredSize(aReflowState, aDesiredSize.mFlags | NS_REFLOW_CALC_BOUNDING_METRICS); WritingMode wm = childFrame->GetWritingMode(); LogicalSize availSize = aReflowState.ComputedSize(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; - nsHTMLReflowState childReflowState(aPresContext, aReflowState, + ReflowInput childReflowState(aPresContext, aReflowState, childFrame, availSize); ReflowChild(childFrame, aPresContext, childDesiredSize, childReflowState, childStatus); //NS_ASSERTION(NS_FRAME_IS_COMPLETE(childStatus), "bad status"); if (0 == count) { // base baseFrame = childFrame; baseSize = childDesiredSize;
--- a/layout/mathml/nsMathMLmrootFrame.h +++ b/layout/mathml/nsMathMLmrootFrame.h @@ -32,17 +32,17 @@ public: nsIFrame* aPrevInFlow) override; NS_IMETHOD TransmitAutomaticData() override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; void GetRadicalXOffsets(nscoord aIndexWidth, nscoord aSqrWidth, nsFontMetrics* aFontMetrics, nscoord* aIndexOffset, nscoord* aSqrOffset);
--- a/layout/mathml/nsMathMLmspaceFrame.cpp +++ b/layout/mathml/nsMathMLmspaceFrame.cpp @@ -90,17 +90,17 @@ nsMathMLmspaceFrame::ProcessAttributes(n ParseNumericValue(value, &mDepth, 0, aPresContext, mStyleContext, fontSizeInflation); } } void nsMathMLmspaceFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); mPresentationData.flags &= ~NS_MATHML_ERROR; ProcessAttributes(aPresContext); mBoundingMetrics = nsBoundingMetrics(); mBoundingMetrics.width = mWidth;
--- a/layout/mathml/nsMathMLmspaceFrame.h +++ b/layout/mathml/nsMathMLmspaceFrame.h @@ -27,17 +27,17 @@ public: return NS_OK; } virtual bool IsLeaf() const override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; protected: explicit nsMathMLmspaceFrame(nsStyleContext* aContext) : nsMathMLContainerFrame(aContext) {} virtual ~nsMathMLmspaceFrame(); virtual nsresult MeasureForWidth(DrawTarget* aDrawTarget,
--- a/layout/mathml/nsMathMLmtableFrame.cpp +++ b/layout/mathml/nsMathMLmtableFrame.cpp @@ -817,17 +817,17 @@ nsMathMLmtableWrapperFrame::GetRowFrameA } } return nullptr; } void nsMathMLmtableWrapperFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { nsAutoString value; // we want to return a table that is anchored according to the align attribute nsTableWrapperFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus); NS_ASSERTION(aDesiredSize.Height() >= 0, "illegal height for mtable"); NS_ASSERTION(aDesiredSize.Width() >= 0, "illegal width for mtable"); @@ -1312,17 +1312,17 @@ nsMathMLmtdInnerFrame::nsMathMLmtdInnerF nsMathMLmtdInnerFrame::~nsMathMLmtdInnerFrame() { mUniqueStyleText->Destroy(PresContext()); } void nsMathMLmtdInnerFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { // Let the base class do the reflow nsBlockFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus); // more about <maligngroup/> and <malignmark/> later // ... }
--- a/layout/mathml/nsMathMLmtableFrame.h +++ b/layout/mathml/nsMathMLmtableFrame.h @@ -28,17 +28,17 @@ public: NS_DECL_QUERYFRAME NS_DECL_FRAMEARENA_HELPERS // overloaded nsTableWrapperFrame methods virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual nsresult AttributeChanged(int32_t aNameSpaceID, nsIAtom* aAttribute, int32_t aModType) override; virtual bool IsFrameOfType(uint32_t aFlags) const override @@ -298,17 +298,17 @@ public: nsMathMLContainerFrame::PropagatePresentationDataFromChildAt(this, aFirstIndex, aLastIndex, aFlagsValues, aFlagsToUpdate); return NS_OK; } virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual bool IsFrameOfType(uint32_t aFlags) const override { return nsBlockFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace)); }
--- a/layout/style/nsComputedDOMStyle.cpp +++ b/layout/style/nsComputedDOMStyle.cpp @@ -5120,17 +5120,17 @@ nsComputedDOMStyle::GetLineHeightCoord(n blockHeight = mInnerFrame->GetContentRect().height; } else { GetCBContentHeight(blockHeight); } } // lie about font size inflation since we lie about font size (since // the inflation only applies to text) - aCoord = nsHTMLReflowState::CalcLineHeight(mContent, mStyleContext, + aCoord = ReflowInput::CalcLineHeight(mContent, mStyleContext, blockHeight, 1.0f); // CalcLineHeight uses font->mFont.size, but we want to use // font->mSize as the font size. Adjust for that. Also adjust for // the text zoom, if any. const nsStyleFont* font = StyleFont(); float fCoord = float(aCoord); if (font->mAllowZoom) {
--- a/layout/style/nsRuleNode.cpp +++ b/layout/style/nsRuleNode.cpp @@ -5911,17 +5911,17 @@ nsRuleNode::ComputeDisplayData(void* aSt // -moz-top-layer: enum, inherit, initial SetValue(*aRuleData->ValueForTopLayer(), display->mTopLayer, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mTopLayer, NS_STYLE_TOP_LAYER_NONE); // Backup original display value for calculation of a hypothetical // box (CSS2 10.6.4/10.6.5), in addition to getting our style data right later. - // See nsHTMLReflowState::CalculateHypotheticalBox + // See ReflowInput::CalculateHypotheticalBox display->mOriginalDisplay = display->mDisplay; // appearance: enum, inherit, initial SetValue(*aRuleData->ValueForAppearance(), display->mAppearance, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mAppearance, NS_THEME_NONE);
--- a/layout/svg/SVGTextFrame.cpp +++ b/layout/svg/SVGTextFrame.cpp @@ -5384,17 +5384,17 @@ SVGTextFrame::DoReflow() // an updated preferred width. kid->MarkIntrinsicISizesDirty(); } mState |= NS_STATE_SVG_TEXT_IN_REFLOW; nscoord inlineSize = kid->GetPrefISize(&renderingContext); WritingMode wm = kid->GetWritingMode(); - nsHTMLReflowState reflowState(presContext, kid, + ReflowInput reflowState(presContext, kid, &renderingContext, LogicalSize(wm, inlineSize, NS_UNCONSTRAINEDSIZE)); nsHTMLReflowMetrics desiredSize(reflowState); nsReflowStatus status; NS_ASSERTION(reflowState.ComputedPhysicalBorderPadding() == nsMargin(0, 0, 0, 0) && reflowState.ComputedPhysicalMargin() == nsMargin(0, 0, 0, 0),
--- a/layout/svg/nsSVGForeignObjectFrame.cpp +++ b/layout/svg/nsSVGForeignObjectFrame.cpp @@ -120,17 +120,17 @@ nsSVGForeignObjectFrame::AttributeChange } return NS_OK; } void nsSVGForeignObjectFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MOZ_ASSERT(!(GetStateBits() & NS_FRAME_IS_NONDISPLAY), "Should not have been called"); // Only InvalidateAndScheduleBoundsUpdate marks us with NS_FRAME_IS_DIRTY, // so if that bit is still set we still have a resize pending. If we hit // this assertion, then we should get the presShell to skip reflow roots @@ -536,17 +536,17 @@ nsSVGForeignObjectFrame::DoReflow() // initiate a synchronous reflow here and now: nsRenderingContext renderingContext( presContext->PresShell()->CreateReferenceRenderingContext()); mInReflow = true; WritingMode wm = kid->GetWritingMode(); - nsHTMLReflowState reflowState(presContext, kid, + ReflowInput reflowState(presContext, kid, &renderingContext, LogicalSize(wm, ISize(wm), NS_UNCONSTRAINEDSIZE)); nsHTMLReflowMetrics desiredSize(reflowState); nsReflowStatus status; // We don't use mRect.height above because that tells the child to do // page/column breaking at that height.
--- a/layout/svg/nsSVGForeignObjectFrame.h +++ b/layout/svg/nsSVGForeignObjectFrame.h @@ -38,17 +38,17 @@ public: int32_t aModType) override; virtual nsContainerFrame* GetContentInsertionFrame() override { return PrincipalChildList().FirstChild()->GetContentInsertionFrame(); } virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; /** * Get the "type" of the frame
--- a/layout/svg/nsSVGOuterSVGFrame.cpp +++ b/layout/svg/nsSVGOuterSVGFrame.cpp @@ -353,17 +353,17 @@ nsSVGOuterSVGFrame::ComputeSize(nsRender aMargin, aBorder, aPadding); } void nsSVGOuterSVGFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsSVGOuterSVGFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS, ("enter nsSVGOuterSVGFrame::Reflow: availSize=%d,%d", aReflowState.AvailableWidth(), aReflowState.AvailableHeight())); @@ -499,17 +499,17 @@ nsSVGOuterSVGFrame::Reflow(nsPresContext NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS, ("exit nsSVGOuterSVGFrame::Reflow: size=%d,%d", aDesiredSize.Width(), aDesiredSize.Height())); NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize); } void nsSVGOuterSVGFrame::DidReflow(nsPresContext* aPresContext, - const nsHTMLReflowState* aReflowState, + const ReflowInput* aReflowState, nsDidReflowStatus aStatus) { nsSVGDisplayContainerFrame::DidReflow(aPresContext,aReflowState,aStatus); // Make sure elements styled by :hover get updated if script/animation moves // them under or out from under the pointer: PresContext()->PresShell()->SynthesizeMouseMove(false); }
--- a/layout/svg/nsSVGOuterSVGFrame.h +++ b/layout/svg/nsSVGOuterSVGFrame.h @@ -51,21 +51,21 @@ public: nscoord aAvailableISize, const mozilla::LogicalSize& aMargin, const mozilla::LogicalSize& aBorder, const mozilla::LogicalSize& aPadding, ComputeSizeFlags aFlags) override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; virtual void DidReflow(nsPresContext* aPresContext, - const nsHTMLReflowState* aReflowState, + const ReflowInput* aReflowState, nsDidReflowStatus aStatus) override; virtual void UnionChildOverflow(nsOverflowAreas& aOverflowAreas) override; virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override;
--- a/layout/tables/BasicTableLayoutStrategy.cpp +++ b/layout/tables/BasicTableLayoutStrategy.cpp @@ -515,17 +515,17 @@ BasicTableLayoutStrategy::MarkIntrinsicI { mMinISize = NS_INTRINSIC_WIDTH_UNKNOWN; mPrefISize = NS_INTRINSIC_WIDTH_UNKNOWN; mPrefISizePctExpand = NS_INTRINSIC_WIDTH_UNKNOWN; mLastCalcISize = nscoord_MIN; } /* virtual */ void -BasicTableLayoutStrategy::ComputeColumnISizes(const nsHTMLReflowState& aReflowState) +BasicTableLayoutStrategy::ComputeColumnISizes(const ReflowInput& aReflowState) { nscoord iSize = aReflowState.ComputedISize(); if (mLastCalcISize == iSize) { return; } mLastCalcISize = iSize;
--- a/layout/tables/BasicTableLayoutStrategy.h +++ b/layout/tables/BasicTableLayoutStrategy.h @@ -23,17 +23,17 @@ public: explicit BasicTableLayoutStrategy(nsTableFrame *aTableFrame); virtual ~BasicTableLayoutStrategy(); // nsITableLayoutStrategy implementation virtual nscoord GetMinISize(nsRenderingContext* aRenderingContext) override; virtual nscoord GetPrefISize(nsRenderingContext* aRenderingContext, bool aComputingSize) override; virtual void MarkIntrinsicISizesDirty() override; - virtual void ComputeColumnISizes(const nsHTMLReflowState& aReflowState) override; + virtual void ComputeColumnISizes(const ReflowInput& aReflowState) override; private: // NOTE: Using prefix "BTLS" to avoid overlapping names with // the values of nsLayoutUtils::IntrinsicISizeType enum BtlsISizeType { BTLS_MIN_ISIZE, BTLS_PREF_ISIZE, BTLS_FINAL_ISIZE };
--- a/layout/tables/FixedTableLayoutStrategy.cpp +++ b/layout/tables/FixedTableLayoutStrategy.cpp @@ -148,17 +148,17 @@ AllocateUnassigned(nscoord aUnassignedSp // equal. We want to return unassignedSpace exactly, even if it // can't be precisely round-tripped through float. return aUnassignedSpace; } return NSToCoordRound(float(aUnassignedSpace) * aShare); } /* virtual */ void -FixedTableLayoutStrategy::ComputeColumnISizes(const nsHTMLReflowState& aReflowState) +FixedTableLayoutStrategy::ComputeColumnISizes(const ReflowInput& aReflowState) { nscoord tableISize = aReflowState.ComputedISize(); if (mLastCalcISize == tableISize) { return; } mLastCalcISize = tableISize;
--- a/layout/tables/FixedTableLayoutStrategy.h +++ b/layout/tables/FixedTableLayoutStrategy.h @@ -23,17 +23,17 @@ public: explicit FixedTableLayoutStrategy(nsTableFrame *aTableFrame); virtual ~FixedTableLayoutStrategy(); // nsITableLayoutStrategy implementation virtual nscoord GetMinISize(nsRenderingContext* aRenderingContext) override; virtual nscoord GetPrefISize(nsRenderingContext* aRenderingContext, bool aComputingSize) override; virtual void MarkIntrinsicISizesDirty() override; - virtual void ComputeColumnISizes(const nsHTMLReflowState& aReflowState) + virtual void ComputeColumnISizes(const ReflowInput& aReflowState) override; private: nsTableFrame *mTableFrame; nscoord mMinISize; nscoord mLastCalcISize; };
--- a/layout/tables/nsITableLayoutStrategy.h +++ b/layout/tables/nsITableLayoutStrategy.h @@ -12,23 +12,23 @@ #ifndef nsITableLayoutStrategy_h_ #define nsITableLayoutStrategy_h_ #include "nscore.h" #include "nsCoord.h" class nsRenderingContext; namespace mozilla { -struct nsHTMLReflowState; +struct ReflowInput; } // namespace mozilla class nsITableLayoutStrategy { public: - using nsHTMLReflowState = mozilla::nsHTMLReflowState; + using ReflowInput = mozilla::ReflowInput; virtual ~nsITableLayoutStrategy() {} /** Implement nsIFrame::GetMinISize for the table */ virtual nscoord GetMinISize(nsRenderingContext* aRenderingContext) = 0; /** Implement nsIFrame::GetPrefISize for the table */ virtual nscoord GetPrefISize(nsRenderingContext* aRenderingContext, @@ -36,17 +36,17 @@ public: /** Implement nsIFrame::MarkIntrinsicISizesDirty for the table */ virtual void MarkIntrinsicISizesDirty() = 0; /** * Compute final column isizes based on the intrinsic isize data and * the available isize. */ - virtual void ComputeColumnISizes(const nsHTMLReflowState& aReflowState) = 0; + virtual void ComputeColumnISizes(const ReflowInput& aReflowState) = 0; /** * Return the type of table layout strategy, without the cost of * a virtual function call */ enum Type { Auto, Fixed }; Type GetType() const { return mType; }
--- a/layout/tables/nsTableCellFrame.cpp +++ b/layout/tables/nsTableCellFrame.cpp @@ -103,27 +103,27 @@ nsTableCellFrame::DestroyFrom(nsIFrame* } nsContainerFrame::DestroyFrom(aDestructRoot); } // nsIPercentBSizeObserver methods void -nsTableCellFrame::NotifyPercentBSize(const nsHTMLReflowState& aReflowState) +nsTableCellFrame::NotifyPercentBSize(const ReflowInput& aReflowState) { - // nsHTMLReflowState ensures the mCBReflowState of blocks inside a + // ReflowInput ensures the mCBReflowState of blocks inside a // cell is the cell frame, not the inner-cell block, and that the // containing block of an inner table is the containing block of its // table wrapper. // XXXldb Given the now-stricter |NeedsToObserve|, many if not all of // these tests are probably unnecessary. // Maybe the cell reflow state; we sure if we're inside the |if|. - const nsHTMLReflowState *cellRS = aReflowState.mCBReflowState; + const ReflowInput *cellRS = aReflowState.mCBReflowState; if (cellRS && cellRS->frame == this && (cellRS->ComputedBSize() == NS_UNCONSTRAINEDSIZE || cellRS->ComputedBSize() == 0)) { // XXXldb Why 0? // This is a percentage bsize on a frame whose percentage bsizes // are based on the bsize of the cell, since its containing block // is the inner cell frame. @@ -131,32 +131,32 @@ nsTableCellFrame::NotifyPercentBSize(con // have specified/pct bsize. (Also, siblings only count for this if // both this cell and the sibling cell span exactly 1 row.) if (nsTableFrame::AncestorsHaveStyleBSize(*cellRS) || (GetTableFrame()->GetEffectiveRowSpan(*this) == 1 && cellRS->mParentReflowState->frame-> HasAnyStateBits(NS_ROW_HAS_CELL_WITH_STYLE_BSIZE))) { - for (const nsHTMLReflowState *rs = aReflowState.mParentReflowState; + for (const ReflowInput *rs = aReflowState.mParentReflowState; rs != cellRS; rs = rs->mParentReflowState) { rs->frame->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE); } nsTableFrame::RequestSpecialBSizeReflow(*cellRS); } } } // The cell needs to observe its block and things inside its block but nothing below that bool -nsTableCellFrame::NeedsToObserve(const nsHTMLReflowState& aReflowState) +nsTableCellFrame::NeedsToObserve(const ReflowInput& aReflowState) { - const nsHTMLReflowState *rs = aReflowState.mParentReflowState; + const ReflowInput *rs = aReflowState.mParentReflowState; if (!rs) return false; if (rs->frame == this) { // We always observe the child block. It will never send any // notifications, but we need this so that the observer gets // propagated to its kids. return true; } @@ -556,17 +556,17 @@ nsTableCellFrame::BuildDisplayList(nsDis // event handling. We do not call BuildDisplayListForNonBlockChildren // because that/ would put the child's background in the Content() list // which isn't right (e.g., would end up on top of our child floats for // event handling). BuildDisplayListForChild(aBuilder, kid, aDirtyRect, aLists); } nsIFrame::LogicalSides -nsTableCellFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const +nsTableCellFrame::GetLogicalSkipSides(const ReflowInput* aReflowState) const { if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak == NS_STYLE_BOX_DECORATION_BREAK_CLONE)) { return LogicalSides(); } LogicalSides skip; if (nullptr != GetPrevInFlow()) { @@ -853,17 +853,17 @@ CalcUnpaginatedBSize(nsTableCellFrame& a } } return computedBSize; } void nsTableCellFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsTableCellFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); if (aReflowState.mFlags.mSpecialBSizeReflow) { FirstInFlow()->AddStateBits(NS_TABLE_CELL_HAD_SPECIAL_REFLOW); @@ -896,35 +896,35 @@ nsTableCellFrame::Reflow(nsPresContext* nsHTMLReflowMetrics kidSize(wm, aDesiredSize.mFlags); kidSize.ClearSize(); SetPriorAvailISize(aReflowState.AvailableISize()); nsIFrame* firstKid = mFrames.FirstChild(); NS_ASSERTION(firstKid, "Frame construction error, a table cell always has an inner cell frame"); nsTableFrame* tableFrame = GetTableFrame(); if (aReflowState.mFlags.mSpecialBSizeReflow) { - const_cast<nsHTMLReflowState&>(aReflowState). + const_cast<ReflowInput&>(aReflowState). SetComputedBSize(BSize(wm) - borderPadding.BStartEnd(wm)); DISPLAY_REFLOW_CHANGE(); } else if (aPresContext->IsPaginated()) { nscoord computedUnpaginatedBSize = CalcUnpaginatedBSize((nsTableCellFrame&)*this, *tableFrame, borderPadding.BStartEnd(wm)); if (computedUnpaginatedBSize > 0) { - const_cast<nsHTMLReflowState&>(aReflowState).SetComputedBSize(computedUnpaginatedBSize); + const_cast<ReflowInput&>(aReflowState).SetComputedBSize(computedUnpaginatedBSize); DISPLAY_REFLOW_CHANGE(); } } else { SetHasPctOverBSize(false); } WritingMode kidWM = firstKid->GetWritingMode(); - nsHTMLReflowState kidReflowState(aPresContext, aReflowState, firstKid, + ReflowInput kidReflowState(aPresContext, aReflowState, firstKid, availSize.ConvertTo(kidWM, wm)); // Don't be a percent height observer if we're in the middle of // special-bsize reflow, in case we get an accidental NotifyPercentBSize() // call (which we shouldn't honor during special-bsize reflow) if (!aReflowState.mFlags.mSpecialBSizeReflow) { // mPercentBSizeObserver is for children of cells in quirks mode, // but only those than are tables in standards mode. NeedsToObserve
--- a/layout/tables/nsTableCellFrame.h +++ b/layout/tables/nsTableCellFrame.h @@ -94,19 +94,19 @@ public: #endif virtual nsContainerFrame* GetContentInsertionFrame() override { return PrincipalChildList().FirstChild()->GetContentInsertionFrame(); } virtual nsMargin GetUsedMargin() const override; - virtual void NotifyPercentBSize(const nsHTMLReflowState& aReflowState) override; + virtual void NotifyPercentBSize(const ReflowInput& aReflowState) override; - virtual bool NeedsToObserve(const nsHTMLReflowState& aReflowState) override; + virtual bool NeedsToObserve(const ReflowInput& aReflowState) override; virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override; DrawResult PaintCellBackground(nsRenderingContext& aRenderingContext, const nsRect& aDirtyRect, nsPoint aPt, uint32_t aFlags); @@ -117,17 +117,17 @@ public: const nsDisplayListSet& aLists); virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override; virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override; virtual IntrinsicISizeOffsetData IntrinsicISizeOffsets() override; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; /** * Get the "type" of the frame * * @see nsLayoutAtoms::tableCellFrame */ virtual nsIAtom* GetType() const override; @@ -238,17 +238,17 @@ public: } virtual void InvalidateFrame(uint32_t aDisplayItemKey = 0) override; virtual void InvalidateFrameWithRect(const nsRect& aRect, uint32_t aDisplayItemKey = 0) override; virtual void InvalidateFrameForRemoval() override { InvalidateFrameSubtree(); } protected: virtual LogicalSides - GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const override; + GetLogicalSkipSides(const ReflowInput* aReflowState = nullptr) const override; /** * GetBorderOverflow says how far the cell's own borders extend * outside its own bounds. In the separated borders model this should * just be zero (as it is for most frames), but in the collapsed * borders model (for which nsBCTableCellFrame overrides this virtual * method), it considers the extents of the collapsed border. */
--- a/layout/tables/nsTableColFrame.cpp +++ b/layout/tables/nsTableColFrame.cpp @@ -87,17 +87,17 @@ void nsTableColFrame::SetContinuousBCBor default: NS_ERROR("invalid side arg"); } } void nsTableColFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsTableColFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); aDesiredSize.ClearSize(); const nsStyleVisibility* colVis = StyleVisibility(); bool collapseCol = (NS_STYLE_VISIBILITY_COLLAPSE == colVis->mVisible);
--- a/layout/tables/nsTableColFrame.h +++ b/layout/tables/nsTableColFrame.h @@ -51,17 +51,17 @@ public: int32_t GetColIndex() const; void SetColIndex (int32_t aColIndex); nsTableColFrame* GetNextCol() const; virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; /** * Table columns never paint anything, nor receive events. */ virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) override {}
--- a/layout/tables/nsTableColGroupFrame.cpp +++ b/layout/tables/nsTableColGroupFrame.cpp @@ -325,17 +325,17 @@ nsTableColGroupFrame::RemoveFrame(ChildL } } else { mFrames.DestroyFrame(aOldFrame); } } nsIFrame::LogicalSides -nsTableColGroupFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const +nsTableColGroupFrame::GetLogicalSkipSides(const ReflowInput* aReflowState) const { if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak == NS_STYLE_BOX_DECORATION_BREAK_CLONE)) { return LogicalSides(); } LogicalSides skip; if (nullptr != GetPrevInFlow()) { @@ -345,17 +345,17 @@ nsTableColGroupFrame::GetLogicalSkipSide skip |= eLogicalSideBitsBEnd; } return skip; } void nsTableColGroupFrame::Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsTableColGroupFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus); NS_ASSERTION(nullptr!=mContent, "bad state -- null content for frame"); const nsStyleVisibility* groupVis = StyleVisibility(); @@ -365,17 +365,17 @@ nsTableColGroupFrame::Reflow(nsPresConte } // for every content child that (is a column thingy and does not already have a frame) // create a frame and adjust it's style for (nsIFrame *kidFrame = mFrames.FirstChild(); kidFrame; kidFrame = kidFrame->GetNextSibling()) { // Give the child frame a chance to reflow, even though we know it'll have 0 size nsHTMLReflowMetrics kidSize(aReflowState); - nsHTMLReflowState kidReflowState(aPresContext, aReflowState, kidFrame, + ReflowInput kidReflowState(aPresContext, aReflowState, kidFrame, LogicalSize(kidFrame->GetWritingMode())); nsReflowStatus status; ReflowChild(kidFrame, aPresContext, kidSize, kidReflowState, 0, 0, 0, status); FinishReflowChild(kidFrame, aPresContext, kidSize, nullptr, 0, 0, 0); } aDesiredSize.ClearSize();
--- a/layout/tables/nsTableColGroupFrame.h +++ b/layout/tables/nsTableColGroupFrame.h @@ -101,17 +101,17 @@ public: /** reflow of a column group is a trivial matter of reflowing * the col group's children (columns), and setting this frame * to 0-size. Since tables are row-centric, column group frames * don't play directly in the rendering game. They do however * maintain important state that effects table and cell layout. */ virtual void Reflow(nsPresContext* aPresContext, nsHTMLReflowMetrics& aDesiredSize, - const nsHTMLReflowState& aReflowState, + const ReflowInput& aReflowState, nsReflowStatus& aStatus) override; /** * Get the "type" of the frame * * @see nsGkAtoms::tableColGroupFrame */ virtual nsIAtom* GetType() const override; @@ -209,17 +209,17 @@ public: virtual void InvalidateFrameForRemoval() override { InvalidateFrameSubtree(); } protected: explicit nsTableColGroupFrame(nsStyleContext* aContext); void InsertColsReflow(int32_t aColIndex, const nsFrameList::Slice& aCols); - virtual LogicalSides GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const override; + virtual LogicalSides GetLogicalSkipSides(const ReflowInput* aReflowState = nullptr) const override; // data members int32_t mColCount; // the starting column index this col group represents. Must be >= 0. int32_t mStartColIndex; // border width in pixels BCPixelSize mBStartContBorderWidth;
--- a/layout/tables/nsTableFrame.cpp +++ b/layout/tables/nsTableFrame.cpp @@ -54,28 +54,28 @@ using namespace mozilla::layout; /******************************************************************************** ** nsTableReflowState ** ********************************************************************************/ struct nsTableReflowState { // the real reflow state - const nsHTMLReflowState& reflowState; + const ReflowInput& reflowState; // The table's available size (in reflowState's writing mode) LogicalSize availSize; // Stationary inline-offset nscoord iCoord; // Running block-offset nscoord bCoord; - nsTableReflowState(const nsHTMLReflowState& aReflowState, + nsTableReflowState(const ReflowInput& aReflowState, const LogicalSize& aAvailSize) : reflowState(aReflowState) , availSize(aAvailSize) { MOZ_ASSERT(reflowState.frame->GetType() == nsGkAtoms::tableFrame, "nsTableReflowState should only be created for nsTableFrame"); nsTableFrame* table = static_cast<nsTableFrame*>(reflowState.frame->FirstInFlow()); @@ -1406,17 +1406,17 @@ nsTableFrame::PaintTableBorderBackground PaintBCBorders(*drawTarget, aDirtyRect - aPt); } } return result; } nsIFrame::LogicalSides -nsTableFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const +nsTableFrame::GetLogicalSkipSides(const ReflowInput* aReflowState) const { if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak == NS_STYLE_BOX_DECORATION_BREAK_CLONE)) { return LogicalSides(); } LogicalSides skip; // frame attribute was accounted for in nsHTMLTableElement::MapTableBorderInto @@ -1664,20 +1664,20 @@ nsTableFrame::ComputeAutoSize(nsRenderin aPadding.ISize(aWM); return LogicalSize(aWM, TableShrinkISizeToFit(aRenderingContext, cbBased), NS_UNCONSTRAINEDSIZE); } // Return true if aParentReflowState.frame or any of its ancestors within // the containing table have non-auto bsize. (e.g. pct or fixed bsize) bool -nsTableFrame::AncestorsHaveStyleBSize(const nsHTMLReflowState& aParentReflowState) +nsTableFrame::AncestorsHaveStyleBSize(const ReflowInput& aParentReflowState) { WritingMode wm = aParentReflowState.GetWritingMode(); - for (const nsHTMLReflowState* rs = &aParentReflowState; + for (const ReflowInput* rs = &aParentReflowState; rs && rs->frame; rs = rs->mParentReflowState) { nsIAtom* frameType = rs->frame->GetType(); if (IS_TABLE_CELL(frameType) || (nsGkAtoms::tableRowFrame == frameType) || (nsGkAtoms::tableRowGroupFrame == frameType)) { const nsStyleCoord &bsize = rs->mStylePosition->BSize(wm); // calc() with percentages treated like 'auto' on internal table elements if (bsize.GetUnit() != eStyleUnit_Auto && @@ -1691,17 +1691,17 @@ nsTableFrame::AncestorsHaveStyleBSize(co } } return false; } // See if a special block-size reflow needs to occur and if so,