--- a/layout/generic/nsContainerFrame.cpp
+++ b/layout/generic/nsContainerFrame.cpp
@@ -693,17 +693,17 @@ nsContainerFrame::SyncWindowProperties(n
return;
if (!weak.IsAlive()) {
return;
}
nsBoxLayoutState aState(aPresContext, aRC);
nsSize minSize = rootFrame->GetXULMinSize(aState);
- nsSize maxSize = rootFrame->GetMaxSize(aState);
+ nsSize maxSize = rootFrame->GetXULMaxSize(aState);
SetSizeConstraints(aPresContext, windowWidget, minSize, maxSize);
#endif
}
void nsContainerFrame::SetSizeConstraints(nsPresContext* aPresContext,
nsIWidget* aWidget,
const nsSize& aMinSize,
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -8759,31 +8759,31 @@ nsFrame::GetXULMinSize(nsBoxLayoutState&
size.height = blockSize.height;
}
metrics->mMinSize = size;
return size;
}
nsSize
-nsFrame::GetMaxSize(nsBoxLayoutState& aState)
+nsFrame::GetXULMaxSize(nsBoxLayoutState& aState)
{
nsSize size(NS_INTRINSICSIZE, NS_INTRINSICSIZE);
DISPLAY_MAX_SIZE(this, size);
// Don't use the cache if we have HTMLReflowState constraints --- they might have changed
nsBoxLayoutMetrics *metrics = BoxMetrics();
if (!DoesNeedRecalc(metrics->mMaxSize)) {
size = metrics->mMaxSize;
return size;
}
if (IsCollapsed())
return size;
- size = nsBox::GetMaxSize(aState);
+ size = nsBox::GetXULMaxSize(aState);
metrics->mMaxSize = size;
return size;
}
nscoord
nsFrame::GetFlex()
{
--- a/layout/generic/nsFrame.h
+++ b/layout/generic/nsFrame.h
@@ -405,17 +405,17 @@ public:
// Helper for GetContentAndOffsetsFromPoint; calculation of content offsets
// in this function assumes there is no child frame that can be targeted.
virtual ContentOffsets CalcContentOffsetsFromFramePoint(nsPoint aPoint);
// Box layout methods
virtual nsSize GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) override;
virtual nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) override;
- virtual nsSize GetMaxSize(nsBoxLayoutState& aBoxLayoutState) override;
+ virtual nsSize GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) override;
virtual nscoord GetFlex() override;
virtual nscoord GetBoxAscent(nsBoxLayoutState& aBoxLayoutState) override;
// We compute and store the HTML content's overflow area. So don't
// try to compute it in the box code.
virtual bool ComputesOwnOverflowArea() override { return true; }
//--------------------------------------------------
--- a/layout/generic/nsGfxScrollFrame.cpp
+++ b/layout/generic/nsGfxScrollFrame.cpp
@@ -1459,17 +1459,17 @@ nsXULScrollFrame::GetXULMinSize(nsBoxLay
AddBorderAndPadding(min);
bool widthSet, heightSet;
nsIFrame::AddCSSMinSize(aState, this, min, widthSet, heightSet);
return min;
}
nsSize
-nsXULScrollFrame::GetMaxSize(nsBoxLayoutState& aState)
+nsXULScrollFrame::GetXULMaxSize(nsBoxLayoutState& aState)
{
#ifdef DEBUG_LAYOUT
PropagateDebug(aState);
#endif
nsSize maxSize(NS_INTRINSICSIZE, NS_INTRINSICSIZE);
AddBorderAndPadding(maxSize);
--- a/layout/generic/nsGfxScrollFrame.h
+++ b/layout/generic/nsGfxScrollFrame.h
@@ -1121,17 +1121,17 @@ public:
// nsIAnonymousContentCreator
virtual nsresult CreateAnonymousContent(nsTArray<ContentInfo>& aElements) override;
virtual void AppendAnonymousContentTo(nsTArray<nsIContent*>& aElements,
uint32_t aFilter) override;
virtual nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) override;
virtual nsSize GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) override;
- virtual nsSize GetMaxSize(nsBoxLayoutState& aBoxLayoutState) override;
+ virtual nsSize GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) override;
virtual nscoord GetBoxAscent(nsBoxLayoutState& aBoxLayoutState) override;
NS_IMETHOD DoLayout(nsBoxLayoutState& aBoxLayoutState) override;
virtual nsresult GetPadding(nsMargin& aPadding) override;
virtual bool GetBorderRadii(const nsSize& aFrameSize, const nsSize& aBorderArea,
Sides aSkipSides, nscoord aRadii[8]) const override {
return mHelper.GetBorderRadii(aFrameSize, aBorderArea, aSkipSides, aRadii);
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -2882,17 +2882,17 @@ public:
*/
virtual nsSize GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) = 0;
/**
* This calculates the maximum size for a box based on its state
* @param[in] aBoxLayoutState The desired state to calculate for
* @return The maximum size
*/
- virtual nsSize GetMaxSize(nsBoxLayoutState& aBoxLayoutState) = 0;
+ virtual nsSize GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) = 0;
/**
* This returns the minimum size for the scroll area if this frame is
* being scrolled. Usually it's (0,0).
*/
virtual nsSize GetMinSizeForScrollArea(nsBoxLayoutState& aBoxLayoutState) = 0;
// Implemented in nsBox, used in nsBoxFrame
--- a/layout/generic/nsPlaceholderFrame.cpp
+++ b/layout/generic/nsPlaceholderFrame.cpp
@@ -49,17 +49,17 @@ nsPlaceholderFrame::GetXULMinSize(nsBoxL
nsPlaceholderFrame::GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState)
{
nsSize size(0, 0);
DISPLAY_PREF_SIZE(this, size);
return size;
}
/* virtual */ nsSize
-nsPlaceholderFrame::GetMaxSize(nsBoxLayoutState& aBoxLayoutState)
+nsPlaceholderFrame::GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState)
{
nsSize size(NS_INTRINSICSIZE, NS_INTRINSICSIZE);
DISPLAY_MAX_SIZE(this, size);
return size;
}
/* virtual */ void
nsPlaceholderFrame::AddInlineMinISize(nsRenderingContext* aRenderingContext,
--- a/layout/generic/nsPlaceholderFrame.h
+++ b/layout/generic/nsPlaceholderFrame.h
@@ -91,17 +91,17 @@ public:
// We need to override GetXULMinSize and GetXULPrefSize because XUL uses
// placeholders not within lines.
virtual void AddInlineMinISize(nsRenderingContext* aRenderingContext,
InlineMinISizeData* aData) override;
virtual void AddInlinePrefISize(nsRenderingContext* aRenderingContext,
InlinePrefISizeData* aData) override;
virtual nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) override;
virtual nsSize GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) override;
- virtual nsSize GetMaxSize(nsBoxLayoutState& aBoxLayoutState) override;
+ virtual nsSize GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) override;
virtual void Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) override;
virtual void DestroyFrom(nsIFrame* aDestructRoot) override;
--- a/layout/xul/grid/nsGrid.cpp
+++ b/layout/xul/grid/nsGrid.cpp
@@ -997,17 +997,17 @@ nsGrid::GetMaxRowHeight(nsBoxLayoutState
child = GetCellAt(i,aIndex);
else
child = GetCellAt(aIndex,i);
// ignore collapsed children
if (!child->IsCollapsed())
{
nsSize min = child->GetXULMinSize(aState);
- nsSize childSize = nsBox::BoundsCheckMinMax(min, child->GetMaxSize(aState));
+ nsSize childSize = nsBox::BoundsCheckMinMax(min, child->GetXULMaxSize(aState));
nsSprocketLayout::AddLargestSize(size, childSize, aIsHorizontal);
}
}
row->mMax = GET_HEIGHT(size, aIsHorizontal) + top + bottom;
return row->mMax;
}
--- a/layout/xul/grid/nsGridCell.cpp
+++ b/layout/xul/grid/nsGridCell.cpp
@@ -82,35 +82,35 @@ nsGridCell::GetXULMinSize(nsBoxLayoutSta
nsBoxLayout::AddLargestSize(sum, min);
}
return sum;
}
nsSize
-nsGridCell::GetMaxSize(nsBoxLayoutState& aState)
+nsGridCell::GetXULMaxSize(nsBoxLayoutState& aState)
{
nsSize sum(NS_INTRINSICSIZE, NS_INTRINSICSIZE);
// take our 2 children and add them up.
// we are as wide as the smallest child plus its left offset
// we are tall as the shortest child plus its top offset
if (mBoxInColumn) {
- nsSize max = mBoxInColumn->GetMaxSize(aState);
+ nsSize max = mBoxInColumn->GetXULMaxSize(aState);
nsBox::AddMargin(mBoxInColumn, max);
nsGridLayout2::AddOffset(mBoxInColumn, max);
nsBoxLayout::AddSmallestSize(sum, max);
}
if (mBoxInRow) {
- nsSize max = mBoxInRow->GetMaxSize(aState);
+ nsSize max = mBoxInRow->GetXULMaxSize(aState);
nsBox::AddMargin(mBoxInRow, max);
nsGridLayout2::AddOffset(mBoxInRow, max);
nsBoxLayout::AddSmallestSize(sum, max);
}
return sum;
--- a/layout/xul/grid/nsGridCell.h
+++ b/layout/xul/grid/nsGridCell.h
@@ -30,17 +30,17 @@ class nsIFrame;
class nsGridCell final
{
public:
nsGridCell();
~nsGridCell();
nsSize GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState);
nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState);
- nsSize GetMaxSize(nsBoxLayoutState& aBoxLayoutState);
+ nsSize GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState);
bool IsCollapsed();
// accessors
nsIFrame* GetBoxInColumn() { return mBoxInColumn; }
nsIFrame* GetBoxInRow() { return mBoxInRow; }
void SetBoxInRow(nsIFrame* aBox) { mBoxInRow = aBox; }
void SetBoxInColumn(nsIFrame* aBox) { mBoxInColumn = aBox; }
--- a/layout/xul/grid/nsGridLayout2.cpp
+++ b/layout/xul/grid/nsGridLayout2.cpp
@@ -166,19 +166,19 @@ nsGridLayout2::GetXULPrefSize(nsIFrame*
AddOffset(aBox, total);
AddLargestSize(pref, total);
}
return pref;
}
nsSize
-nsGridLayout2::GetMaxSize(nsIFrame* aBox, nsBoxLayoutState& aState)
+nsGridLayout2::GetXULMaxSize(nsIFrame* aBox, nsBoxLayoutState& aState)
{
- nsSize maxSize = nsStackLayout::GetMaxSize(aBox, aState);
+ nsSize maxSize = nsStackLayout::GetXULMaxSize(aBox, aState);
// if there are no <rows> tags that will sum up our columns,
// sum up our columns here.
nsSize total(NS_INTRINSICSIZE, NS_INTRINSICSIZE);
nsIFrame* rowsBox = mGrid.GetRowsBox();
nsIFrame* columnsBox = mGrid.GetColumnsBox();
if (!rowsBox || !columnsBox) {
if (!rowsBox) {
--- a/layout/xul/grid/nsGridLayout2.h
+++ b/layout/xul/grid/nsGridLayout2.h
@@ -35,17 +35,17 @@ public:
virtual nsGridRowGroupLayout* CastToRowGroupLayout() override { return nullptr; }
virtual nsGridLayout2* CastToGridLayout() override { return this; }
virtual nsGrid* GetGrid(nsIFrame* aBox, int32_t* aIndex, nsGridRowLayout* aRequestor=nullptr) override;
virtual nsIGridPart* GetParentGridPart(nsIFrame* aBox, nsIFrame** aParentBox) override {
NS_NOTREACHED("Should not be called"); return nullptr;
}
virtual nsSize GetXULMinSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
- virtual nsSize GetMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
+ virtual nsSize GetXULMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
virtual nsSize GetXULPrefSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
virtual void CountRowsColumns(nsIFrame* aBox, int32_t& aRowCount, int32_t& aComputedColumnCount) override { aRowCount++; }
virtual void DirtyRows(nsIFrame* aBox, nsBoxLayoutState& aState) override { }
virtual int32_t BuildRows(nsIFrame* aBox, nsGridRow* aRows) override;
virtual nsMargin GetTotalMargin(nsIFrame* aBox, bool aIsHorizontal) override;
virtual Type GetType() override { return eGrid; }
virtual void ChildrenInserted(nsIFrame* aBox, nsBoxLayoutState& aState,
nsIFrame* aPrevBox,
--- a/layout/xul/grid/nsGridRowGroupLayout.cpp
+++ b/layout/xul/grid/nsGridRowGroupLayout.cpp
@@ -90,19 +90,19 @@ nsGridRowGroupLayout::GetXULPrefSize(nsI
AddWidth(vpref, pref, isHorizontal);
}
}
return vpref;
}
nsSize
-nsGridRowGroupLayout::GetMaxSize(nsIFrame* aBox, nsBoxLayoutState& aState)
+nsGridRowGroupLayout::GetXULMaxSize(nsIFrame* aBox, nsBoxLayoutState& aState)
{
- nsSize maxSize = nsGridRowLayout::GetMaxSize(aBox, aState);
+ nsSize maxSize = nsGridRowLayout::GetXULMaxSize(aBox, aState);
int32_t index = 0;
nsGrid* grid = GetGrid(aBox, &index);
if (grid)
{
// make sure we add in extra columns sizes as well
bool isHorizontal = IsHorizontal(aBox);
--- a/layout/xul/grid/nsGridRowGroupLayout.h
+++ b/layout/xul/grid/nsGridRowGroupLayout.h
@@ -23,17 +23,17 @@ class nsGridRowGroupLayout : public nsGr
{
public:
friend already_AddRefed<nsBoxLayout> NS_NewGridRowGroupLayout();
virtual nsGridRowGroupLayout* CastToRowGroupLayout() override { return this; }
virtual nsSize GetXULMinSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
virtual nsSize GetXULPrefSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
- virtual nsSize GetMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
+ virtual nsSize GetXULMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
virtual void CountRowsColumns(nsIFrame* aBox, int32_t& aRowCount, int32_t& aComputedColumnCount) override;
virtual void DirtyRows(nsIFrame* aBox, nsBoxLayoutState& aState) override;
virtual int32_t BuildRows(nsIFrame* aBox, nsGridRow* aRows) override;
virtual nsMargin GetTotalMargin(nsIFrame* aBox, bool aIsHorizontal) override;
virtual int32_t GetRowCount() override { return mRowCount; }
virtual Type GetType() override { return eRowGroup; }
protected:
--- a/layout/xul/grid/nsGridRowLeafLayout.cpp
+++ b/layout/xul/grid/nsGridRowLeafLayout.cpp
@@ -64,24 +64,24 @@ nsGridRowLeafLayout::GetXULMinSize(nsIFr
else {
nsSize minSize = grid->GetMinRowSize(aState, index, isHorizontal);
AddBorderAndPadding(aBox, minSize);
return minSize;
}
}
nsSize
-nsGridRowLeafLayout::GetMaxSize(nsIFrame* aBox, nsBoxLayoutState& aState)
+nsGridRowLeafLayout::GetXULMaxSize(nsIFrame* aBox, nsBoxLayoutState& aState)
{
int32_t index = 0;
nsGrid* grid = GetGrid(aBox, &index);
bool isHorizontal = IsHorizontal(aBox);
if (!grid)
- return nsGridRowLayout::GetMaxSize(aBox, aState);
+ return nsGridRowLayout::GetXULMaxSize(aBox, aState);
else {
nsSize maxSize;
maxSize = grid->GetMaxRowSize(aState, index, isHorizontal);
AddBorderAndPadding(aBox, maxSize);
return maxSize;
}
}
--- a/layout/xul/grid/nsGridRowLeafLayout.h
+++ b/layout/xul/grid/nsGridRowLeafLayout.h
@@ -25,17 +25,17 @@
class nsGridRowLeafLayout final : public nsGridRowLayout
{
public:
friend already_AddRefed<nsBoxLayout> NS_NewGridRowLeafLayout();
virtual nsSize GetXULPrefSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
virtual nsSize GetXULMinSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
- virtual nsSize GetMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
+ virtual nsSize GetXULMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
virtual void ChildAddedOrRemoved(nsIFrame* aBox, nsBoxLayoutState& aState) override;
NS_IMETHOD Layout(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
virtual void CountRowsColumns(nsIFrame* aBox, int32_t& aRowCount, int32_t& aComputedColumnCount) override;
virtual void DirtyRows(nsIFrame* aBox, nsBoxLayoutState& aState) override;
virtual int32_t BuildRows(nsIFrame* aBox, nsGridRow* aRows) override;
virtual Type GetType() override { return eRowLeaf; }
protected:
--- a/layout/xul/nsBox.cpp
+++ b/layout/xul/nsBox.cpp
@@ -402,17 +402,17 @@ nsBox::GetXULPrefSize(nsBoxLayoutState&
if (IsCollapsed())
return pref;
AddBorderAndPadding(pref);
bool widthSet, heightSet;
nsIFrame::AddCSSPrefSize(this, pref, widthSet, heightSet);
nsSize minSize = GetXULMinSize(aState);
- nsSize maxSize = GetMaxSize(aState);
+ nsSize maxSize = GetXULMaxSize(aState);
return BoundsCheck(minSize, pref, maxSize);
}
nsSize
nsBox::GetXULMinSize(nsBoxLayoutState& aState)
{
NS_ASSERTION(aState.GetRenderingContext(), "must have rendering context");
@@ -430,17 +430,17 @@ nsBox::GetXULMinSize(nsBoxLayoutState& a
nsSize
nsBox::GetMinSizeForScrollArea(nsBoxLayoutState& aBoxLayoutState)
{
return nsSize(0, 0);
}
nsSize
-nsBox::GetMaxSize(nsBoxLayoutState& aState)
+nsBox::GetXULMaxSize(nsBoxLayoutState& aState)
{
NS_ASSERTION(aState.GetRenderingContext(), "must have rendering context");
nsSize maxSize(NS_INTRINSICSIZE, NS_INTRINSICSIZE);
DISPLAY_MAX_SIZE(this, maxSize);
if (IsCollapsed())
return maxSize;
--- a/layout/xul/nsBox.h
+++ b/layout/xul/nsBox.h
@@ -16,17 +16,17 @@ class nsBox : public nsIFrame {
public:
friend class nsIFrame;
static void Shutdown();
virtual nsSize GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) override;
virtual nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) override;
- virtual nsSize GetMaxSize(nsBoxLayoutState& aBoxLayoutState) override;
+ virtual nsSize GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) override;
virtual nscoord GetFlex() override;
virtual nscoord GetBoxAscent(nsBoxLayoutState& aBoxLayoutState) override;
virtual nsSize GetMinSizeForScrollArea(nsBoxLayoutState& aBoxLayoutState) override;
virtual bool IsCollapsed() override;
virtual void SetBounds(nsBoxLayoutState& aBoxLayoutState, const nsRect& aRect,
--- a/layout/xul/nsBoxFrame.cpp
+++ b/layout/xul/nsBoxFrame.cpp
@@ -672,17 +672,17 @@ nsBoxFrame::Reflow(nsPresContext*
LogicalSize prefSize(wm);
// if we are told to layout intrinsic then get our preferred size.
NS_ASSERTION(computedSize.ISize(wm) != NS_INTRINSICSIZE,
"computed inline size should always be computed");
if (computedSize.BSize(wm) == NS_INTRINSICSIZE) {
nsSize physicalPrefSize = GetXULPrefSize(state);
nsSize minSize = GetXULMinSize(state);
- nsSize maxSize = GetMaxSize(state);
+ nsSize maxSize = GetXULMaxSize(state);
// XXXbz isn't GetXULPrefSize supposed to bounds-check for us?
physicalPrefSize = BoundsCheck(minSize, physicalPrefSize, maxSize);
prefSize = LogicalSize(wm, physicalPrefSize);
}
// get our desiredSize
computedSize.ISize(wm) += m.IStart(wm) + m.IEnd(wm);
@@ -774,17 +774,17 @@ nsBoxFrame::GetXULPrefSize(nsBoxLayoutSt
size.height = layoutSize.height;
}
else {
size = nsBox::GetXULPrefSize(aBoxLayoutState);
}
}
nsSize minSize = GetXULMinSize(aBoxLayoutState);
- nsSize maxSize = GetMaxSize(aBoxLayoutState);
+ nsSize maxSize = GetXULMaxSize(aBoxLayoutState);
mPrefSize = BoundsCheck(minSize, size, maxSize);
return mPrefSize;
}
nscoord
nsBoxFrame::GetBoxAscent(nsBoxLayoutState& aBoxLayoutState)
{
@@ -842,17 +842,17 @@ nsBoxFrame::GetXULMinSize(nsBoxLayoutSta
}
mMinSize = size;
return size;
}
nsSize
-nsBoxFrame::GetMaxSize(nsBoxLayoutState& aBoxLayoutState)
+nsBoxFrame::GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState)
{
NS_ASSERTION(aBoxLayoutState.GetRenderingContext(),
"must have rendering context");
nsSize size(NS_INTRINSICSIZE, NS_INTRINSICSIZE);
DISPLAY_MAX_SIZE(this, size);
if (!DoesNeedRecalc(mMaxSize)) {
return mMaxSize;
@@ -865,24 +865,24 @@ nsBoxFrame::GetMaxSize(nsBoxLayoutState&
if (IsCollapsed())
return size;
// if the size was not completely redefined in CSS then ask our children
bool widthSet, heightSet;
if (!nsIFrame::AddCSSMaxSize(this, size, widthSet, heightSet))
{
if (mLayoutManager) {
- nsSize layoutSize = mLayoutManager->GetMaxSize(this, aBoxLayoutState);
+ nsSize layoutSize = mLayoutManager->GetXULMaxSize(this, aBoxLayoutState);
if (!widthSet)
size.width = layoutSize.width;
if (!heightSet)
size.height = layoutSize.height;
}
else {
- size = nsBox::GetMaxSize(aBoxLayoutState);
+ size = nsBox::GetXULMaxSize(aBoxLayoutState);
}
}
mMaxSize = size;
return size;
}
@@ -1783,17 +1783,17 @@ nsBoxFrame::DisplayDebugInfoFor(nsIFrame
bool widthSet, heightSet;
nsIFrame::AddCSSPrefSize(child, prefSizeCSS, widthSet, heightSet);
nsIFrame::AddCSSMinSize (state, child, minSizeCSS, widthSet, heightSet);
nsIFrame::AddCSSMaxSize (child, maxSizeCSS, widthSet, heightSet);
nsIFrame::AddCSSFlex (child, flexCSS);
nsSize prefSize = child->GetXULPrefSize(state);
nsSize minSize = child->GetXULMinSize(state);
- nsSize maxSize = child->GetMaxSize(state);
+ nsSize maxSize = child->GetXULMaxSize(state);
nscoord flexSize = child->GetFlex();
nscoord ascentSize = child->GetBoxAscent(state);
char min[100];
char pref[100];
char max[100];
char calc[100];
char flex[100];
--- a/layout/xul/nsBoxFrame.h
+++ b/layout/xul/nsBoxFrame.h
@@ -58,17 +58,17 @@ public:
virtual void SetLayoutManager(nsBoxLayout* aLayout) override { mLayoutManager = aLayout; }
virtual nsBoxLayout* GetLayoutManager() override { return mLayoutManager; }
virtual nsresult RelayoutChildAtOrdinal(nsIFrame* aChild) override;
virtual nsSize GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) override;
virtual nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) override;
- virtual nsSize GetMaxSize(nsBoxLayoutState& aBoxLayoutState) override;
+ virtual nsSize GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) override;
virtual nscoord GetFlex() override;
virtual nscoord GetBoxAscent(nsBoxLayoutState& aBoxLayoutState) override;
#ifdef DEBUG_LAYOUT
virtual nsresult SetDebug(nsBoxLayoutState& aBoxLayoutState, bool aDebug) override;
virtual nsresult GetDebug(bool& aDebug) override;
#endif
virtual Valignment GetVAlign() const override { return mValign; }
virtual Halignment GetHAlign() const override { return mHalign; }
--- a/layout/xul/nsBoxLayout.cpp
+++ b/layout/xul/nsBoxLayout.cpp
@@ -46,17 +46,17 @@ nsSize
nsBoxLayout::GetXULMinSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState)
{
nsSize minSize (0,0);
AddBorderAndPadding(aBox, minSize);
return minSize;
}
nsSize
-nsBoxLayout::GetMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState)
+nsBoxLayout::GetXULMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState)
{
//AddBorderAndPadding () never changes maxSize (NS_INTRINSICSIZE)
//AddBorderAndPadding(aBox, maxSize);
return nsSize (NS_INTRINSICSIZE,NS_INTRINSICSIZE);
}
nscoord
--- a/layout/xul/nsBoxLayout.h
+++ b/layout/xul/nsBoxLayout.h
@@ -33,17 +33,17 @@ public:
NS_DECL_ISUPPORTS
NS_DECLARE_STATIC_IID_ACCESSOR(NS_BOX_LAYOUT_IID)
NS_IMETHOD Layout(nsIFrame* aBox, nsBoxLayoutState& aState);
virtual nsSize GetXULPrefSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState);
virtual nsSize GetXULMinSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState);
- virtual nsSize GetMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState);
+ virtual nsSize GetXULMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState);
virtual nscoord GetAscent(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState);
virtual void ChildrenInserted(nsIFrame* aBox, nsBoxLayoutState& aState,
nsIFrame* aPrevBox,
const nsFrameList::Slice& aNewChildren) {}
virtual void ChildrenAppended(nsIFrame* aBox, nsBoxLayoutState& aState,
const nsFrameList::Slice& aNewChildren) {}
virtual void ChildrenRemoved(nsIFrame* aBox, nsBoxLayoutState& aState, nsIFrame* aChildList) {}
virtual void ChildrenSet(nsIFrame* aBox, nsBoxLayoutState& aState, nsIFrame* aChildList) {}
--- a/layout/xul/nsImageBoxFrame.cpp
+++ b/layout/xul/nsImageBoxFrame.cpp
@@ -565,17 +565,17 @@ nsImageBoxFrame::GetXULPrefSize(nsBoxLay
size.height += borderPadding.TopBottom();
bool widthSet, heightSet;
nsIFrame::AddCSSPrefSize(this, size, widthSet, heightSet);
NS_ASSERTION(size.width != NS_INTRINSICSIZE && size.height != NS_INTRINSICSIZE,
"non-intrinsic size expected");
nsSize minSize = GetXULMinSize(aState);
- nsSize maxSize = GetMaxSize(aState);
+ nsSize maxSize = GetXULMaxSize(aState);
if (!widthSet && !heightSet) {
if (minSize.width != NS_INTRINSICSIZE)
minSize.width -= borderPadding.LeftRight();
if (minSize.height != NS_INTRINSICSIZE)
minSize.height -= borderPadding.TopBottom();
if (maxSize.width != NS_INTRINSICSIZE)
maxSize.width -= borderPadding.LeftRight();
--- a/layout/xul/nsLeafBoxFrame.cpp
+++ b/layout/xul/nsLeafBoxFrame.cpp
@@ -254,17 +254,17 @@ nsLeafBoxFrame::Reflow(nsPresContext*
}
nsSize prefSize(0,0);
// if we are told to layout intrinic then get our preferred size.
if (computedSize.width == NS_INTRINSICSIZE || computedSize.height == NS_INTRINSICSIZE) {
prefSize = GetXULPrefSize(state);
nsSize minSize = GetXULMinSize(state);
- nsSize maxSize = GetMaxSize(state);
+ nsSize maxSize = GetXULMaxSize(state);
prefSize = BoundsCheck(minSize, prefSize, maxSize);
}
// get our desiredSize
if (aReflowState.ComputedWidth() == NS_INTRINSICSIZE) {
computedSize.width = prefSize.width;
} else {
computedSize.width += m.left + m.right;
@@ -354,19 +354,19 @@ nsLeafBoxFrame::GetXULPrefSize(nsBoxLayo
/* virtual */ nsSize
nsLeafBoxFrame::GetXULMinSize(nsBoxLayoutState& aState)
{
return nsBox::GetXULMinSize(aState);
}
/* virtual */ nsSize
-nsLeafBoxFrame::GetMaxSize(nsBoxLayoutState& aState)
+nsLeafBoxFrame::GetXULMaxSize(nsBoxLayoutState& aState)
{
- return nsBox::GetMaxSize(aState);
+ return nsBox::GetXULMaxSize(aState);
}
/* virtual */ nscoord
nsLeafBoxFrame::GetFlex()
{
return nsBox::GetFlex();
}
--- a/layout/xul/nsLeafBoxFrame.h
+++ b/layout/xul/nsLeafBoxFrame.h
@@ -13,17 +13,17 @@ class nsLeafBoxFrame : public nsLeafFram
{
public:
NS_DECL_FRAMEARENA_HELPERS
friend nsIFrame* NS_NewLeafBoxFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
virtual nsSize GetXULPrefSize(nsBoxLayoutState& aState) override;
virtual nsSize GetXULMinSize(nsBoxLayoutState& aState) override;
- virtual nsSize GetMaxSize(nsBoxLayoutState& aState) override;
+ virtual nsSize GetXULMaxSize(nsBoxLayoutState& aState) override;
virtual nscoord GetFlex() override;
virtual nscoord GetBoxAscent(nsBoxLayoutState& aState) override;
virtual nsIAtom* GetType() const override;
virtual bool IsFrameOfType(uint32_t aFlags) const override
{
// This is bogus, but it's what we've always done.
// Note that nsLeafFrame is also eReplacedContainsBlock.
--- a/layout/xul/nsListBoxLayout.cpp
+++ b/layout/xul/nsListBoxLayout.cpp
@@ -68,19 +68,19 @@ nsListBoxLayout::GetXULMinSize(nsIFrame*
if (width > minSize.width)
minSize.width = width;
}
}
return minSize;
}
nsSize
-nsListBoxLayout::GetMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState)
+nsListBoxLayout::GetXULMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState)
{
- nsSize maxSize = nsGridRowGroupLayout::GetMaxSize(aBox, aBoxLayoutState);
+ nsSize maxSize = nsGridRowGroupLayout::GetXULMaxSize(aBox, aBoxLayoutState);
nsListBoxBodyFrame* frame = static_cast<nsListBoxBodyFrame*>(aBox);
if (frame) {
nscoord rowheight = frame->GetRowHeightAppUnits();
maxSize.height = frame->GetRowCount() * rowheight;
// Pad the height.
nscoord y = frame->GetAvailableHeight();
if (maxSize.height > y && y > 0 && rowheight > 0) {
--- a/layout/xul/nsListBoxLayout.h
+++ b/layout/xul/nsListBoxLayout.h
@@ -17,16 +17,16 @@ class nsListBoxLayout : public nsGridRow
{
public:
nsListBoxLayout();
// nsBoxLayout
NS_IMETHOD Layout(nsIFrame* aBox, nsBoxLayoutState& aState) override;
virtual nsSize GetXULPrefSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
virtual nsSize GetXULMinSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
- virtual nsSize GetMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
+ virtual nsSize GetXULMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
protected:
NS_IMETHOD LayoutInternal(nsIFrame* aBox, nsBoxLayoutState& aState);
};
#endif
--- a/layout/xul/nsMenuFrame.cpp
+++ b/layout/xul/nsMenuFrame.cpp
@@ -1387,17 +1387,17 @@ nsMenuFrame::GetXULPrefSize(nsBoxLayoutS
// If we are using sizetopopup="always" then
// nsBoxFrame will already have enforced the minimum size
if (!IsSizedToPopup(mContent, true) &&
IsSizedToPopup(mContent, false) &&
SizeToPopup(aState, size)) {
// We now need to ensure that size is within the min - max range.
nsSize minSize = nsBoxFrame::GetXULMinSize(aState);
- nsSize maxSize = GetMaxSize(aState);
+ nsSize maxSize = GetXULMaxSize(aState);
size = BoundsCheck(minSize, size, maxSize);
}
return size;
}
NS_IMETHODIMP
nsMenuFrame::GetActiveChild(nsIDOMElement** aResult)
--- a/layout/xul/nsMenuPopupFrame.cpp
+++ b/layout/xul/nsMenuPopupFrame.cpp
@@ -454,17 +454,17 @@ nsMenuPopupFrame::LayoutPopup(nsBoxLayou
}
}
}
// get the preferred, minimum and maximum size. If the menu is sized to the
// popup, then the popup's width is the menu's width.
nsSize prefSize = GetXULPrefSize(aState);
nsSize minSize = GetXULMinSize(aState);
- nsSize maxSize = GetMaxSize(aState);
+ nsSize maxSize = GetXULMaxSize(aState);
if (aSizedToPopup) {
prefSize.width = aParentMenu->GetRect().width;
}
prefSize = BoundsCheck(minSize, prefSize, maxSize);
// if the size changed then set the bounds to be the preferred size
bool sizeChanged = (mPrefSize != prefSize);
--- a/layout/xul/nsSliderFrame.cpp
+++ b/layout/xul/nsSliderFrame.cpp
@@ -1347,20 +1347,20 @@ nsSliderFrame::GetXULMinSize(nsBoxLayout
{
EnsureOrient();
// our min size is just our borders and padding
return nsBox::GetXULMinSize(aState);
}
nsSize
-nsSliderFrame::GetMaxSize(nsBoxLayoutState& aState)
+nsSliderFrame::GetXULMaxSize(nsBoxLayoutState& aState)
{
EnsureOrient();
- return nsBoxFrame::GetMaxSize(aState);
+ return nsBoxFrame::GetXULMaxSize(aState);
}
void
nsSliderFrame::EnsureOrient()
{
nsIFrame* scrollbarBox = GetScrollbar();
bool isHorizontal = (scrollbarBox->GetStateBits() & NS_STATE_IS_HORIZONTAL) != 0;
--- a/layout/xul/nsSliderFrame.h
+++ b/layout/xul/nsSliderFrame.h
@@ -52,17 +52,17 @@ public:
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const override {
return MakeFrameName(NS_LITERAL_STRING("SliderFrame"), aResult);
}
#endif
virtual nsSize GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) override;
virtual nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) override;
- virtual nsSize GetMaxSize(nsBoxLayoutState& aBoxLayoutState) override;
+ virtual nsSize GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) override;
NS_IMETHOD DoLayout(nsBoxLayoutState& aBoxLayoutState) override;
// nsIFrame overrides
virtual void DestroyFrom(nsIFrame* aDestructRoot) override;
virtual void BuildDisplayListForChildren(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) override;
--- a/layout/xul/nsSplitterFrame.cpp
+++ b/layout/xul/nsSplitterFrame.cpp
@@ -665,17 +665,17 @@ nsSplitterFrameInner::MouseDown(nsIDOMEv
nsIDocument* doc = content->OwnerDoc();
int32_t dummy;
nsIAtom* atom = doc->BindingManager()->ResolveTag(content, &dummy);
// skip over any splitters
if (atom != nsGkAtoms::splitter) {
nsSize prefSize = childBox->GetXULPrefSize(state);
nsSize minSize = childBox->GetXULMinSize(state);
- nsSize maxSize = nsBox::BoundsCheckMinMax(minSize, childBox->GetMaxSize(state));
+ nsSize maxSize = nsBox::BoundsCheckMinMax(minSize, childBox->GetXULMaxSize(state));
prefSize = nsBox::BoundsCheck(minSize, prefSize, maxSize);
mOuter->AddMargin(childBox, minSize);
mOuter->AddMargin(childBox, prefSize);
mOuter->AddMargin(childBox, maxSize);
nscoord flex = childBox->GetFlex();
--- a/layout/xul/nsSprocketLayout.cpp
+++ b/layout/xul/nsSprocketLayout.cpp
@@ -317,17 +317,17 @@ nsSprocketLayout::Layout(nsIFrame* aBox,
if (!childBoxSize->bogus) {
// We have a valid box size entry. This entry already contains information about our
// sizes along the axis of the box (e.g., widths in a horizontal box). If our default
// ALIGN is not stretch, however, then we also need to know the child's size along the
// opposite axis.
if (!(frameState & NS_STATE_AUTO_STRETCH)) {
nsSize prefSize = child->GetXULPrefSize(aState);
nsSize minSize = child->GetXULMinSize(aState);
- nsSize maxSize = child->GetMaxSize(aState);
+ nsSize maxSize = child->GetXULMaxSize(aState);
prefSize = nsBox::BoundsCheck(minSize, prefSize, maxSize);
AddMargin(child, prefSize);
width = std::min(prefSize.width, originalClientRect.width);
height = std::min(prefSize.height, originalClientRect.height);
}
}
@@ -458,17 +458,17 @@ nsSprocketLayout::Layout(nsIFrame* aBox,
child->SetBounds(aState, childRect);
bool sizeChanged = (childRect.width != oldRect.width ||
childRect.height != oldRect.height);
if (sizeChanged) {
// Our size is different. Sanity check against our maximum allowed size to ensure
// we didn't exceed it.
nsSize minSize = child->GetXULMinSize(aState);
- nsSize maxSize = child->GetMaxSize(aState);
+ nsSize maxSize = child->GetXULMaxSize(aState);
maxSize = nsBox::BoundsCheckMinMax(minSize, maxSize);
// make sure the size is in our max size.
if (childRect.width > maxSize.width)
childRect.width = maxSize.width;
if (childRect.height > maxSize.height)
childRect.height = maxSize.height;
@@ -741,17 +741,17 @@ nsSprocketLayout::PopulateBoxSizes(nsIFr
if (!collapsed) {
// only one flexible child? Cool we will just make its preferred size
// 0 then and not even have to ask for it.
//if (flexes != 1) {
pref = child->GetXULPrefSize(aState);
minSize = child->GetXULMinSize(aState);
- maxSize = nsBox::BoundsCheckMinMax(minSize, child->GetMaxSize(aState));
+ maxSize = nsBox::BoundsCheckMinMax(minSize, child->GetXULMaxSize(aState));
ascent = child->GetBoxAscent(aState);
nsMargin margin;
child->GetMargin(margin);
ascent += margin.top;
//}
pref = nsBox::BoundsCheck(minSize, pref, maxSize);
@@ -1041,17 +1041,17 @@ nsSprocketLayout::ChildResized(nsIFrame*
// if we are a horizontal box see if the child will fit inside us.
if ( childActualHeight > containingHeight) {
// if we are a horizontal box and the child is bigger than our height
// ok if the height changed then we need to reflow everyone but us at the new height
// so we will set the changed index to be us. And signal that we need a new pass.
nsSize min = aChild->GetXULMinSize(aState);
- nsSize max = nsBox::BoundsCheckMinMax(min, aChild->GetMaxSize(aState));
+ nsSize max = nsBox::BoundsCheckMinMax(min, aChild->GetXULMaxSize(aState));
AddMargin(aChild, max);
if (isHorizontal)
childActualHeight = max.height < childActualHeight ? max.height : childActualHeight;
else
childActualHeight = max.width < childActualHeight ? max.width : childActualHeight;
// only set if it changes
@@ -1076,17 +1076,17 @@ nsSprocketLayout::ChildResized(nsIFrame*
}
}
}
}
if (childActualWidth > childLayoutWidth) {
nsSize min = aChild->GetXULMinSize(aState);
- nsSize max = nsBox::BoundsCheckMinMax(min, aChild->GetMaxSize(aState));
+ nsSize max = nsBox::BoundsCheckMinMax(min, aChild->GetXULMaxSize(aState));
AddMargin(aChild, max);
// our width now becomes the new size
if (isHorizontal)
childActualWidth = max.width < childActualWidth ? max.width : childActualWidth;
else
@@ -1424,17 +1424,17 @@ nsSprocketLayout::GetXULMinSize(nsIFrame
// now add our border and padding
AddBorderAndPadding(aBox, minSize);
return minSize;
}
nsSize
-nsSprocketLayout::GetMaxSize(nsIFrame* aBox, nsBoxLayoutState& aState)
+nsSprocketLayout::GetXULMaxSize(nsIFrame* aBox, nsBoxLayoutState& aState)
{
bool isHorizontal = IsHorizontal(aBox);
nscoord smallestMax = NS_INTRINSICSIZE;
nsSize maxSize (NS_INTRINSICSIZE, NS_INTRINSICSIZE);
// run through all the children and get their min, max, and preferred sizes
@@ -1448,17 +1448,17 @@ nsSprocketLayout::GetMaxSize(nsIFrame* a
while (child)
{
// ignore collapsed children
if (!child->IsCollapsed())
{
// if completely redefined don't even ask our child for its size.
nsSize min = child->GetXULMinSize(aState);
- nsSize max = nsBox::BoundsCheckMinMax(min, child->GetMaxSize(aState));
+ nsSize max = nsBox::BoundsCheckMinMax(min, child->GetXULMaxSize(aState));
AddMargin(child, max);
AddSmallestSize(maxSize, max, isHorizontal);
if (isEqual) {
if (isHorizontal)
{
if (max.width < smallestMax)
--- a/layout/xul/nsSprocketLayout.h
+++ b/layout/xul/nsSprocketLayout.h
@@ -67,17 +67,17 @@ public:
friend nsresult NS_NewSprocketLayout(nsCOMPtr<nsBoxLayout>& aNewLayout);
static void Shutdown();
NS_IMETHOD Layout(nsIFrame* aBox, nsBoxLayoutState& aState) override;
virtual nsSize GetXULPrefSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
virtual nsSize GetXULMinSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
- virtual nsSize GetMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
+ virtual nsSize GetXULMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
virtual nscoord GetAscent(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
nsSprocketLayout();
static bool IsHorizontal(nsIFrame* aBox);
static void SetLargestSize(nsSize& aSize1, const nsSize& aSize2, bool aIsHorizontal);
static void SetSmallestSize(nsSize& aSize1, const nsSize& aSize2, bool aIsHorizontal);
--- a/layout/xul/nsStackLayout.cpp
+++ b/layout/xul/nsStackLayout.cpp
@@ -106,25 +106,25 @@ nsStackLayout::GetXULMinSize(nsIFrame* a
}
AddBorderAndPadding(aBox, minSize);
return minSize;
}
nsSize
-nsStackLayout::GetMaxSize(nsIFrame* aBox, nsBoxLayoutState& aState)
+nsStackLayout::GetXULMaxSize(nsIFrame* aBox, nsBoxLayoutState& aState)
{
nsSize maxSize (NS_INTRINSICSIZE, NS_INTRINSICSIZE);
nsIFrame* child = nsBox::GetChildBox(aBox);
while (child) {
if (child->StyleXUL()->mStretchStack) {
nsSize min = child->GetXULMinSize(aState);
- nsSize max = child->GetMaxSize(aState);
+ nsSize max = child->GetXULMaxSize(aState);
max = nsBox::BoundsCheckMinMax(min, max);
AddMargin(child, max);
nsMargin offset;
GetOffset(child, offset);
max.width += offset.LeftRight();
max.height += offset.TopBottom();
@@ -294,17 +294,17 @@ nsStackLayout::Layout(nsIFrame* aBox, ns
// right only - offset from right edge, preferred width
// left and right - offset from left and right edges, width in between this
// neither - no offset, full width of stack
// Vertical direction is similar.
//
// Margins on the child are also included in the edge offsets
if (offsetSpecified) {
nsSize min = child->GetXULMinSize(aState);
- nsSize max = child->GetMaxSize(aState);
+ nsSize max = child->GetXULMaxSize(aState);
if (offsetSpecified & SPECIFIED_LEFT) {
childRect.x = clientRect.x + offset.left + margin.left;
if (offsetSpecified & SPECIFIED_RIGHT) {
nscoord width = clientRect.width - offset.LeftRight() - margin.LeftRight();
childRect.width = clamped(width, min.width, max.width);
}
else {
nscoord width = child->GetXULPrefSize(aState).width;
--- a/layout/xul/nsStackLayout.h
+++ b/layout/xul/nsStackLayout.h
@@ -31,17 +31,17 @@ public:
static void Shutdown();
nsStackLayout();
NS_IMETHOD Layout(nsIFrame* aBox, nsBoxLayoutState& aState) override;
virtual nsSize GetXULPrefSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
virtual nsSize GetXULMinSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
- virtual nsSize GetMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
+ virtual nsSize GetXULMaxSize(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
virtual nscoord GetAscent(nsIFrame* aBox, nsBoxLayoutState& aBoxLayoutState) override;
// get the child offsets for aChild and set them in aMargin. Returns a
// bitfield mask of the SPECIFIED_LEFT, SPECIFIED_RIGHT, SPECIFIED_TOP and
// SPECIFIED_BOTTOM offsets indicating which sides have been specified by
// attributes.
static uint8_t GetOffset(nsIFrame* aChild, nsMargin& aMargin);
