--- 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
@@ -697,17 +697,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
@@ -5903,17 +5903,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,
// call RequestSpecialBSizeReflow
void
-nsTableFrame::CheckRequestSpecialBSizeReflow(const nsHTMLReflowState& aReflowState)
+nsTableFrame::CheckRequestSpecialBSizeReflow(const ReflowInput& aReflowState)
{
NS_ASSERTION(IS_TABLE_CELL(aReflowState.frame->GetType()) ||
aReflowState.frame->GetType() == nsGkAtoms::tableRowFrame ||
aReflowState.frame->GetType() == nsGkAtoms::tableRowGroupFrame ||
aReflowState.frame->GetType() == nsGkAtoms::tableFrame,
"unexpected frame type");
WritingMode wm = aReflowState.GetWritingMode();
if (!aReflowState.frame->GetPrevInFlow() && // 1st in flow
@@ -1714,20 +1714,20 @@ nsTableFrame::CheckRequestSpecialBSizeRe
}
// Notify the frame and its ancestors (up to the containing table) that a special
// bsize reflow will occur. During a special bsize reflow, a table, row group,
// row, or cell returns the last size it was reflowed at. However, the table may
// change the bsize of row groups, rows, cells in DistributeBSizeToRows after.
// And the row group can change the bsize of rows, cells in CalculateRowBSizes.
void
-nsTableFrame::RequestSpecialBSizeReflow(const nsHTMLReflowState& aReflowState)
+nsTableFrame::RequestSpecialBSizeReflow(const ReflowInput& aReflowState)
{
// notify the frame and its ancestors of the special reflow, stopping at the containing table
- for (const nsHTMLReflowState* rs = &aReflowState; rs && rs->frame; rs = rs->mParentReflowState) {
+ for (const ReflowInput* rs = &aReflowState; rs && rs->frame; rs = rs->mParentReflowState) {
nsIAtom* frameType = rs->frame->GetType();
NS_ASSERTION(IS_TABLE_CELL(frameType) ||
nsGkAtoms::tableRowFrame == frameType ||
nsGkAtoms::tableRowGroupFrame == frameType ||
nsGkAtoms::tableFrame == frameType,
"unexpected frame type");
rs->frame->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);
@@ -1800,17 +1800,17 @@ nsTableFrame::RequestSpecialBSizeReflow(
* the contents of the cells to do the necessary block-axis resizing.
*
******************************************************************************************/
/* Layout the entire inner table. */
void
nsTableFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsTableFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
bool isPaginated = aPresContext->IsPaginated();
WritingMode wm = aReflowState.GetWritingMode();
@@ -1897,18 +1897,18 @@ nsTableFrame::Reflow(nsPresContext*
if (HasAnyStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE)) {
needToInitiateSpecialReflow = true;
}
// XXXldb Are all these conditions correct?
if (needToInitiateSpecialReflow && NS_FRAME_IS_COMPLETE(aStatus)) {
// XXXldb Do we need to set the IsBResize flag on any reflow states?
- nsHTMLReflowState &mutable_rs =
- const_cast<nsHTMLReflowState&>(aReflowState);
+ ReflowInput &mutable_rs =
+ const_cast<ReflowInput&>(aReflowState);
// distribute extra block-direction space to rows
CalcDesiredBSize(aReflowState, aDesiredSize);
mutable_rs.mFlags.mSpecialBSizeReflow = true;
ReflowTable(aDesiredSize, aReflowState, aReflowState.AvailableBSize(),
lastChildReflowed, aStatus);
@@ -1981,17 +1981,17 @@ nsTableFrame::Reflow(nsPresContext*
FinishAndStoreOverflow(&aDesiredSize);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
}
void
nsTableFrame::FixupPositionedTableParts(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState)
+ const ReflowInput& aReflowState)
{
FrameTArray* positionedParts = Properties().Get(PositionedTablePartArray());
if (!positionedParts) {
return;
}
OverflowChangedTracker overflowTracker;
overflowTracker.SetSubtreeRoot(this);
@@ -2009,19 +2009,19 @@ nsTableFrame::FixupPositionedTableParts(
// Construct a dummy reflow state and reflow status.
// XXX(seth): Note that the dummy reflow state doesn't have a correct
// chain of parent reflow states. It also doesn't necessarily have a
// correct containing block.
WritingMode wm = positionedPart->GetWritingMode();
LogicalSize availSize(wm, size);
availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
- nsHTMLReflowState reflowState(aPresContext, positionedPart,
+ ReflowInput reflowState(aPresContext, positionedPart,
aReflowState.rendContext, availSize,
- nsHTMLReflowState::DUMMY_PARENT_REFLOW_STATE);
+ ReflowInput::DUMMY_PARENT_REFLOW_STATE);
nsReflowStatus reflowStatus = NS_FRAME_COMPLETE;
// Reflow absolutely-positioned descendants of the positioned part.
// FIXME: Unconditionally using NS_UNCONSTRAINEDSIZE for the bsize and
// ignoring any change to the reflow status aren't correct. We'll never
// paginate absolutely positioned frames.
nsFrame* positionedFrame = static_cast<nsFrame*>(positionedPart);
positionedFrame->FinishReflowWithAbsoluteFrames(PresContext(),
@@ -2062,17 +2062,17 @@ nsTableFrame::ComputeCustomOverflow(nsOv
aOverflowAreas.UnionAllWith(bounds);
}
return nsContainerFrame::ComputeCustomOverflow(aOverflowAreas);
}
void
nsTableFrame::ReflowTable(nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nscoord aAvailBSize,
nsIFrame*& aLastChildReflowed,
nsReflowStatus& aStatus)
{
aLastChildReflowed = nullptr;
if (!GetPrevInFlow()) {
mTableLayoutStrategy->ComputeColumnISizes(aReflowState);
@@ -2711,40 +2711,40 @@ nsTableFrame::GetIncludedOuterBCBorder(c
LogicalMargin
nsTableFrame::GetExcludedOuterBCBorder(const WritingMode aWM) const
{
return GetOuterBCBorder(aWM) - GetIncludedOuterBCBorder(aWM);
}
static LogicalMargin
GetSeparateModelBorderPadding(const WritingMode aWM,
- const nsHTMLReflowState* aReflowState,
+ const ReflowInput* aReflowState,
nsStyleContext* aStyleContext)
{
// XXXbz Either we _do_ have a reflow state and then we can use its
// mComputedBorderPadding or we don't and then we get the padding
// wrong!
const nsStyleBorder* border = aStyleContext->StyleBorder();
LogicalMargin borderPadding(aWM, border->GetComputedBorder());
if (aReflowState) {
borderPadding += aReflowState->ComputedLogicalPadding();
}
return borderPadding;
}
LogicalMargin
nsTableFrame::GetChildAreaOffset(const WritingMode aWM,
- const nsHTMLReflowState* aReflowState) const
+ const ReflowInput* aReflowState) const
{
return IsBorderCollapse() ? GetIncludedOuterBCBorder(aWM) :
GetSeparateModelBorderPadding(aWM, aReflowState, mStyleContext);
}
void
-nsTableFrame::InitChildReflowState(nsHTMLReflowState& aReflowState)
+nsTableFrame::InitChildReflowState(ReflowInput& aReflowState)
{
nsMargin collapseBorder;
nsMargin padding(0,0,0,0);
nsMargin* pCollapseBorder = nullptr;
nsPresContext* presContext = PresContext();
if (IsBorderCollapse()) {
nsTableRowGroupFrame* rgFrame =
static_cast<nsTableRowGroupFrame*>(aReflowState.frame);
@@ -2920,19 +2920,19 @@ nsTableFrame::SetupHeaderFooterChild(con
// Reflow the child with unconstrained height
WritingMode wm = aFrame->GetWritingMode();
LogicalSize availSize = aReflowState.reflowState.AvailableSize(wm);
nsSize containerSize = availSize.GetPhysicalSize(wm);
// XXX check for containerSize.* == NS_UNCONSTRAINEDSIZE
availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
- nsHTMLReflowState kidReflowState(presContext, aReflowState.reflowState,
+ ReflowInput kidReflowState(presContext, aReflowState.reflowState,
aFrame, availSize, nullptr,
- nsHTMLReflowState::CALLER_WILL_INIT);
+ ReflowInput::CALLER_WILL_INIT);
InitChildReflowState(kidReflowState);
kidReflowState.mFlags.mIsTopOfPage = true;
nsHTMLReflowMetrics desiredSize(aReflowState.reflowState);
desiredSize.ClearSize();
nsReflowStatus status;
ReflowChild(aFrame, presContext, desiredSize, kidReflowState,
wm, LogicalPoint(wm, aReflowState.iCoord, aReflowState.bCoord),
containerSize, 0, status);
@@ -2951,21 +2951,21 @@ nsTableFrame::PlaceRepeatedFooter(nsTabl
nsPresContext* presContext = PresContext();
WritingMode wm = aTfoot->GetWritingMode();
LogicalSize kidAvailSize = aReflowState.availSize;
nsSize containerSize = kidAvailSize.GetPhysicalSize(wm);
// XXX check for containerSize.* == NS_UNCONSTRAINEDSIZE
kidAvailSize.BSize(wm) = aFooterHeight;
- nsHTMLReflowState footerReflowState(presContext,
+ ReflowInput footerReflowState(presContext,
aReflowState.reflowState,
aTfoot, kidAvailSize,
nullptr,
- nsHTMLReflowState::CALLER_WILL_INIT);
+ ReflowInput::CALLER_WILL_INIT);
InitChildReflowState(footerReflowState);
aReflowState.bCoord += GetRowSpacing(GetRowCount());
nsRect origTfootRect = aTfoot->GetRect();
nsRect origTfootVisualOverflow = aTfoot->GetVisualOverflowRect();
nsReflowStatus footerStatus;
nsHTMLReflowMetrics desiredSize(aReflowState.reflowState);
@@ -3089,21 +3089,21 @@ nsTableFrame::ReflowChildren(nsTableRefl
nsRect oldKidRect = kidFrame->GetRect();
nsRect oldKidVisualOverflow = kidFrame->GetVisualOverflowRect();
nsHTMLReflowMetrics desiredSize(aReflowState.reflowState);
desiredSize.ClearSize();
// Reflow the child into the available space
- nsHTMLReflowState kidReflowState(presContext, aReflowState.reflowState,
+ ReflowInput kidReflowState(presContext, aReflowState.reflowState,
kidFrame,
kidAvailSize,
nullptr,
- nsHTMLReflowState::CALLER_WILL_INIT);
+ ReflowInput::CALLER_WILL_INIT);
InitChildReflowState(kidReflowState);
// If this isn't the first row group, and the previous row group has a
// nonzero YMost, then we can't be at the top of the page.
// We ignore a repeated head row group in this check to avoid causing
// infinite loops in some circumstances - see bug 344883.
if (childX > ((thead && IsRepeatedFrame(thead)) ? 1u : 0u) &&
(rowGroups[childX - 1]->GetNormalRect().YMost() > 0)) {
@@ -3290,31 +3290,31 @@ void
nsTableFrame::ReflowColGroups(nsRenderingContext *aRenderingContext)
{
if (!GetPrevInFlow() && !HaveReflowedColGroups()) {
nsHTMLReflowMetrics kidMet(GetWritingMode());
nsPresContext *presContext = PresContext();
for (nsIFrame* kidFrame : mColGroups) {
if (NS_SUBTREE_DIRTY(kidFrame)) {
// The column groups don't care about dimensions or reflow states.
- nsHTMLReflowState
+ ReflowInput
kidReflowState(presContext, kidFrame, aRenderingContext,
LogicalSize(kidFrame->GetWritingMode()));
nsReflowStatus cgStatus;
ReflowChild(kidFrame, presContext, kidMet, kidReflowState, 0, 0, 0,
cgStatus);
FinishReflowChild(kidFrame, presContext, kidMet, nullptr, 0, 0, 0);
}
}
SetHaveReflowedColGroups(true);
}
}
void
-nsTableFrame::CalcDesiredBSize(const nsHTMLReflowState& aReflowState,
+nsTableFrame::CalcDesiredBSize(const ReflowInput& aReflowState,
nsHTMLReflowMetrics& aDesiredSize)
{
WritingMode wm = aReflowState.GetWritingMode();
nsTableCellMap* cellMap = GetCellMap();
if (!cellMap) {
NS_ERROR("never ever call me until the cell map is built!");
aDesiredSize.BSize(wm) = 0;
return;
@@ -3394,17 +3394,17 @@ void ResizeCells(nsTableFrame& aTableFra
rgFrame->FinishAndStoreOverflow(&groupDesiredSize);
tableDesiredSize.mOverflowAreas.UnionWith(groupDesiredSize.mOverflowAreas +
rgFrame->GetPosition());
}
aTableFrame.FinishAndStoreOverflow(&tableDesiredSize);
}
void
-nsTableFrame::DistributeBSizeToRows(const nsHTMLReflowState& aReflowState,
+nsTableFrame::DistributeBSizeToRows(const ReflowInput& aReflowState,
nscoord aAmount)
{
WritingMode wm = aReflowState.GetWritingMode();
LogicalMargin borderPadding = GetChildAreaOffset(wm, &aReflowState);
nsSize containerSize =
aReflowState.ComputedSizeAsContainerIfConstrained();
@@ -3857,17 +3857,17 @@ nsTableFrame::IsAutoBSize(WritingMode aW
const nsStyleCoord &bsize = StylePosition()->BSize(aWM);
// Don't consider calc() here like this quirk for percent.
return bsize.GetUnit() == eStyleUnit_Auto ||
(bsize.GetUnit() == eStyleUnit_Percent &&
bsize.GetPercentValue() <= 0.0f);
}
nscoord
-nsTableFrame::CalcBorderBoxBSize(const nsHTMLReflowState& aState)
+nsTableFrame::CalcBorderBoxBSize(const ReflowInput& aState)
{
nscoord bSize = aState.ComputedBSize();
if (NS_AUTOHEIGHT != bSize) {
WritingMode wm = aState.GetWritingMode();
LogicalMargin borderPadding = GetChildAreaOffset(wm, &aState);
bSize += borderPadding.BStartEnd(wm);
}
bSize = std::max(0, bSize);
--- a/layout/tables/nsTableFrame.h
+++ b/layout/tables/nsTableFrame.h
@@ -157,41 +157,41 @@ public:
virtual void Init(nsIContent* aContent,
nsContainerFrame* aParent,
nsIFrame* aPrevInFlow) override;
static float GetTwipsToPixels(nsPresContext* aPresContext);
// Return true if aParentReflowState.frame or any of its ancestors within
// the containing table have non-auto bsize. (e.g. pct or fixed bsize)
- static bool AncestorsHaveStyleBSize(const nsHTMLReflowState& aParentReflowState);
+ static bool AncestorsHaveStyleBSize(const ReflowInput& aParentReflowState);
// See if a special bsize reflow will occur due to having a pct bsize when
// the pct bsize basis may not yet be valid.
- static void CheckRequestSpecialBSizeReflow(const nsHTMLReflowState& aReflowState);
+ static void CheckRequestSpecialBSizeReflow(const ReflowInput& aReflowState);
// Notify the frame and its ancestors (up to the containing table) that a special
// height reflow will occur.
- static void RequestSpecialBSizeReflow(const nsHTMLReflowState& aReflowState);
+ static void RequestSpecialBSizeReflow(const ReflowInput& aReflowState);
static void RePositionViews(nsIFrame* aFrame);
static bool PageBreakAfter(nsIFrame* aSourceFrame,
nsIFrame* aNextFrame);
// Register a positioned table part with its nsTableFrame. These objects will
// be visited by FixupPositionedTableParts after reflow is complete. (See that
// function for more explanation.) Should be called during frame construction.
static void RegisterPositionedTablePart(nsIFrame* aFrame);
// Unregister a positioned table part with its nsTableFrame.
static void UnregisterPositionedTablePart(nsIFrame* aFrame,
nsIFrame* aDestructRoot);
- nsPoint GetFirstSectionOrigin(const nsHTMLReflowState& aReflowState) const;
+ nsPoint GetFirstSectionOrigin(const ReflowInput& aReflowState) const;
/*
* Notification that aAttribute has changed for content inside a table (cell, row, etc)
*/
void AttributeChangedFor(nsIFrame* aFrame,
nsIContent* aContent,
nsIAtom* aAttribute);
/** @see nsIFrame::DestroyFrom */
@@ -211,17 +211,17 @@ public:
nsIFrame* aOldFrame) override;
virtual nsMargin GetUsedBorder() const override;
virtual nsMargin GetUsedPadding() const override;
virtual nsMargin GetUsedMargin() const override;
// Get the offset from the border box to the area where the row groups fit
LogicalMargin GetChildAreaOffset(const WritingMode aWM,
- const nsHTMLReflowState* aReflowState) const;
+ const ReflowInput* aReflowState) const;
/** helper method to find the table parent of any table frame object */
static nsTableFrame* GetTableFrame(nsIFrame* aSourceFrame);
/* Like GetTableFrame, but will set *aDidPassThrough to false if we don't
* pass through aMustPassThrough on the way to the table.
*/
static nsTableFrame* GetTableFramePassingThrough(nsIFrame* aMustPassThrough,
@@ -364,21 +364,21 @@ public:
* do pass 2
* use column widths to Reflow cells
* </pre>
*
* @see nsIFrame::Reflow
*/
virtual void Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsReflowStatus& aStatus) override;
void ReflowTable(nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nscoord aAvailBSize,
nsIFrame*& aLastChildReflowed,
nsReflowStatus& aStatus);
nsFrameList& GetColGroups();
virtual nsStyleContext*
GetParentStyleContext(nsIFrame** aProviderFrame) const override;
@@ -608,19 +608,19 @@ protected:
/** protected constructor.
* @see NewFrame
*/
explicit nsTableFrame(nsStyleContext* aContext);
/** destructor, responsible for mColumnLayoutData */
virtual ~nsTableFrame();
- void InitChildReflowState(nsHTMLReflowState& aReflowState);
+ void InitChildReflowState(ReflowInput& aReflowState);
- virtual LogicalSides GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const override;
+ virtual LogicalSides GetLogicalSkipSides(const ReflowInput* aReflowState = nullptr) const override;
public:
bool IsRowInserted() const;
void SetRowInserted(bool aValue);
protected:
// A helper function to reflow a header or footer with unconstrained height
@@ -659,17 +659,17 @@ protected:
/** FixupPositionedTableParts is called at the end of table reflow to reflow
* the absolutely positioned descendants of positioned table parts. This is
* necessary because the dimensions of table parts may change after they've
* been reflowed (e.g. in AdjustForCollapsingRowsCols).
*/
void FixupPositionedTableParts(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState);
+ const ReflowInput& aReflowState);
// Clears the list of positioned table parts.
void ClearAllPositionedTableParts();
nsITableLayoutStrategy* LayoutStrategy() const {
return static_cast<nsTableFrame*>(FirstInFlow())->
mTableLayoutStrategy;
}
@@ -684,29 +684,29 @@ private:
void ProcessRowInserted(nscoord aNewHeight);
// WIDTH AND HEIGHT CALCULATION
public:
// calculate the computed block-size of aFrame including its border and
// padding given its reflow state.
- nscoord CalcBorderBoxBSize(const nsHTMLReflowState& aReflowState);
+ nscoord CalcBorderBoxBSize(const ReflowInput& aReflowState);
protected:
// update the desired block-size of this table taking into account the current
// reflow state, the table attributes and the content driven rowgroup bsizes
// this function can change the overflow area
- void CalcDesiredBSize(const nsHTMLReflowState& aReflowState,
+ void CalcDesiredBSize(const ReflowInput& aReflowState,
nsHTMLReflowMetrics& aDesiredSize);
// The following is a helper for CalcDesiredBSize
- void DistributeBSizeToRows(const nsHTMLReflowState& aReflowState,
+ void DistributeBSizeToRows(const ReflowInput& aReflowState,
nscoord aAmount);
void PlaceChild(nsTableReflowState& aReflowState,
nsIFrame* aKidFrame,
nsPoint aKidPosition,
nsHTMLReflowMetrics& aKidDesiredSize,
const nsRect& aOriginalKidRect,
const nsRect& aOriginalKidVisualOverflow);
--- a/layout/tables/nsTableRowFrame.cpp
+++ b/layout/tables/nsTableRowFrame.cpp
@@ -21,24 +21,24 @@
#include "nsTableColFrame.h"
#include "nsCOMPtr.h"
#include "nsDisplayList.h"
#include "nsIFrameInlines.h"
#include <algorithm>
using namespace mozilla;
-struct nsTableCellReflowState : public nsHTMLReflowState
+struct nsTableCellReflowState : public ReflowInput
{
nsTableCellReflowState(nsPresContext* aPresContext,
- const nsHTMLReflowState& aParentReflowState,
+ const ReflowInput& aParentReflowState,
nsIFrame* aFrame,
const LogicalSize& aAvailableSpace,
uint32_t aFlags = 0)
- : nsHTMLReflowState(aPresContext, aParentReflowState, aFrame,
+ : ReflowInput(aPresContext, aParentReflowState, aFrame,
aAvailableSpace, nullptr, aFlags)
{
}
void FixUp(const LogicalSize& aAvailSpace);
};
void nsTableCellReflowState::FixUp(const LogicalSize& aAvailSpace)
@@ -513,17 +513,17 @@ nsTableRowFrame::UpdateBSize(nscoord
if (GetInitialBSize() < mMaxCellAscent + mMaxCellDescent) {
SetContentBSize(mMaxCellAscent + mMaxCellDescent);
}
}
}
}
nscoord
-nsTableRowFrame::CalcBSize(const nsHTMLReflowState& aReflowState)
+nsTableRowFrame::CalcBSize(const ReflowInput& aReflowState)
{
nsTableFrame* tableFrame = GetTableFrame();
nscoord computedBSize = (NS_UNCONSTRAINEDSIZE == aReflowState.ComputedBSize())
? 0 : aReflowState.ComputedBSize();
ResetBSize(computedBSize);
WritingMode wm = aReflowState.GetWritingMode();
const nsStylePosition* position = StylePosition();
@@ -614,17 +614,17 @@ nsTableRowFrame::BuildDisplayList(nsDisp
item = new (aBuilder) nsDisplayTableRowBackground(aBuilder, this);
aLists.BorderBackground()->AppendNewToTop(item);
}
}
nsTableFrame::DisplayGenericTablePart(aBuilder, this, aDirtyRect, aLists, item);
}
nsIFrame::LogicalSides
-nsTableRowFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const
+nsTableRowFrame::GetLogicalSkipSides(const ReflowInput* aReflowState) const
{
if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak ==
NS_STYLE_BOX_DECORATION_BREAK_CLONE)) {
return LogicalSides();
}
LogicalSides skip;
if (nullptr != GetPrevInFlow()) {
@@ -777,17 +777,17 @@ nscoord CalcBSizeFromUnpaginatedBSize(ns
}
}
return std::max(bsize, 0);
}
void
nsTableRowFrame::ReflowChildren(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsTableFrame& aTableFrame,
nsReflowStatus& aStatus)
{
aStatus = NS_FRAME_COMPLETE;
// XXXldb Should we be checking constrained bsize instead?
const bool isPaginated = aPresContext->IsPaginated();
const bool borderCollapse = aTableFrame.IsBorderCollapse();
@@ -811,17 +811,17 @@ nsTableRowFrame::ReflowChildren(nsPresCo
if (!cellFrame) {
// XXXldb nsCSSFrameConstructor needs to enforce this!
NS_NOTREACHED("yikes, a non-row child");
// it's an unknown frame type, give it a generic reflow and ignore the results
nsTableCellReflowState
kidReflowState(aPresContext, aReflowState, kidFrame,
LogicalSize(kidFrame->GetWritingMode(), 0, 0),
- nsHTMLReflowState::CALLER_WILL_INIT);
+ ReflowInput::CALLER_WILL_INIT);
InitChildReflowState(*aPresContext, LogicalSize(wm), false, kidReflowState);
nsHTMLReflowMetrics desiredSize(aReflowState);
nsReflowStatus status;
ReflowChild(kidFrame, aPresContext, desiredSize, kidReflowState, 0, 0, 0, status);
kidFrame->DidReflow(aPresContext, nullptr, nsDidReflowStatus::FINISHED);
continue;
}
@@ -904,17 +904,17 @@ nsTableRowFrame::ReflowChildren(nsPresCo
HasPctBSize()) {
// Reflow the cell to fit the available isize, bsize
// XXX The old IR_ChildIsDirty code used availCellISize here.
LogicalSize kidAvailSize(wm, availCellISize, aReflowState.AvailableBSize());
// Reflow the child
kidReflowState.emplace(aPresContext, aReflowState, kidFrame,
kidAvailSize,
- nsHTMLReflowState::CALLER_WILL_INIT);
+ ReflowInput::CALLER_WILL_INIT);
InitChildReflowState(*aPresContext, kidAvailSize, borderCollapse,
*kidReflowState);
nsReflowStatus status;
ReflowChild(kidFrame, aPresContext, desiredSize, *kidReflowState,
wm, kidPosition, containerSize, 0, status);
// allow the table to determine if/how the table needs to be rebalanced
@@ -974,17 +974,17 @@ nsTableRowFrame::ReflowChildren(nsPresCo
// MovePositionBy does internally. (This codepath should really
// be merged into the else below if we can.)
nsMargin* computedOffsetProp =
kidFrame->Properties().Get(nsIFrame::ComputedOffsetProperty());
// Bug 975644: a position:sticky kid can end up with a null
// property value here.
LogicalMargin computedOffsets(wm, computedOffsetProp ?
*computedOffsetProp : nsMargin());
- nsHTMLReflowState::ApplyRelativePositioning(kidFrame, wm, computedOffsets,
+ ReflowInput::ApplyRelativePositioning(kidFrame, wm, computedOffsets,
&kidPosition, containerSize);
}
// In vertical-rl mode, we are likely to have containerSize.width = 0
// because ComputedWidth() was NS_UNCONSTRAINEDSIZE.
// For cases where that's wrong, we will fix up the position later.
FinishReflowChild(kidFrame, aPresContext, desiredSize, nullptr,
wm, kidPosition, containerSize, 0);
@@ -1072,17 +1072,17 @@ nsTableRowFrame::ReflowChildren(nsPresCo
}
/** Layout the entire row.
* This method stacks cells in the inline dir according to HTML 4.0 rules.
*/
void
nsTableRowFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsTableRowFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
WritingMode wm = aReflowState.GetWritingMode();
@@ -1127,17 +1127,17 @@ nsTableRowFrame::Reflow(nsPresContext*
/**
* This function is called by the row group frame's SplitRowGroup() code when
* pushing a row frame that has cell frames that span into it. The cell frame
* should be reflowed with the specified height
*/
nscoord
nsTableRowFrame::ReflowCellFrame(nsPresContext* aPresContext,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
bool aIsTopOfPage,
nsTableCellFrame* aCellFrame,
nscoord aAvailableBSize,
nsReflowStatus& aStatus)
{
WritingMode wm = aReflowState.GetWritingMode();
// Reflow the cell frame with the specified height. Use the existing width
@@ -1147,17 +1147,17 @@ nsTableRowFrame::ReflowCellFrame(nsPresC
LogicalSize cellSize = cellRect.Size(wm);
LogicalSize availSize(wm, cellRect.ISize(wm), aAvailableBSize);
bool borderCollapse = GetTableFrame()->IsBorderCollapse();
NS_ASSERTION(aCellFrame->GetWritingMode() == wm,
"expected consistent writing-mode within table");
nsTableCellReflowState
cellReflowState(aPresContext, aReflowState, aCellFrame, availSize,
- nsHTMLReflowState::CALLER_WILL_INIT);
+ ReflowInput::CALLER_WILL_INIT);
InitChildReflowState(*aPresContext, availSize, borderCollapse, cellReflowState);
cellReflowState.mFlags.mIsTopOfPage = aIsTopOfPage;
nsHTMLReflowMetrics desiredSize(aReflowState);
ReflowChild(aCellFrame, aPresContext, desiredSize, cellReflowState,
0, 0, NS_FRAME_NO_MOVE_FRAME, aStatus);
bool fullyComplete = NS_FRAME_IS_COMPLETE(aStatus) && !NS_FRAME_IS_TRUNCATED(aStatus);
--- a/layout/tables/nsTableRowFrame.h
+++ b/layout/tables/nsTableRowFrame.h
@@ -91,17 +91,17 @@ public:
* height of cells with rowspan=1.
*
* @see nsIFrame::Reflow
* @see nsTableFrame::BalanceColumnWidths
* @see nsTableFrame::ShrinkWrapChildren
*/
virtual void Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsReflowStatus& aStatus) override;
void DidResize();
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::tableRowFrame
@@ -120,17 +120,17 @@ public:
nscoord aDescent,
nsTableFrame* aTableFrame = nullptr,
nsTableCellFrame* aCellFrame = nullptr);
void ResetBSize(nscoord aRowStyleBSize);
// calculate the bsize, considering content bsize of the
// cells and the style bsize of the row and cells, excluding pct bsizes
- nscoord CalcBSize(const nsHTMLReflowState& aReflowState);
+ nscoord CalcBSize(const ReflowInput& aReflowState);
// Support for cells with 'vertical-align: baseline'.
/**
* returns the max-ascent amongst all the cells that have
* 'vertical-align: baseline', *including* cells with rowspans.
* returns 0 if we don't have any cell with 'vertical-align: baseline'
*/
@@ -143,17 +143,17 @@ public:
/** returns the ordinal position of this row in its table */
virtual int32_t GetRowIndex() const;
/** set this row's starting row index */
void SetRowIndex (int aRowIndex);
/** used by row group frame code */
nscoord ReflowCellFrame(nsPresContext* aPresContext,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
bool aIsTopOfPage,
nsTableCellFrame* aCellFrame,
nscoord aAvailableBSize,
nsReflowStatus& aStatus);
/**
* Collapse the row if required, apply col and colgroup visibility: collapse
* info to the cells in the row.
* @return the amount to shift bstart-wards all following rows
@@ -258,30 +258,30 @@ protected:
*/
explicit nsTableRowFrame(nsStyleContext *aContext);
void InitChildReflowState(nsPresContext& aPresContext,
const mozilla::LogicalSize& aAvailSize,
bool aBorderCollapse,
nsTableCellReflowState& aReflowState);
- virtual LogicalSides GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const override;
+ virtual LogicalSides GetLogicalSkipSides(const ReflowInput* aReflowState = nullptr) const override;
// row-specific methods
- nscoord ComputeCellXOffset(const nsHTMLReflowState& aState,
+ nscoord ComputeCellXOffset(const ReflowInput& aState,
nsIFrame* aKidFrame,
const nsMargin& aKidMargin) const;
/**
* Called for incremental/dirty and resize reflows. If aDirtyOnly is true then
* only reflow dirty cells.
*/
void ReflowChildren(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsTableFrame& aTableFrame,
nsReflowStatus& aStatus);
private:
struct RowBits {
unsigned mRowIndex:29;
unsigned mHasFixedBSize:1; // set if the dominating style bsize on the row or any cell is pixel based
unsigned mHasPctBSize:1; // set if the dominating style bsize on the row or any cell is pct based
--- a/layout/tables/nsTableRowGroupFrame.cpp
+++ b/layout/tables/nsTableRowGroupFrame.cpp
@@ -231,17 +231,17 @@ nsTableRowGroupFrame::BuildDisplayList(n
aLists.BorderBackground()->AppendNewToTop(item);
}
}
nsTableFrame::DisplayGenericTablePart(aBuilder, this, aDirtyRect,
aLists, item, DisplayRows);
}
nsIFrame::LogicalSides
-nsTableRowGroupFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const
+nsTableRowGroupFrame::GetLogicalSkipSides(const ReflowInput* aReflowState) const
{
if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak ==
NS_STYLE_BOX_DECORATION_BREAK_CLONE)) {
return LogicalSides();
}
LogicalSides skip;
if (nullptr != GetPrevInFlow()) {
@@ -281,17 +281,17 @@ nsTableRowGroupFrame::PlaceChild(nsPresC
if (NS_UNCONSTRAINEDSIZE != aReflowState.availSize.BSize(aWM)) {
aReflowState.availSize.BSize(aWM) -= aDesiredSize.BSize(aWM);
}
}
void
nsTableRowGroupFrame::InitChildReflowState(nsPresContext& aPresContext,
bool aBorderCollapse,
- nsHTMLReflowState& aReflowState)
+ ReflowInput& aReflowState)
{
nsMargin collapseBorder;
nsMargin padding(0,0,0,0);
nsMargin* pCollapseBorder = nullptr;
if (aBorderCollapse) {
nsTableRowFrame *rowFrame = do_QueryFrame(aReflowState.frame);
if (rowFrame) {
WritingMode wm = GetWritingMode();
@@ -375,20 +375,20 @@ nsTableRowGroupFrame::ReflowChildren(nsP
aDesiredSize.mFlags);
desiredSize.ClearSize();
// Reflow the child into the available space, giving it as much bsize as
// it wants. We'll deal with splitting later after we've computed the row
// bsizes, taking into account cells with row spans...
LogicalSize kidAvailSize = aReflowState.availSize;
kidAvailSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
- nsHTMLReflowState kidReflowState(aPresContext, aReflowState.reflowState,
+ ReflowInput kidReflowState(aPresContext, aReflowState.reflowState,
kidFrame, kidAvailSize,
nullptr,
- nsHTMLReflowState::CALLER_WILL_INIT);
+ ReflowInput::CALLER_WILL_INIT);
InitChildReflowState(*aPresContext, borderCollapse, kidReflowState);
// This can indicate that columns were resized.
if (aReflowState.reflowState.IsIResize()) {
kidReflowState.SetIResize(true);
}
NS_ASSERTION(kidFrame == mFrames.FirstChild() || prevKidFrame,
@@ -528,17 +528,17 @@ nsTableRowGroupFrame::DidResizeRows(nsHT
// This calculates the bsize of all the rows and takes into account
// style bsize on the row group, style bsizes on rows and cells, style bsizes on rowspans.
// Actual row bsizes will be adjusted later if the table has a style bsize.
// Even if rows don't change bsize, this method must be called to set the bsizes of each
// cell in the row to the bsize of its row.
void
nsTableRowGroupFrame::CalculateRowBSizes(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState)
+ const ReflowInput& aReflowState)
{
nsTableFrame* tableFrame = GetTableFrame();
const bool isPaginated = aPresContext->IsPaginated();
int32_t numEffCols = tableFrame->GetEffectiveColCount();
int32_t startRowIndex = GetStartRowIndex();
// find the row corresponding to the row index we just found
@@ -926,17 +926,17 @@ nsTableRowGroupFrame::CreateContinuingRo
PushChildren(*aContRowFrame, &aRowFrame);
}
// Reflow the cells with rowspan > 1 which originate between aFirstRow
// and end on or after aLastRow. aFirstTruncatedRow is the highest row on the
// page that contains a cell which cannot split on this page
void
nsTableRowGroupFrame::SplitSpanningCells(nsPresContext& aPresContext,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsTableFrame& aTable,
nsTableRowFrame& aFirstRow,
nsTableRowFrame& aLastRow,
bool aFirstRowIsTopOfPage,
nscoord aSpanningRowBEnd,
nsTableRowFrame*& aContRow,
nsTableRowFrame*& aFirstTruncatedRow,
nscoord& aDesiredBSize)
@@ -970,21 +970,21 @@ nsTableRowGroupFrame::SplitSpanningCells
nsRect rowRect = row->GetNormalRect();
nsSize rowAvailSize(aReflowState.AvailableWidth(),
std::max(aReflowState.AvailableHeight() - rowRect.y,
0));
// don't let the available height exceed what
// CalculateRowBSizes set for it
rowAvailSize.height = std::min(rowAvailSize.height, rowRect.height);
- nsHTMLReflowState rowReflowState(&aPresContext, aReflowState, row,
+ ReflowInput rowReflowState(&aPresContext, aReflowState, row,
LogicalSize(row->GetWritingMode(),
rowAvailSize),
nullptr,
- nsHTMLReflowState::CALLER_WILL_INIT);
+ ReflowInput::CALLER_WILL_INIT);
InitChildReflowState(aPresContext, borderCollapse, rowReflowState);
rowReflowState.mFlags.mIsTopOfPage = isTopOfPage; // set top of page
nscoord cellBSize = row->ReflowCellFrame(&aPresContext, rowReflowState,
isTopOfPage, cell,
cellAvailBSize, status);
aDesiredBSize = std::max(aDesiredBSize, rowPos.y + cellBSize);
if (NS_FRAME_IS_COMPLETE(status)) {
@@ -1062,17 +1062,17 @@ GetRowBefore(nsTableRowFrame& aStartRow,
rowBefore = sib;
}
return rowBefore;
}
nsresult
nsTableRowGroupFrame::SplitRowGroup(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsTableFrame* aTableFrame,
nsReflowStatus& aStatus,
bool aRowForcedPageBreak)
{
NS_PRECONDITION(aPresContext->IsPaginated(), "SplitRowGroup currently supports only paged media");
nsTableRowFrame* prevRowFrame = nullptr;
aDesiredSize.Height() = 0;
@@ -1106,21 +1106,21 @@ nsTableRowGroupFrame::SplitRowGroup(nsPr
// Reflow the row in the availabe space and have it split if it is the 1st
// row (on the page) or there is at least 5% of the current page available
// XXX this 5% should be made a preference
if (!prevRowFrame || (availHeight - aDesiredSize.Height() > pageHeight / 20)) {
nsSize availSize(availWidth, std::max(availHeight - rowRect.y, 0));
// don't let the available height exceed what CalculateRowHeights set for it
availSize.height = std::min(availSize.height, rowRect.height);
- nsHTMLReflowState rowReflowState(aPresContext, aReflowState, rowFrame,
+ ReflowInput rowReflowState(aPresContext, aReflowState, rowFrame,
LogicalSize(rowFrame->GetWritingMode(),
availSize),
nullptr,
- nsHTMLReflowState::CALLER_WILL_INIT);
+ ReflowInput::CALLER_WILL_INIT);
InitChildReflowState(*aPresContext, borderCollapse, rowReflowState);
rowReflowState.mFlags.mIsTopOfPage = isTopOfPage; // set top of page
nsHTMLReflowMetrics rowMetrics(aReflowState);
// Get the old size before we reflow.
nsRect oldRowRect = rowFrame->GetRect();
nsRect oldRowVisualOverflow = rowFrame->GetVisualOverflowRect();
@@ -1310,17 +1310,17 @@ nsTableRowGroupFrame::SplitRowGroup(nsPr
/** Layout the entire row group.
* This method stacks rows vertically according to HTML 4.0 rules.
* Rows are responsible for layout of their children.
*/
void
nsTableRowGroupFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsTableRowGroupFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
aStatus = NS_FRAME_COMPLETE;
@@ -1349,22 +1349,22 @@ nsTableRowGroupFrame::Reflow(nsPresConte
// See if all the frames fit. Do not try to split anything if we're
// not paginated ... we can't split across columns yet.
if (aReflowState.mFlags.mTableIsSplittable &&
NS_UNCONSTRAINEDSIZE != aReflowState.AvailableHeight() &&
(NS_FRAME_NOT_COMPLETE == aStatus || splitDueToPageBreak ||
aDesiredSize.Height() > aReflowState.AvailableHeight())) {
// Nope, find a place to split the row group
bool specialReflow = (bool)aReflowState.mFlags.mSpecialBSizeReflow;
- ((nsHTMLReflowState::ReflowStateFlags&)aReflowState.mFlags).mSpecialBSizeReflow = false;
+ ((ReflowInput::ReflowStateFlags&)aReflowState.mFlags).mSpecialBSizeReflow = false;
SplitRowGroup(aPresContext, aDesiredSize, aReflowState, tableFrame, aStatus,
splitDueToPageBreak);
- ((nsHTMLReflowState::ReflowStateFlags&)aReflowState.mFlags).mSpecialBSizeReflow = specialReflow;
+ ((ReflowInput::ReflowStateFlags&)aReflowState.mFlags).mSpecialBSizeReflow = specialReflow;
}
// XXXmats The following is just bogus. We leave it here for now because
// ReflowChildren should pull up rows from our next-in-flow before returning
// a Complete status, but doesn't (bug 804888).
if (GetNextInFlow() && GetNextInFlow()->PrincipalChildList().FirstChild()) {
NS_FRAME_SET_INCOMPLETE(aStatus);
}
@@ -1546,29 +1546,29 @@ nsTableRowGroupFrame::GetUsedBorder() co
/* virtual */ nsMargin
nsTableRowGroupFrame::GetUsedPadding() const
{
return nsMargin(0,0,0,0);
}
nscoord
-nsTableRowGroupFrame::GetBSizeBasis(const nsHTMLReflowState& aReflowState)
+nsTableRowGroupFrame::GetBSizeBasis(const ReflowInput& aReflowState)
{
nscoord result = 0;
nsTableFrame* tableFrame = GetTableFrame();
int32_t startRowIndex = GetStartRowIndex();
if ((aReflowState.ComputedBSize() > 0) && (aReflowState.ComputedBSize() < NS_UNCONSTRAINEDSIZE)) {
nscoord cellSpacing = tableFrame->GetRowSpacing(startRowIndex,
std::max(startRowIndex,
startRowIndex + GetRowCount() - 1));
result = aReflowState.ComputedBSize() - cellSpacing;
}
else {
- const nsHTMLReflowState* parentRS = aReflowState.mParentReflowState;
+ const ReflowInput* parentRS = aReflowState.mParentReflowState;
if (parentRS && (tableFrame != parentRS->frame)) {
parentRS = parentRS->mParentReflowState;
}
if (parentRS && (tableFrame == parentRS->frame) &&
(parentRS->ComputedBSize() > 0) && (parentRS->ComputedBSize() < NS_UNCONSTRAINEDSIZE)) {
nscoord cellSpacing = tableFrame->GetRowSpacing(-1, tableFrame->GetRowCount());
result = parentRS->ComputedBSize() - cellSpacing;
}
--- a/layout/tables/nsTableRowGroupFrame.h
+++ b/layout/tables/nsTableRowGroupFrame.h
@@ -13,29 +13,29 @@
#include "nsTablePainter.h"
#include "nsTArray.h"
#include "nsTableFrame.h"
#include "mozilla/WritingModes.h"
class nsTableRowFrame;
struct nsRowGroupReflowState {
- using nsHTMLReflowState = mozilla::nsHTMLReflowState;
+ using ReflowInput = mozilla::ReflowInput;
- const nsHTMLReflowState& reflowState; // Our reflow state
+ const ReflowInput& reflowState; // Our reflow state
nsTableFrame* tableFrame;
// The available size (computed from the parent)
mozilla::LogicalSize availSize;
// Running block-offset
nscoord bCoord;
- nsRowGroupReflowState(const nsHTMLReflowState& aReflowState,
+ nsRowGroupReflowState(const ReflowInput& aReflowState,
nsTableFrame* aTableFrame)
: reflowState(aReflowState)
, tableFrame(aTableFrame)
, availSize(aReflowState.GetWritingMode(),
aReflowState.AvailableISize(),
aReflowState.AvailableBSize())
, bCoord(0)
{
@@ -107,17 +107,17 @@ public:
*
* @param aDesiredSize isize set to isize of rows, bsize set to
* sum of bsize of rows that fit in AvailableBSize.
*
* @see nsIFrame::Reflow
*/
virtual void Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsReflowStatus& aStatus) override;
virtual bool ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas) override;
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::tableRowGroupFrame
@@ -158,17 +158,17 @@ public:
* that was repeated
*/
nsresult InitRepeatedFrame(nsTableRowGroupFrame* aHeaderFooterFrame);
/**
* Get the total bsize of all the row rects
*/
- nscoord GetBSizeBasis(const nsHTMLReflowState& aReflowState);
+ nscoord GetBSizeBasis(const ReflowInput& aReflowState);
mozilla::LogicalMargin GetBCBorderWidth(mozilla::WritingMode aWM);
/**
* Gets inner border widths before collapsing with cell borders
* Caller must get bstart border from previous row group or from table
* GetContinuousBCBorderWidth will not overwrite aBorder.BStart()
* see nsTablePainter about continuous borders
@@ -342,33 +342,33 @@ public:
virtual void InvalidateFrameWithRect(const nsRect& aRect, uint32_t aDisplayItemKey = 0) override;
virtual void InvalidateFrameForRemoval() override { InvalidateFrameSubtree(); }
protected:
explicit nsTableRowGroupFrame(nsStyleContext* aContext);
void InitChildReflowState(nsPresContext& aPresContext,
bool aBorderCollapse,
- nsHTMLReflowState& aReflowState);
+ ReflowInput& aReflowState);
- virtual LogicalSides GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const override;
+ virtual LogicalSides GetLogicalSkipSides(const ReflowInput* aReflowState = nullptr) const override;
void PlaceChild(nsPresContext* aPresContext,
nsRowGroupReflowState& aReflowState,
nsIFrame* aKidFrame,
mozilla::WritingMode aWM,
const mozilla::LogicalPoint& aKidPosition,
const nsSize& aContainerSize,
nsHTMLReflowMetrics& aDesiredSize,
const nsRect& aOriginalKidRect,
const nsRect& aOriginalKidVisualOverflow);
void CalculateRowBSizes(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState);
+ const ReflowInput& aReflowState);
void DidResizeRows(nsHTMLReflowMetrics& aDesiredSize);
void SlideChild(nsRowGroupReflowState& aReflowState,
nsIFrame* aKidFrame);
/**
* Reflow the frames we've already created
@@ -379,23 +379,23 @@ protected:
void ReflowChildren(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
nsRowGroupReflowState& aReflowState,
nsReflowStatus& aStatus,
bool* aPageBreakBeforeEnd = nullptr);
nsresult SplitRowGroup(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsTableFrame* aTableFrame,
nsReflowStatus& aStatus,
bool aRowForcedPageBreak);
void SplitSpanningCells(nsPresContext& aPresContext,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsTableFrame& aTableFrame,
nsTableRowFrame& aFirstRow,
nsTableRowFrame& aLastRow,
bool aFirstRowIsTopOfPage,
nscoord aSpanningRowBottom,
nsTableRowFrame*& aContRowFrame,
nsTableRowFrame*& aFirstTruncatedRow,
nscoord& aDesiredHeight);
--- a/layout/tables/nsTableWrapperFrame.cpp
+++ b/layout/tables/nsTableWrapperFrame.cpp
@@ -224,64 +224,64 @@ nsTableWrapperFrame::GetParentStyleConte
return (*aProviderFrame = InnerTableFrame())->StyleContext();
}
// INCREMENTAL REFLOW HELPER FUNCTIONS
void
nsTableWrapperFrame::InitChildReflowState(nsPresContext& aPresContext,
- nsHTMLReflowState& aReflowState)
+ ReflowInput& aReflowState)
{
nsMargin collapseBorder;
nsMargin collapsePadding(0,0,0,0);
nsMargin* pCollapseBorder = nullptr;
nsMargin* pCollapsePadding = nullptr;
if (aReflowState.frame == InnerTableFrame() &&
InnerTableFrame()->IsBorderCollapse()) {
WritingMode wm = aReflowState.GetWritingMode();
LogicalMargin border = InnerTableFrame()->GetIncludedOuterBCBorder(wm);
collapseBorder = border.GetPhysicalMargin(wm);
pCollapseBorder = &collapseBorder;
pCollapsePadding = &collapsePadding;
}
aReflowState.Init(&aPresContext, nullptr, pCollapseBorder, pCollapsePadding);
}
-// get the margin and padding data. nsHTMLReflowState doesn't handle the
+// get the margin and padding data. ReflowInput doesn't handle the
// case of auto margins
void
nsTableWrapperFrame::GetChildMargin(nsPresContext* aPresContext,
- const nsHTMLReflowState& aOuterRS,
+ const ReflowInput& aOuterRS,
nsIFrame* aChildFrame,
nscoord aAvailISize,
LogicalMargin& aMargin)
{
NS_ASSERTION(!aChildFrame->IsTableCaption(),
"didn't expect caption frame; writing-mode may be wrong!");
// construct a reflow state to compute margin and padding. Auto margins
// will not be computed at this time.
// create and init the child reflow state
// XXX We really shouldn't construct a reflow state to do this.
WritingMode wm = aOuterRS.GetWritingMode();
LogicalSize availSize(wm, aAvailISize, aOuterRS.AvailableSize(wm).BSize(wm));
- nsHTMLReflowState childRS(aPresContext, aOuterRS, aChildFrame, availSize,
- nullptr, nsHTMLReflowState::CALLER_WILL_INIT);
+ ReflowInput childRS(aPresContext, aOuterRS, aChildFrame, availSize,
+ nullptr, ReflowInput::CALLER_WILL_INIT);
InitChildReflowState(*aPresContext, childRS);
aMargin = childRS.ComputedLogicalMargin();
}
static nsSize
-GetContainingBlockSize(const nsHTMLReflowState& aOuterRS)
+GetContainingBlockSize(const ReflowInput& aOuterRS)
{
nsSize size(0,0);
- const nsHTMLReflowState* containRS = aOuterRS.mCBReflowState;
+ const ReflowInput* containRS = aOuterRS.mCBReflowState;
if (containRS) {
size.width = containRS->ComputedWidth();
if (NS_UNCONSTRAINEDSIZE == size.width) {
size.width = 0;
}
size.height = containRS->ComputedHeight();
if (NS_UNCONSTRAINEDSIZE == size.height) {
@@ -727,18 +727,18 @@ nsTableWrapperFrame::GetInnerOrigin(uint
break;
}
return NS_OK;
}
void
nsTableWrapperFrame::OuterBeginReflowChild(nsPresContext* aPresContext,
nsIFrame* aChildFrame,
- const nsHTMLReflowState& aOuterRS,
- Maybe<nsHTMLReflowState>& aChildRS,
+ const ReflowInput& aOuterRS,
+ Maybe<ReflowInput>& aChildRS,
nscoord aAvailISize)
{
// work around pixel rounding errors, round down to ensure we don't exceed the avail height in
WritingMode wm = aChildFrame->GetWritingMode();
LogicalSize outerSize = aOuterRS.AvailableSize(wm);
nscoord availBSize = outerSize.BSize(wm);
if (NS_UNCONSTRAINEDSIZE != availBSize) {
if (mCaptionFrames.FirstChild() == aChildFrame) {
@@ -756,34 +756,34 @@ nsTableWrapperFrame::OuterBeginReflowChi
"No unconstrainedsize arithmetic, please");
availBSize -= margin.BEnd(wm);
}
}
LogicalSize availSize(wm, aAvailISize, availBSize);
// create and init the child reflow state, using passed-in Maybe<>,
// so that caller can use it after we return.
aChildRS.emplace(aPresContext, aOuterRS, aChildFrame, availSize,
- nullptr, nsHTMLReflowState::CALLER_WILL_INIT);
+ nullptr, ReflowInput::CALLER_WILL_INIT);
InitChildReflowState(*aPresContext, *aChildRS);
// see if we need to reset top-of-page due to a caption
if (aChildRS->mFlags.mIsTopOfPage &&
mCaptionFrames.FirstChild() == aChildFrame) {
uint8_t captionSide = GetCaptionSide();
if (captionSide == NS_STYLE_CAPTION_SIDE_BOTTOM ||
captionSide == NS_STYLE_CAPTION_SIDE_BOTTOM_OUTSIDE) {
aChildRS->mFlags.mIsTopOfPage = false;
}
}
}
void
nsTableWrapperFrame::OuterDoReflowChild(nsPresContext* aPresContext,
nsIFrame* aChildFrame,
- const nsHTMLReflowState& aChildRS,
+ const ReflowInput& aChildRS,
nsHTMLReflowMetrics& aMetrics,
nsReflowStatus& aStatus)
{
// Using zero as containerSize here because we want consistency between
// the GetLogicalPosition and ReflowChild calls, to avoid unnecessarily
// changing the frame's coordinates; but we don't yet know its final
// position anyway so the actual value is unimportant.
const nsSize zeroCSize;
@@ -814,35 +814,35 @@ nsTableWrapperFrame::UpdateOverflowAreas
if (mCaptionFrames.NotEmpty()) {
ConsiderChildOverflow(aMet.mOverflowAreas, mCaptionFrames.FirstChild());
}
}
void
nsTableWrapperFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aOuterRS,
+ const ReflowInput& aOuterRS,
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsTableWrapperFrame");
DISPLAY_REFLOW(aPresContext, this, aOuterRS, aDesiredSize, aStatus);
// Initialize out parameters
aDesiredSize.ClearSize();
aStatus = NS_FRAME_COMPLETE;
if (!HasAnyStateBits(NS_FRAME_FIRST_REFLOW)) {
// Set up our kids. They're already present, on an overflow list,
// or there are none so we'll create them now
MoveOverflowToChildList();
}
- Maybe<nsHTMLReflowState> captionRS;
- Maybe<nsHTMLReflowState> innerRS;
+ Maybe<ReflowInput> captionRS;
+ Maybe<ReflowInput> innerRS;
nsRect origInnerRect = InnerTableFrame()->GetRect();
nsRect origInnerVisualOverflow = InnerTableFrame()->GetVisualOverflowRect();
bool innerFirstReflow =
InnerTableFrame()->HasAnyStateBits(NS_FRAME_FIRST_REFLOW);
nsRect origCaptionRect;
nsRect origCaptionVisualOverflow;
bool captionFirstReflow;
--- a/layout/tables/nsTableWrapperFrame.h
+++ b/layout/tables/nsTableWrapperFrame.h
@@ -81,17 +81,17 @@ public:
const mozilla::LogicalSize& aPadding,
bool aShrinkWrap) override;
/** process a reflow command for the table.
* This involves reflowing the caption and the inner table.
* @see nsIFrame::Reflow */
virtual void Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsReflowStatus& aStatus) override;
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::tableWrapperFrame
*/
virtual nsIAtom* GetType() const override;
@@ -181,17 +181,17 @@ public:
protected:
explicit nsTableWrapperFrame(nsStyleContext* aContext);
virtual ~nsTableWrapperFrame();
void InitChildReflowState(nsPresContext& aPresContext,
- nsHTMLReflowState& aReflowState);
+ ReflowInput& aReflowState);
// Get a NS_STYLE_CAPTION_SIDE_* value, or NO_SIDE if no caption is present.
// (Remember that caption-side values are interpreted logically, despite
// having "physical" names.)
uint8_t GetCaptionSide();
bool HasSideCaption() {
uint8_t captionSide = GetCaptionSide();
@@ -226,32 +226,32 @@ protected:
const mozilla::LogicalSize& aInnerSize,
mozilla::LogicalMargin& aInnerMargin,
mozilla::LogicalPoint& aOrigin,
mozilla::WritingMode aWM);
// reflow the child (caption or innertable frame)
void OuterBeginReflowChild(nsPresContext* aPresContext,
nsIFrame* aChildFrame,
- const nsHTMLReflowState& aOuterRS,
- mozilla::Maybe<nsHTMLReflowState>& aChildRS,
+ const ReflowInput& aOuterRS,
+ mozilla::Maybe<ReflowInput>& aChildRS,
nscoord aAvailISize);
void OuterDoReflowChild(nsPresContext* aPresContext,
nsIFrame* aChildFrame,
- const nsHTMLReflowState& aChildRS,
+ const ReflowInput& aChildRS,
nsHTMLReflowMetrics& aMetrics,
nsReflowStatus& aStatus);
// Set the overflow areas in our reflow metrics
void UpdateOverflowAreas(nsHTMLReflowMetrics& aMet);
// Get the margin.
void GetChildMargin(nsPresContext* aPresContext,
- const nsHTMLReflowState& aOuterRS,
+ const ReflowInput& aOuterRS,
nsIFrame* aChildFrame,
nscoord aAvailableWidth,
mozilla::LogicalMargin& aMargin);
virtual bool IsFrameOfType(uint32_t aFlags) const override
{
return nsContainerFrame::IsFrameOfType(aFlags &
(~eCanContainOverflowContainers));
--- a/layout/xul/nsBox.cpp
+++ b/layout/xul/nsBox.cpp
@@ -130,24 +130,24 @@ nsBox::BeginXULLayout(nsBoxLayoutState&
// mark ourselves as dirty so no child under us
// can post an incremental layout.
// XXXldb Is this still needed?
mState |= NS_FRAME_HAS_DIRTY_CHILDREN;
if (GetStateBits() & NS_FRAME_IS_DIRTY)
{
- // If the parent is dirty, all the children are dirty (nsHTMLReflowState
+ // If the parent is dirty, all the children are dirty (ReflowInput
// does this too).
nsIFrame* box;
for (box = GetChildXULBox(this); box; box = GetNextXULBox(box))
box->AddStateBits(NS_FRAME_IS_DIRTY);
}
- // Another copy-over from nsHTMLReflowState.
+ // Another copy-over from ReflowInput.
// Since we are in reflow, we don't need to store these properties anymore.
FrameProperties props = Properties();
props.Delete(UsedBorderProperty());
props.Delete(UsedPaddingProperty());
props.Delete(UsedMarginProperty());
#ifdef DEBUG_LAYOUT
PropagateDebug(aState);
--- a/layout/xul/nsBoxFrame.cpp
+++ b/layout/xul/nsBoxFrame.cpp
@@ -549,17 +549,17 @@ nsBoxFrame::GetInitialAutoStretch(bool&
const nsStyleXUL* boxInfo = StyleXUL();
aStretch = (boxInfo->mBoxAlign == NS_STYLE_BOX_ALIGN_STRETCH);
return true;
}
void
nsBoxFrame::DidReflow(nsPresContext* aPresContext,
- const nsHTMLReflowState* aReflowState,
+ const ReflowInput* aReflowState,
nsDidReflowStatus aStatus)
{
nsFrameState preserveBits =
mState & (NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN);
nsFrame::DidReflow(aPresContext, aReflowState, aStatus);
mState |= preserveBits;
}
@@ -625,17 +625,17 @@ nsBoxFrame::GetPrefISize(nsRenderingCont
result = std::max(result, 0);
return result;
}
void
nsBoxFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsReflowStatus& aStatus)
{
MarkInReflow();
// If you make changes to this method, please keep nsLeafBoxFrame::Reflow
// in sync, if the changes are applicable there.
DO_GLOBAL_REFLOW_COUNT("nsBoxFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
@@ -913,17 +913,17 @@ nsBoxFrame::DoXULLayout(nsBoxLayoutState
rv = mLayoutManager->XULLayout(this, aState);
}
aState.SetLayoutFlags(oldFlags);
if (HasAbsolutelyPositionedChildren()) {
// Set up a |reflowState| to pass into ReflowAbsoluteFrames
WritingMode wm = GetWritingMode();
- nsHTMLReflowState reflowState(aState.PresContext(), this,
+ ReflowInput reflowState(aState.PresContext(), this,
aState.GetRenderingContext(),
LogicalSize(wm, GetLogicalSize().ISize(wm),
NS_UNCONSTRAINEDSIZE));
// Set up a |desiredSize| to pass into ReflowAbsoluteFrames
nsHTMLReflowMetrics desiredSize(reflowState);
desiredSize.Width() = mRect.width;
desiredSize.Height() = mRect.height;
--- a/layout/xul/nsBoxFrame.h
+++ b/layout/xul/nsBoxFrame.h
@@ -90,17 +90,17 @@ public:
int32_t aModType) override;
virtual void MarkIntrinsicISizesDirty() 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 SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) override;
virtual void AppendFrames(ChildListID aListID,
nsFrameList& aFrameList) override;
virtual void InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
@@ -119,29 +119,29 @@ public:
// record that children that are ignorable whitespace should be excluded
// (When content was loaded via the XUL content sink, it's already
// been excluded, but we need this for when the XUL namespace is used
// in other MIME types or when the XUL CSS display types are used with
// non-XUL elements.)
// This is bogus, but it's what we've always done.
// (Given that we're replaced, we need to say we're a replaced element
- // that contains a block so nsHTMLReflowState doesn't tell us to be
+ // that contains a block so ReflowInput doesn't tell us to be
// NS_INTRINSICSIZE wide.)
return nsContainerFrame::IsFrameOfType(aFlags &
~(nsIFrame::eReplaced | nsIFrame::eReplacedContainsBlock | eXULBox |
nsIFrame::eExcludesIgnorableWhitespace));
}
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const override;
#endif
virtual void DidReflow(nsPresContext* aPresContext,
- const nsHTMLReflowState* aReflowState,
+ const ReflowInput* aReflowState,
nsDidReflowStatus aStatus) override;
virtual bool HonorPrintBackgroundSettings() override;
virtual ~nsBoxFrame();
explicit nsBoxFrame(nsStyleContext* aContext, bool aIsRoot = false, nsBoxLayout* aLayoutManager = nullptr);
--- a/layout/xul/nsBoxLayoutState.cpp
+++ b/layout/xul/nsBoxLayoutState.cpp
@@ -9,17 +9,17 @@
//
// See documentation in associated header file
//
#include "nsBoxLayoutState.h"
nsBoxLayoutState::nsBoxLayoutState(nsPresContext* aPresContext,
nsRenderingContext* aRenderingContext,
- const nsHTMLReflowState* aOuterReflowState,
+ const ReflowInput* aOuterReflowState,
uint16_t aReflowDepth)
: mPresContext(aPresContext)
, mRenderingContext(aRenderingContext)
, mOuterReflowState(aOuterReflowState)
, mLayoutFlags(0)
, mReflowDepth(aReflowDepth)
, mPaintingDisabled(false)
{
--- a/layout/xul/nsBoxLayoutState.h
+++ b/layout/xul/nsBoxLayoutState.h
@@ -14,29 +14,29 @@
#define nsBoxLayoutState_h___
#include "nsCOMPtr.h"
#include "nsPresContext.h"
#include "nsIPresShell.h"
class nsRenderingContext;
namespace mozilla {
-struct nsHTMLReflowState;
+struct ReflowInput;
} // namespace mozilla
class MOZ_STACK_CLASS nsBoxLayoutState
{
- using nsHTMLReflowState = mozilla::nsHTMLReflowState;
+ using ReflowInput = mozilla::ReflowInput;
public:
explicit nsBoxLayoutState(nsPresContext* aPresContext,
nsRenderingContext* aRenderingContext = nullptr,
// see OuterReflowState() below
- const nsHTMLReflowState* aOuterReflowState = nullptr,
+ const ReflowInput* aOuterReflowState = nullptr,
uint16_t aReflowDepth = 0);
nsBoxLayoutState(const nsBoxLayoutState& aState);
nsPresContext* PresContext() const { return mPresContext; }
nsIPresShell* PresShell() const { return mPresContext->PresShell(); }
uint32_t LayoutFlags() const { return mLayoutFlags; }
void SetLayoutFlags(uint32_t aFlags) { mLayoutFlags = aFlags; }
@@ -55,23 +55,23 @@ public:
explicit AutoReflowDepth(nsBoxLayoutState& aState)
: mState(aState) { ++mState.mReflowDepth; }
~AutoReflowDepth() { --mState.mReflowDepth; }
nsBoxLayoutState& mState;
};
// The HTML reflow state that lives outside the box-block boundary.
// May not be set reliably yet.
- const nsHTMLReflowState* OuterReflowState() { return mOuterReflowState; }
+ const ReflowInput* OuterReflowState() { return mOuterReflowState; }
uint16_t GetReflowDepth() { return mReflowDepth; }
private:
RefPtr<nsPresContext> mPresContext;
nsRenderingContext *mRenderingContext;
- const nsHTMLReflowState *mOuterReflowState;
+ const ReflowInput *mOuterReflowState;
uint32_t mLayoutFlags;
uint16_t mReflowDepth;
bool mPaintingDisabled;
};
#endif
--- a/layout/xul/nsLeafBoxFrame.cpp
+++ b/layout/xul/nsLeafBoxFrame.cpp
@@ -188,17 +188,17 @@ nsLeafBoxFrame::ComputeAutoSize(nsRender
return nsFrame::ComputeAutoSize(aRenderingContext, aWM,
aCBSize, aAvailableISize,
aMargin, aBorder, aPadding, aShrinkWrap);
}
void
nsLeafBoxFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsReflowStatus& aStatus)
{
// This is mostly a copy of nsBoxFrame::Reflow().
// We aren't able to share an implementation because of the frame
// class hierarchy. If you make changes here, please keep
// nsBoxFrame::Reflow in sync.
MarkInReflow();
--- a/layout/xul/nsLeafBoxFrame.h
+++ b/layout/xul/nsLeafBoxFrame.h
@@ -49,17 +49,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 nsresult CharacterDataChanged(CharacterDataChangeInfo* aInfo) override;
virtual void Init(nsIContent* aContent,
nsContainerFrame* aParent,
nsIFrame* asPrevInFlow) override;
--- a/layout/xul/nsRootBoxFrame.cpp
+++ b/layout/xul/nsRootBoxFrame.cpp
@@ -63,17 +63,17 @@ public:
virtual void InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList) override;
virtual void RemoveFrame(ChildListID aListID,
nsIFrame* aOldFrame) override;
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 void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) override;
@@ -157,17 +157,17 @@ nsRootBoxFrame::RemoveFrame(ChildListID
#ifdef DEBUG_REFLOW
int32_t gReflows = 0;
#endif
void
nsRootBoxFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsRootBoxFrame");
#ifdef DEBUG_REFLOW
gReflows++;
printf("----Reflow %d----\n", gReflows);
#endif
--- a/layout/xul/nsScrollbarFrame.cpp
+++ b/layout/xul/nsScrollbarFrame.cpp
@@ -52,17 +52,17 @@ nsScrollbarFrame::Init(nsIContent*
// move the slider and will thus not change anything outside of the
// scrollbar or change the size of the scrollbar frame.
mState |= NS_FRAME_REFLOW_ROOT;
}
void
nsScrollbarFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsReflowStatus& aStatus)
{
nsBoxFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
// nsGfxScrollFrame may have told us to shrink to nothing. If so, make sure our
// desired size agrees.
if (aReflowState.AvailableWidth() == 0) {
aDesiredSize.Width() = 0;
--- a/layout/xul/nsScrollbarFrame.h
+++ b/layout/xul/nsScrollbarFrame.h
@@ -57,17 +57,17 @@ public:
nsEventStatus* aEventStatus) override;
virtual void Init(nsIContent* aContent,
nsContainerFrame* aParent,
nsIFrame* aPrevInFlow) override;
virtual void Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
+ const ReflowInput& aReflowState,
nsReflowStatus& aStatus) override;
virtual nsIAtom* GetType() const override;
void SetScrollbarMediatorContent(nsIContent* aMediator);
nsIScrollbarMediator* GetScrollbarMediator();
// nsBox methods