mirrors/gecko-dev
1
0
Fork 1
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-11-02 09:18:36 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Bug 1971135: Use anchor resolution params in place of position property. r=TYLin

Browse source 
... The full resolution that makes use of additional parameters will follow
shortly.

Differential Revision: https://phabricator.services.mozilla.com/D253175
This commit is contained in:
David Shin 2025-06-16 18:56:35 +00:00 committed by dshin@mozilla.com
parent c593d9bbab
commit d6e52699a1
25 changed files with 405 additions and 299 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

14
layout/base/PresShell.cpp
View file

@ -12619,20 +12619,24 @@ PresShell::WindowSizeConstraints PresShell::GetWindowSizeConstraints() {
return {minSize, maxSize};
}
const auto* pos = rootFrame->StylePosition();
const auto positionProperty = rootFrame->StyleDisplay()->mPosition;
if (const auto styleMinWidth = pos->GetMinWidth(positionProperty);
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(rootFrame);
if (const auto styleMinWidth =
pos->GetMinWidth(anchorResolutionParams.mPosition);
styleMinWidth->ConvertsToLength()) {
minSize.width = styleMinWidth->ToLength();
}
if (const auto styleMinHeight = pos->GetMinHeight(positionProperty);
if (const auto styleMinHeight =
pos->GetMinHeight(anchorResolutionParams.mPosition);
styleMinHeight->ConvertsToLength()) {
minSize.height = styleMinHeight->ToLength();
}
if (const auto maxWidth = pos->GetMaxWidth(positionProperty);
if (const auto maxWidth = pos->GetMaxWidth(anchorResolutionParams.mPosition);
maxWidth->ConvertsToLength()) {
maxSize.width = maxWidth->ToLength();
}
if (const auto maxHeight = pos->GetMaxHeight(positionProperty);
if (const auto maxHeight =
pos->GetMaxHeight(anchorResolutionParams.mPosition);
maxHeight->ConvertsToLength()) {
maxSize.height = maxHeight->ToLength();
}

5
layout/base/RestyleManager.cpp
View file

@ -841,8 +841,9 @@ static bool RecomputePosition(nsIFrame* aFrame) {
if (aFrame->HasIntrinsicKeywordForBSize()) {
WritingMode wm = aFrame->GetWritingMode();
const auto* styleMargin = aFrame->StyleMargin();
const auto positionProperty = aFrame->StyleDisplay()->mPosition;
if (styleMargin->HasBlockAxisAuto(wm, positionProperty)) {
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(aFrame);
if (styleMargin->HasBlockAxisAuto(wm, anchorResolutionParams.mPosition)) {
return false;
}
}

71
layout/base/nsLayoutUtils.cpp
View file

@ -3453,9 +3453,11 @@ struct BoxToRect : public nsLayoutUtils::BoxCallback {
nsMargin usedMargin =
aFrame->GetUsedMargin().ApplySkipSides(aFrame->GetSkipSides());
const auto* styleMargin = aFrame->StyleMargin();
const auto positionProperty = aFrame->StyleDisplay()->mPosition;
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(aFrame);
for (const Side side : AllPhysicalSides()) {
if (styleMargin->GetMargin(side, positionProperty)->IsAuto()) {
if (styleMargin->GetMargin(side, anchorResolutionParams.mPosition)
->IsAuto()) {
usedMargin.Side(side) = 0;
}
}
@ -4087,8 +4089,9 @@ static Maybe<nscoord> GetPercentBSize(const LengthPercentage& aSize,
WritingMode wm = f->GetWritingMode();
const nsStylePosition* pos = f->StylePosition();
const auto positionProperty = f->StyleDisplay()->mPosition;
Maybe<nscoord> bSize = GetBSize(pos->BSize(wm, positionProperty));
const auto anchorResolutionParams = AnchorPosResolutionParams::From(f);
Maybe<nscoord> bSize =
GetBSize(pos->BSize(wm, anchorResolutionParams.mPosition));
if (!bSize) {
LayoutFrameType fType = f->Type();
if (fType != LayoutFrameType::Viewport &&
@ -4110,13 +4113,15 @@ static Maybe<nscoord> GetPercentBSize(const LengthPercentage& aSize,
}
}
if (Maybe<nscoord> maxBSize = GetBSize(pos->MaxBSize(wm, positionProperty))) {
if (Maybe<nscoord> maxBSize =
GetBSize(pos->MaxBSize(wm, anchorResolutionParams.mPosition))) {
if (*maxBSize < *bSize) {
*bSize = *maxBSize;
}
}
if (Maybe<nscoord> minBSize = GetBSize(pos->MinBSize(wm, positionProperty))) {
if (Maybe<nscoord> minBSize =
GetBSize(pos->MinBSize(wm, anchorResolutionParams.mPosition))) {
if (*minBSize > *bSize) {
*bSize = *minBSize;
}
@ -4627,10 +4632,10 @@ nscoord nsLayoutUtils::IntrinsicForAxis(
aFrame->GetWritingMode().PhysicalAxis(LogicalAxis::Inline);
const bool isInlineAxis = aAxis == ourInlineAxis;
const auto positionProperty = aFrame->StyleDisplay()->mPosition;
auto styleMinISize = horizontalAxis
? stylePos->GetMinWidth(positionProperty)
: stylePos->GetMinHeight(positionProperty);
const auto anchorResolutionParams = AnchorPosResolutionParams::From(aFrame);
auto styleMinISize =
horizontalAxis ? stylePos->GetMinWidth(anchorResolutionParams.mPosition)
: stylePos->GetMinHeight(anchorResolutionParams.mPosition);
auto styleISize = [&]() {
if (aFlags & MIN_INTRINSIC_ISIZE) {
return AnchorResolvedSizeHelper::Overridden(*styleMinISize);
@ -4639,15 +4644,16 @@ nscoord nsLayoutUtils::IntrinsicForAxis(
isInlineAxis ? aSizeOverrides.mStyleISize : aSizeOverrides.mStyleBSize;
return styleISizeOverride
? AnchorResolvedSizeHelper::Overridden(*styleISizeOverride)
: (horizontalAxis ? stylePos->GetWidth(positionProperty)
: stylePos->GetHeight(positionProperty));
: (horizontalAxis
? stylePos->GetWidth(anchorResolutionParams.mPosition)
: stylePos->GetHeight(anchorResolutionParams.mPosition));
}();
MOZ_ASSERT(!(aFlags & MIN_INTRINSIC_ISIZE) || styleISize->IsAuto() ||
nsIFrame::ToExtremumLength(*styleISize),
"should only use MIN_INTRINSIC_ISIZE for intrinsic values");
auto styleMaxISize = horizontalAxis
? stylePos->GetMaxWidth(positionProperty)
: stylePos->GetMaxHeight(positionProperty);
auto styleMaxISize =
horizontalAxis ? stylePos->GetMaxWidth(anchorResolutionParams.mPosition)
: stylePos->GetMaxHeight(anchorResolutionParams.mPosition);
auto ResetIfKeywords = [](AnchorResolvedSize& aSize,
AnchorResolvedSize& aMinSize,
@ -4705,12 +4711,15 @@ nscoord nsLayoutUtils::IntrinsicForAxis(
auto styleBSize =
styleBSizeOverride
? AnchorResolvedSizeHelper::Overridden(*styleBSizeOverride)
: (horizontalAxis ? stylePos->GetHeight(positionProperty)
: stylePos->GetWidth(positionProperty));
auto styleMinBSize = horizontalAxis ? stylePos->GetMinHeight(positionProperty)
: stylePos->GetMinWidth(positionProperty);
auto styleMaxBSize = horizontalAxis ? stylePos->GetMaxHeight(positionProperty)
: stylePos->GetMaxWidth(positionProperty);
: (horizontalAxis
? stylePos->GetHeight(anchorResolutionParams.mPosition)
: stylePos->GetWidth(anchorResolutionParams.mPosition));
auto styleMinBSize =
horizontalAxis ? stylePos->GetMinHeight(anchorResolutionParams.mPosition)
: stylePos->GetMinWidth(anchorResolutionParams.mPosition);
auto styleMaxBSize =
horizontalAxis ? stylePos->GetMaxHeight(anchorResolutionParams.mPosition)
: stylePos->GetMaxWidth(anchorResolutionParams.mPosition);
// According to the spec, max-content and min-content should behave as the
// property's initial values in block axis.
@ -5001,13 +5010,13 @@ nscoord nsLayoutUtils::MinSizeContributionForAxis(
// Note: this method is only meant for grid/flex items.
const nsStylePosition* const stylePos = aFrame->StylePosition();
const auto positionProperty = aFrame->StyleDisplay()->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(aFrame);
auto size = aAxis == PhysicalAxis::Horizontal
? stylePos->GetMinWidth(positionProperty)
: stylePos->GetMinHeight(positionProperty);
? stylePos->GetMinWidth(anchorResolutionParams.mPosition)
: stylePos->GetMinHeight(anchorResolutionParams.mPosition);
auto maxSize = aAxis == PhysicalAxis::Horizontal
? stylePos->GetMaxWidth(positionProperty)
: stylePos->GetMaxHeight(positionProperty);
? stylePos->GetMaxWidth(anchorResolutionParams.mPosition)
: stylePos->GetMaxHeight(anchorResolutionParams.mPosition);
auto childWM = aFrame->GetWritingMode();
PhysicalAxis ourInlineAxis = childWM.PhysicalAxis(LogicalAxis::Inline);
// According to the spec, max-content and min-content should behave as the
@ -5032,8 +5041,8 @@ nscoord nsLayoutUtils::MinSizeContributionForAxis(
fixedMinSize.emplace(0);
} else {
size = aAxis == PhysicalAxis::Horizontal
? stylePos->GetWidth(positionProperty)
: stylePos->GetHeight(positionProperty);
? stylePos->GetWidth(anchorResolutionParams.mPosition)
: stylePos->GetHeight(anchorResolutionParams.mPosition);
// This is same as above: keywords should behaves as property's initial
// values in block axis.
if (aAxis != ourInlineAxis &&
@ -7950,11 +7959,11 @@ float nsLayoutUtils::FontSizeInflationInner(const nsIFrame* aFrame,
return FontSizeInflationFor(grandparent);
}
WritingMode wm = f->GetWritingMode();
const auto positionProperty = f->StyleDisplay()->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(f);
const auto stylePosISize =
f->StylePosition()->ISize(wm, positionProperty);
f->StylePosition()->ISize(wm, anchorResolutionParams.mPosition);
const auto stylePosBSize =
f->StylePosition()->BSize(wm, positionProperty);
f->StylePosition()->BSize(wm, anchorResolutionParams.mPosition);
if (!stylePosISize->IsAuto() ||
!stylePosBSize->BehavesLikeInitialValueOnBlockAxis()) {
return 1.0;

22
layout/generic/CSSAlignUtils.cpp
View file

@ -68,25 +68,29 @@ nscoord CSSAlignUtils::AlignJustifySelf(const StyleAlignFlags& aAlignment,
bool hasAutoMarginStart;
bool hasAutoMarginEnd;
const auto* styleMargin = aRI.mStyleMargin;
const auto positionProperty = aRI.mStyleDisplay->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(&aRI);
if (aFlags & (AlignJustifyFlags::IgnoreAutoMargins |
AlignJustifyFlags::AligningMarginBox)) {
// (Note: ReflowInput will have treated "auto" margins as 0, so we
// don't need to do anything special to avoid expanding them.)
hasAutoMarginStart = hasAutoMarginEnd = false;
} else if (aAxis == LogicalAxis::Block) {
hasAutoMarginStart =
styleMargin->GetMargin(LogicalSide::BStart, wm, positionProperty)
->IsAuto();
hasAutoMarginStart = styleMargin
->GetMargin(LogicalSide::BStart, wm,
anchorResolutionParams.mPosition)
->IsAuto();
hasAutoMarginEnd =
styleMargin->GetMargin(LogicalSide::BEnd, wm, positionProperty)
styleMargin
->GetMargin(LogicalSide::BEnd, wm, anchorResolutionParams.mPosition)
->IsAuto();
} else { /* aAxis == LogicalAxis::Inline */
hasAutoMarginStart =
styleMargin->GetMargin(LogicalSide::IStart, wm, positionProperty)
->IsAuto();
hasAutoMarginStart = styleMargin
->GetMargin(LogicalSide::IStart, wm,
anchorResolutionParams.mPosition)
->IsAuto();
hasAutoMarginEnd =
styleMargin->GetMargin(LogicalSide::IEnd, wm, positionProperty)
styleMargin
->GetMargin(LogicalSide::IEnd, wm, anchorResolutionParams.mPosition)
->IsAuto();
}

86
layout/generic/ReflowInput.cpp
View file

@ -208,20 +208,21 @@ ReflowInput::ReflowInput(nsPresContext* aPresContext,
bool* aFixed = nullptr) -> nscoord {
nscoord limit = NS_UNCONSTRAINEDSIZE;
const auto* pos = aFrame->StylePosition();
const auto positionProperty = aFrame->StyleDisplay()->mPosition;
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(aFrame);
if (auto size = nsLayoutUtils::GetAbsoluteSize(
*pos->ISize(mWritingMode, positionProperty))) {
*pos->ISize(mWritingMode, anchorResolutionParams.mPosition))) {
limit = size.value();
if (aFixed) {
*aFixed = true;
}
} else if (auto maxSize = nsLayoutUtils::GetAbsoluteSize(
*pos->MaxISize(mWritingMode, positionProperty))) {
} else if (auto maxSize = nsLayoutUtils::GetAbsoluteSize(*pos->MaxISize(
mWritingMode, anchorResolutionParams.mPosition))) {
limit = maxSize.value();
}
if (limit != NS_UNCONSTRAINEDSIZE) {
if (auto minSize = nsLayoutUtils::GetAbsoluteSize(
*pos->MinISize(mWritingMode, positionProperty))) {
if (auto minSize = nsLayoutUtils::GetAbsoluteSize(*pos->MinISize(
mWritingMode, anchorResolutionParams.mPosition))) {
limit = std::max(limit, minSize.value());
}
}
@ -486,11 +487,11 @@ void ReflowInput::Init(nsPresContext* aPresContext,
// An SVG foreignObject frame is inherently constrained block-size.
mFrame->AddStateBits(NS_FRAME_IN_CONSTRAINED_BSIZE);
} else {
const auto positionProperty = mStyleDisplay->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
const auto bSizeCoord =
mStylePosition->BSize(mWritingMode, positionProperty);
const auto maxBSizeCoord =
mStylePosition->MaxBSize(mWritingMode, positionProperty);
mStylePosition->BSize(mWritingMode, anchorResolutionParams.mPosition);
const auto maxBSizeCoord = mStylePosition->MaxBSize(
mWritingMode, anchorResolutionParams.mPosition);
if ((!bSizeCoord->BehavesLikeInitialValueOnBlockAxis() ||
!maxBSizeCoord->BehavesLikeInitialValueOnBlockAxis()) &&
// Don't set NS_FRAME_IN_CONSTRAINED_BSIZE on body or html elements.
@ -1257,13 +1258,13 @@ void ReflowInput::CalculateBorderPaddingMargin(
// If the margin is 'auto', ComputeCBDependentValue() will return 0. The
// correct margin value will be computed later in InitAbsoluteConstraints
// (which is caller of this function, via CalculateHypotheticalPosition).
const auto positionProperty = mStyleDisplay->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
const nscoord start = nsLayoutUtils::ComputeCBDependentValue(
aContainingBlockSize,
mStyleMargin->GetMargin(startSide, positionProperty));
mStyleMargin->GetMargin(startSide, anchorResolutionParams.mPosition));
const nscoord end = nsLayoutUtils::ComputeCBDependentValue(
aContainingBlockSize,
mStyleMargin->GetMargin(endSide, positionProperty));
mStyleMargin->GetMargin(endSide, anchorResolutionParams.mPosition));
marginStartEnd = start + end;
}
@ -1360,8 +1361,9 @@ void ReflowInput::CalculateHypotheticalPosition(
// us to exactly determine both the inline edges
WritingMode wm = containingBlock->GetWritingMode();
const auto positionProperty = mStyleDisplay->mPosition;
const auto styleISize = mStylePosition->ISize(wm, positionProperty);
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
const auto styleISize =
mStylePosition->ISize(wm, anchorResolutionParams.mPosition);
bool isAutoISize = styleISize->IsAuto();
Maybe<nsSize> intrinsicSize;
if (mFlags.mIsReplaced && isAutoISize) {
@ -1410,12 +1412,13 @@ void ReflowInput::CalculateHypotheticalPosition(
const auto contentISize =
mFrame
->ComputeISizeValue(mRenderingContext, wm, blockContentSize,
LogicalSize(wm, contentEdgeToBoxSizingISize,
contentEdgeToBoxSizingBSize),
boxSizingToMarginEdgeISize, *styleISize,
*mStylePosition->BSize(wm, positionProperty),
mFrame->GetAspectRatio())
->ComputeISizeValue(
mRenderingContext, wm, blockContentSize,
LogicalSize(wm, contentEdgeToBoxSizingISize,
contentEdgeToBoxSizingBSize),
boxSizingToMarginEdgeISize, *styleISize,
*mStylePosition->BSize(wm, anchorResolutionParams.mPosition),
mFrame->GetAspectRatio())
.mISize;
boxISize.emplace(contentISize + contentEdgeToBoxSizingISize +
boxSizingToMarginEdgeISize);
@ -1612,7 +1615,8 @@ void ReflowInput::CalculateHypotheticalPosition(
&insideBoxSizing, &outsideBoxSizing);
nscoord boxBSize;
const auto styleBSize = mStylePosition->BSize(wm, positionProperty);
const auto styleBSize =
mStylePosition->BSize(wm, anchorResolutionParams.mPosition);
const bool isAutoBSize =
nsLayoutUtils::IsAutoBSize(*styleBSize, blockContentSize.BSize(wm));
if (isAutoBSize) {
@ -2159,7 +2163,7 @@ LogicalSize ReflowInput::ComputeContainingBlockRectangle(
auto IsQuirky = [](const StyleSize& aSize) -> bool {
return aSize.ConvertsToPercentage();
};
const auto positionProperty = mStyleDisplay->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
// an element in quirks mode gets a containing block based on looking for a
// parent with a non-auto height if the element has a percent height.
// Note: We don't emulate this quirk for percents in calc(), or in vertical
@ -2167,12 +2171,13 @@ LogicalSize ReflowInput::ComputeContainingBlockRectangle(
if (!wm.IsVertical() && NS_UNCONSTRAINEDSIZE == cbSize.BSize(wm)) {
if (eCompatibility_NavQuirks == aPresContext->CompatibilityMode() &&
!aContainingBlockRI->mFrame->IsFlexOrGridItem() &&
(IsQuirky(*mStylePosition->GetHeight(positionProperty)) ||
(IsQuirky(
*mStylePosition->GetHeight(anchorResolutionParams.mPosition)) ||
(mFrame->IsTableWrapperFrame() &&
IsQuirky(*mFrame->PrincipalChildList()
.FirstChild()
->StylePosition()
->GetHeight(positionProperty))))) {
->GetHeight(anchorResolutionParams.mPosition))))) {
cbSize.BSize(wm) = CalcQuirkContainingBlockHeight(aContainingBlockRI);
}
}
@ -2720,14 +2725,16 @@ void ReflowInput::CalculateBlockSideMargins() {
return;
}
const auto positionProperty = mStyleDisplay->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
// The css2 spec clearly defines how block elements should behave
// in section 10.3.3.
bool isAutoStartMargin =
mStyleMargin->GetMargin(LogicalSide::IStart, cbWM, positionProperty)
->IsAuto();
bool isAutoStartMargin = mStyleMargin
->GetMargin(LogicalSide::IStart, cbWM,
anchorResolutionParams.mPosition)
->IsAuto();
bool isAutoEndMargin =
mStyleMargin->GetMargin(LogicalSide::IEnd, cbWM, positionProperty)
mStyleMargin
->GetMargin(LogicalSide::IEnd, cbWM, anchorResolutionParams.mPosition)
->IsAuto();
if (!isAutoStartMargin && !isAutoEndMargin) {
// Neither margin is 'auto' so we're over constrained. Use the
@ -2956,10 +2963,11 @@ bool SizeComputationInput::ComputeMargin(WritingMode aCBWM,
aPercentBasis = 0;
}
LogicalMargin m(aCBWM);
const auto positionProperty = mFrame->StyleDisplay()->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(mFrame);
for (const LogicalSide side : LogicalSides::All) {
m.Side(side, aCBWM) = nsLayoutUtils::ComputeCBDependentValue(
aPercentBasis, styleMargin->GetMargin(side, aCBWM, positionProperty));
aPercentBasis, styleMargin->GetMargin(
side, aCBWM, anchorResolutionParams.mPosition));
}
SetComputedLogicalMargin(aCBWM, m);
} else {
@ -3018,11 +3026,15 @@ bool SizeComputationInput::ComputePadding(WritingMode aCBWM,
void ReflowInput::ComputeMinMaxValues(const LogicalSize& aCBSize) {
WritingMode wm = GetWritingMode();
const auto positionProperty = mStyleDisplay->mPosition;
const auto minISize = mStylePosition->MinISize(wm, positionProperty);
const auto maxISize = mStylePosition->MaxISize(wm, positionProperty);
const auto minBSize = mStylePosition->MinBSize(wm, positionProperty);
const auto maxBSize = mStylePosition->MaxBSize(wm, positionProperty);
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
const auto minISize =
mStylePosition->MinISize(wm, anchorResolutionParams.mPosition);
const auto maxISize =
mStylePosition->MaxISize(wm, anchorResolutionParams.mPosition);
const auto minBSize =
mStylePosition->MinBSize(wm, anchorResolutionParams.mPosition);
const auto maxBSize =
mStylePosition->MaxBSize(wm, anchorResolutionParams.mPosition);
LogicalSize minWidgetSize(wm);
if (mIsThemed) {

56
layout/generic/nsAbsoluteContainingBlock.cpp
View file

@ -307,7 +307,7 @@ bool nsAbsoluteContainingBlock::FrameDependsOnContainer(nsIFrame* f,
const nsStylePadding* padding = f->StylePadding();
const nsStyleMargin* margin = f->StyleMargin();
WritingMode wm = f->GetWritingMode();
const auto anchorPosResolutionParams = AnchorPosResolutionParams::From(f);
const auto anchorResolutionParams = AnchorPosResolutionParams::From(f);
if (wm.IsVertical() ? aCBHeightChanged : aCBWidthChanged) {
// See if f's inline-size might have changed.
// If margin-inline-start/end, padding-inline-start/end,
@ -316,11 +316,11 @@ bool nsAbsoluteContainingBlock::FrameDependsOnContainer(nsIFrame* f,
// Note that borders never depend on the parent isize.
// XXX All of the enumerated values except -moz-available are ok too.
if (nsStylePosition::ISizeDependsOnContainer(
pos->ISize(wm, anchorPosResolutionParams.mPosition)) ||
pos->ISize(wm, anchorResolutionParams.mPosition)) ||
nsStylePosition::MinISizeDependsOnContainer(
pos->MinISize(wm, anchorPosResolutionParams.mPosition)) ||
pos->MinISize(wm, anchorResolutionParams.mPosition)) ||
nsStylePosition::MaxISizeDependsOnContainer(
pos->MaxISize(wm, anchorPosResolutionParams.mPosition)) ||
pos->MaxISize(wm, anchorResolutionParams.mPosition)) ||
!IsFixedPaddingSize(padding->mPadding.GetIStart(wm)) ||
!IsFixedPaddingSize(padding->mPadding.GetIEnd(wm))) {
return true;
@ -330,9 +330,9 @@ bool nsAbsoluteContainingBlock::FrameDependsOnContainer(nsIFrame* f,
// rules are slightly different. We'll assume percentage or auto
// margins will always induce a dependency on the size
if (!IsFixedMarginSize(margin->GetMargin(
LogicalSide::IStart, wm, anchorPosResolutionParams.mPosition)) ||
LogicalSide::IStart, wm, anchorResolutionParams.mPosition)) ||
!IsFixedMarginSize(margin->GetMargin(
LogicalSide::IEnd, wm, anchorPosResolutionParams.mPosition))) {
LogicalSide::IEnd, wm, anchorResolutionParams.mPosition))) {
return true;
}
}
@ -346,10 +346,9 @@ bool nsAbsoluteContainingBlock::FrameDependsOnContainer(nsIFrame* f,
//
// FIXME(emilio): Should the BSize(wm).IsAuto() check also for the extremum
// lengths?
const auto bSize = pos->BSize(wm, anchorPosResolutionParams.mPosition);
const auto bSize = pos->BSize(wm, anchorResolutionParams.mPosition);
const auto anchorOffsetResolutionParams =
AnchorPosOffsetResolutionParams::UseCBFrameSize(
anchorPosResolutionParams);
AnchorPosOffsetResolutionParams::UseCBFrameSize(anchorResolutionParams);
if ((nsStylePosition::BSizeDependsOnContainer(bSize) &&
!(bSize->IsAuto() &&
pos->GetAnchorResolvedInset(LogicalSide::BEnd, wm,
@ -359,9 +358,9 @@ bool nsAbsoluteContainingBlock::FrameDependsOnContainer(nsIFrame* f,
anchorOffsetResolutionParams)
->IsAuto())) ||
nsStylePosition::MinBSizeDependsOnContainer(
pos->MinBSize(wm, anchorPosResolutionParams.mPosition)) ||
pos->MinBSize(wm, anchorResolutionParams.mPosition)) ||
nsStylePosition::MaxBSizeDependsOnContainer(
pos->MaxBSize(wm, anchorPosResolutionParams.mPosition)) ||
pos->MaxBSize(wm, anchorResolutionParams.mPosition)) ||
!IsFixedPaddingSize(padding->mPadding.GetBStart(wm)) ||
!IsFixedPaddingSize(padding->mPadding.GetBEnd(wm))) {
return true;
@ -369,9 +368,9 @@ bool nsAbsoluteContainingBlock::FrameDependsOnContainer(nsIFrame* f,
// See if f's position might have changed.
if (!IsFixedMarginSize(margin->GetMargin(
LogicalSide::BStart, wm, anchorPosResolutionParams.mPosition)) ||
LogicalSide::BStart, wm, anchorResolutionParams.mPosition)) ||
!IsFixedMarginSize(margin->GetMargin(
LogicalSide::BEnd, wm, anchorPosResolutionParams.mPosition))) {
LogicalSide::BEnd, wm, anchorResolutionParams.mPosition))) {
return true;
}
}
@ -384,8 +383,7 @@ bool nsAbsoluteContainingBlock::FrameDependsOnContainer(nsIFrame* f,
// are easier to do using physical coordinates rather than logical.
if (aCBWidthChanged) {
const auto anchorOffsetResolutionParams =
AnchorPosOffsetResolutionParams::UseCBFrameSize(
anchorPosResolutionParams);
AnchorPosOffsetResolutionParams::UseCBFrameSize(anchorResolutionParams);
if (!IsFixedOffset(pos->GetAnchorResolvedInset(
eSideLeft, anchorOffsetResolutionParams))) {
return true;
@ -406,8 +404,7 @@ bool nsAbsoluteContainingBlock::FrameDependsOnContainer(nsIFrame* f,
}
if (aCBHeightChanged) {
const auto anchorOffsetResolutionParams =
AnchorPosOffsetResolutionParams::UseCBFrameSize(
anchorPosResolutionParams);
AnchorPosOffsetResolutionParams::UseCBFrameSize(anchorResolutionParams);
if (!IsFixedOffset(pos->GetAnchorResolvedInset(
eSideTop, anchorOffsetResolutionParams))) {
return true;
@ -786,21 +783,30 @@ void nsAbsoluteContainingBlock::ResolveAutoMarginsAfterLayout(
offsetsInWM.BStartEnd(wm) - marginInWM.BStartEnd(wm);
const auto& styleMargin = aKidReflowInput.mStyleMargin;
const auto positionProperty = aKidReflowInput.mStyleDisplay->mPosition;
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(&aKidReflowInput);
if (wm.IsOrthogonalTo(outerWM)) {
ReflowInput::ComputeAbsPosInlineAutoMargin(
availMarginSpace, outerWM,
styleMargin->GetMargin(LogicalSide::IStart, outerWM, positionProperty)
styleMargin
->GetMargin(LogicalSide::IStart, outerWM,
anchorResolutionParams.mPosition)
->IsAuto(),
styleMargin->GetMargin(LogicalSide::IEnd, outerWM, positionProperty)
styleMargin
->GetMargin(LogicalSide::IEnd, outerWM,
anchorResolutionParams.mPosition)
->IsAuto(),
aMargin, aOffsets);
} else {
ReflowInput::ComputeAbsPosBlockAutoMargin(
availMarginSpace, outerWM,
styleMargin->GetMargin(LogicalSide::BStart, outerWM, positionProperty)
styleMargin
->GetMargin(LogicalSide::BStart, outerWM,
anchorResolutionParams.mPosition)
->IsAuto(),
styleMargin->GetMargin(LogicalSide::BEnd, outerWM, positionProperty)
styleMargin
->GetMargin(LogicalSide::BEnd, outerWM,
anchorResolutionParams.mPosition)
->IsAuto(),
aMargin, aOffsets);
}
@ -812,8 +818,10 @@ void nsAbsoluteContainingBlock::ResolveAutoMarginsAfterLayout(
aKidReflowInput.mFrame->GetProperty(nsIFrame::UsedMarginProperty());
// InitOffsets should've created a UsedMarginProperty for us, if any margin is
// auto.
MOZ_ASSERT_IF(styleMargin->HasInlineAxisAuto(outerWM, positionProperty) ||
styleMargin->HasBlockAxisAuto(outerWM, positionProperty),
MOZ_ASSERT_IF(styleMargin->HasInlineAxisAuto(
outerWM, anchorResolutionParams.mPosition) ||
styleMargin->HasBlockAxisAuto(
outerWM, anchorResolutionParams.mPosition),
propValue);
if (propValue) {
*propValue = aMargin.GetPhysicalMargin(outerWM);

7
layout/generic/nsBlockFrame.cpp
View file

@ -4083,10 +4083,11 @@ bool nsBlockFrame::IsSelfEmpty() {
WritingMode wm = GetWritingMode();
const nsStylePosition* position = StylePosition();
const auto positionProperty = StyleDisplay()->mPosition;
const auto bSize = position->BSize(wm, positionProperty);
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
const auto bSize = position->BSize(wm, anchorResolutionParams.mPosition);
if (IsNonAutoNonZeroBSize(*position->MinBSize(wm, positionProperty)) ||
if (IsNonAutoNonZeroBSize(
*position->MinBSize(wm, anchorResolutionParams.mPosition)) ||
IsNonAutoNonZeroBSize(*bSize)) {
return false;
}

18
layout/generic/nsContainerFrame.cpp
View file

@ -2198,18 +2198,18 @@ LogicalSize nsContainerFrame::ComputeSizeWithIntrinsicDimensions(
const LogicalSize& aBorderPadding, const StyleSizeOverrides& aSizeOverrides,
ComputeSizeFlags aFlags) {
const nsStylePosition* stylePos = StylePosition();
const auto positionProperty = StyleDisplay()->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
const auto styleISize =
aSizeOverrides.mStyleISize
? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleISize)
: stylePos->ISize(aWM, positionProperty);
: stylePos->ISize(aWM, anchorResolutionParams.mPosition);
// TODO(dholbert): if styleBSize is 'stretch' here, we should probably
// resolve it like we do in nsIFrame::ComputeSize. See bug 1937275.
const auto styleBSize =
aSizeOverrides.mStyleBSize
? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleBSize)
: stylePos->BSize(aWM, positionProperty);
: stylePos->BSize(aWM, anchorResolutionParams.mPosition);
const auto& aspectRatio =
aSizeOverrides.mAspectRatio ? *aSizeOverrides.mAspectRatio : aAspectRatio;
@ -2316,7 +2316,8 @@ LogicalSize nsContainerFrame::ComputeSizeWithIntrinsicDimensions(
// algorithm.)
const bool isFlexItemInlineAxisMainAxis =
flexItemMainAxis && *flexItemMainAxis == LogicalAxis::Inline;
const auto maxISizeCoord = stylePos->MaxISize(aWM, positionProperty);
const auto maxISizeCoord =
stylePos->MaxISize(aWM, anchorResolutionParams.mPosition);
if (!maxISizeCoord->IsNone() && !isFlexItemInlineAxisMainAxis) {
maxISize =
ComputeISizeValue(aRenderingContext, aWM, aCBSize, boxSizingAdjust,
@ -2327,7 +2328,8 @@ LogicalSize nsContainerFrame::ComputeSizeWithIntrinsicDimensions(
maxISize = nscoord_MAX;
}
const auto minISizeCoord = stylePos->MinISize(aWM, positionProperty);
const auto minISizeCoord =
stylePos->MinISize(aWM, anchorResolutionParams.mPosition);
if (!minISizeCoord->IsAuto() && !isFlexItemInlineAxisMainAxis) {
minISize =
ComputeISizeValue(aRenderingContext, aWM, aCBSize, boxSizingAdjust,
@ -2378,7 +2380,8 @@ LogicalSize nsContainerFrame::ComputeSizeWithIntrinsicDimensions(
// algorithm.)
const bool isFlexItemBlockAxisMainAxis =
flexItemMainAxis && *flexItemMainAxis == LogicalAxis::Block;
const auto maxBSizeCoord = stylePos->MaxBSize(aWM, positionProperty);
const auto maxBSizeCoord =
stylePos->MaxBSize(aWM, anchorResolutionParams.mPosition);
if (!nsLayoutUtils::IsAutoBSize(*maxBSizeCoord, aCBSize.BSize(aWM)) &&
!isFlexItemBlockAxisMainAxis) {
maxBSize = nsLayoutUtils::ComputeBSizeValueHandlingStretch(
@ -2388,7 +2391,8 @@ LogicalSize nsContainerFrame::ComputeSizeWithIntrinsicDimensions(
maxBSize = nscoord_MAX;
}
const auto minBSizeCoord = stylePos->MinBSize(aWM, positionProperty);
const auto minBSizeCoord =
stylePos->MinBSize(aWM, anchorResolutionParams.mPosition);
if (!nsLayoutUtils::IsAutoBSize(*minBSizeCoord, aCBSize.BSize(aWM)) &&
!isFlexItemBlockAxisMainAxis) {
minBSize = nsLayoutUtils::ComputeBSizeValueHandlingStretch(

8
layout/generic/nsContainerFrameInlines.h
View file

@ -33,7 +33,7 @@ void nsContainerFrame::DoInlineIntrinsicISize(ISizeData* aData,
const nsStylePadding* stylePadding = StylePadding();
const nsStyleBorder* styleBorder = StyleBorder();
const nsStyleMargin* styleMargin = StyleMargin();
const auto positionProperty = StyleDisplay()->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
// This goes at the beginning no matter how things are broken and how
// messy the bidi situations are, since per CSS2.1 section 8.6
@ -52,7 +52,8 @@ void nsContainerFrame::DoInlineIntrinsicISize(ISizeData* aData,
// clamp negative calc() to 0
std::max(stylePadding->mPadding.Get(startSide).Resolve(0), 0) +
styleBorder->GetComputedBorderWidth(startSide) +
GetMargin(styleMargin->GetMargin(startSide, positionProperty));
GetMargin(styleMargin->GetMargin(startSide,
anchorResolutionParams.mPosition));
if (MOZ_LIKELY(sliceBreak)) {
aData->mCurrentLine += startPBM;
} else {
@ -64,7 +65,8 @@ void nsContainerFrame::DoInlineIntrinsicISize(ISizeData* aData,
// clamp negative calc() to 0
std::max(stylePadding->mPadding.Get(endSide).Resolve(0), 0) +
styleBorder->GetComputedBorderWidth(endSide) +
GetMargin(styleMargin->GetMargin(endSide, positionProperty));
GetMargin(
styleMargin->GetMargin(endSide, anchorResolutionParams.mPosition));
if (MOZ_UNLIKELY(!sliceBreak)) {
clonePBM += endPBM;
aData->mCurrentLine += clonePBM;

10
layout/generic/nsFirstLetterFrame.cpp
View file

@ -171,16 +171,16 @@ bool nsFirstLetterFrame::UseTightBounds() const {
const auto wm = GetWritingMode();
const auto* styleMargin = StyleMargin();
const auto positionProperty = StyleDisplay()->mPosition;
const auto bStart =
styleMargin->GetMargin(LogicalSide::BStart, wm, positionProperty);
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
const auto bStart = styleMargin->GetMargin(LogicalSide::BStart, wm,
anchorResolutionParams.mPosition);
// Currently, we only check for margins with negative *length* values;
// negative percentages seem unlikely to be used/useful in this context.
if (bStart->ConvertsToLength() && bStart->ToLength() < 0) {
return false;
}
const auto bEnd =
styleMargin->GetMargin(LogicalSide::BEnd, wm, positionProperty);
const auto bEnd = styleMargin->GetMargin(LogicalSide::BEnd, wm,
anchorResolutionParams.mPosition);
return !(bEnd->ConvertsToLength() && bEnd->ToLength() < 0);
}

58
layout/generic/nsFlexContainerFrame.cpp
View file

@ -1432,7 +1432,8 @@ void nsFlexContainerFrame::GenerateFlexItemForChild(
// or block-size, we need to dig through to the inner table.
const auto* styleFrame = nsLayoutUtils::GetStyleFrame(aChildFrame);
const auto* stylePos = styleFrame->StylePosition();
const auto positionProperty = styleFrame->StyleDisplay()->mPosition;
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(styleFrame);
// Construct a StyleSizeOverrides for this flex item so that its ReflowInput
// below will use and resolve its flex base size rather than its corresponding
@ -1446,8 +1447,8 @@ void nsFlexContainerFrame::GenerateFlexItemForChild(
// *unless* they have 'flex-basis:auto' in which case they use their
// preferred main size after all.
const auto& flexBasis = stylePos->mFlexBasis;
const auto styleMainSize =
stylePos->Size(aAxisTracker.MainAxis(), flexWM, positionProperty);
const auto styleMainSize = stylePos->Size(aAxisTracker.MainAxis(), flexWM,
anchorResolutionParams.mPosition);
if (IsUsedFlexBasisContent(flexBasis, *styleMainSize)) {
// If we get here, we're resolving the flex base size for a flex item, and
// we fall into the flexbox spec section 9.2 step 3, substep C (if we have
@ -1581,11 +1582,12 @@ nscoord nsFlexContainerFrame::PartiallyResolveAutoMinSize(
const auto itemWM = aFlexItem.GetWritingMode();
const auto cbWM = aAxisTracker.GetWritingMode();
const auto positionProperty = aItemReflowInput.mStyleDisplay->mPosition;
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(&aItemReflowInput);
const auto mainStyleSize = aItemReflowInput.mStylePosition->Size(
aAxisTracker.MainAxis(), cbWM, positionProperty);
aAxisTracker.MainAxis(), cbWM, anchorResolutionParams.mPosition);
const auto maxMainStyleSize = aItemReflowInput.mStylePosition->MaxSize(
aAxisTracker.MainAxis(), cbWM, positionProperty);
aAxisTracker.MainAxis(), cbWM, anchorResolutionParams.mPosition);
const auto boxSizingAdjust =
aItemReflowInput.mStylePosition->mBoxSizing == StyleBoxSizing::Border
? aFlexItem.BorderPadding().Size(cbWM)
@ -2241,16 +2243,19 @@ FlexItem::FlexItem(ReflowInput& aFlexItemReflowInput, float aFlexGrow,
SetFlexBaseSizeAndMainSize(aFlexBaseSize);
const nsStyleMargin* styleMargin = aFlexItemReflowInput.mStyleMargin;
const auto positionProperty = aFlexItemReflowInput.mStyleDisplay->mPosition;
mHasAnyAutoMargin = styleMargin->HasInlineAxisAuto(mCBWM, positionProperty) ||
styleMargin->HasBlockAxisAuto(mCBWM, positionProperty);
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(&aFlexItemReflowInput);
mHasAnyAutoMargin =
styleMargin->HasInlineAxisAuto(mCBWM, anchorResolutionParams.mPosition) ||
styleMargin->HasBlockAxisAuto(mCBWM, anchorResolutionParams.mPosition);
// Assert that any "auto" margin components are set to 0.
// (We'll resolve them later; until then, we want to treat them as 0-sized.)
#ifdef DEBUG
{
for (const auto side : LogicalSides::All) {
if (styleMargin->GetMargin(side, mCBWM, positionProperty)->IsAuto()) {
if (styleMargin->GetMargin(side, mCBWM, anchorResolutionParams.mPosition)
->IsAuto()) {
MOZ_ASSERT(GetMarginComponentForSide(side) == 0,
"Someone else tried to resolve our auto margin");
}
@ -2425,13 +2430,14 @@ nscoord FlexItem::BaselineOffsetFromOuterCrossEdge(
bool FlexItem::IsCrossSizeAuto() const {
const auto* styleFrame = nsLayoutUtils::GetStyleFrame(mFrame);
const nsStylePosition* stylePos = styleFrame->StylePosition();
const auto positionProperty = styleFrame->StyleDisplay()->mPosition;
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(styleFrame);
// Check whichever component is in the flex container's cross axis.
// (IsInlineAxisCrossAxis() tells us whether that's our ISize or BSize, in
// terms of our own WritingMode, mWM.)
return IsInlineAxisCrossAxis()
? stylePos->ISize(mWM, positionProperty)->IsAuto()
: stylePos->BSize(mWM, positionProperty)->IsAuto();
? stylePos->ISize(mWM, anchorResolutionParams.mPosition)->IsAuto()
: stylePos->BSize(mWM, anchorResolutionParams.mPosition)->IsAuto();
}
bool FlexItem::IsCrossSizeDefinite(const ReflowInput& aItemReflowInput) const {
@ -2441,18 +2447,19 @@ bool FlexItem::IsCrossSizeDefinite(const ReflowInput& aItemReflowInput) const {
}
const nsStylePosition* pos = aItemReflowInput.mStylePosition;
const auto positionProperty = aItemReflowInput.mStyleDisplay->mPosition;
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(&aItemReflowInput);
const auto itemWM = GetWritingMode();
// The logic here should be similar to the logic for isAutoISize/isAutoBSize
// in nsContainerFrame::ComputeSizeWithIntrinsicDimensions().
if (IsInlineAxisCrossAxis()) {
return !pos->ISize(itemWM, positionProperty)->IsAuto();
return !pos->ISize(itemWM, anchorResolutionParams.mPosition)->IsAuto();
}
nscoord cbBSize = aItemReflowInput.mContainingBlockSize.BSize(itemWM);
return !nsLayoutUtils::IsAutoBSize(*pos->BSize(itemWM, positionProperty),
cbBSize);
return !nsLayoutUtils::IsAutoBSize(
*pos->BSize(itemWM, anchorResolutionParams.mPosition), cbBSize);
}
void FlexItem::ResolveFlexBaseSizeFromAspectRatio(
@ -2484,10 +2491,11 @@ void FlexItem::ResolveFlexBaseSizeFromAspectRatio(
uint32_t FlexItem::NumAutoMarginsInAxis(LogicalAxis aAxis) const {
uint32_t numAutoMargins = 0;
const auto* styleMargin = mFrame->StyleMargin();
const auto positionProperty = mFrame->StyleDisplay()->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(mFrame);
for (const auto edge : {LogicalEdge::Start, LogicalEdge::End}) {
const auto side = MakeLogicalSide(aAxis, edge);
if (styleMargin->GetMargin(side, mCBWM, positionProperty)->IsAuto()) {
if (styleMargin->GetMargin(side, mCBWM, anchorResolutionParams.mPosition)
->IsAuto()) {
numAutoMargins++;
}
}
@ -3580,9 +3588,11 @@ MainAxisPositionTracker::MainAxisPositionTracker(
void MainAxisPositionTracker::ResolveAutoMarginsInMainAxis(FlexItem& aItem) {
if (mNumAutoMarginsInMainAxis) {
const auto* styleMargin = aItem.Frame()->StyleMargin();
const auto positionProperty = aItem.Frame()->StyleDisplay()->mPosition;
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(aItem.Frame());
for (const auto side : {StartSide(), EndSide()}) {
if (styleMargin->GetMargin(side, mWM, positionProperty)->IsAuto()) {
if (styleMargin->GetMargin(side, mWM, anchorResolutionParams.mPosition)
->IsAuto()) {
// NOTE: This integer math will skew the distribution of remainder
// app-units towards the end, which is fine.
nscoord curAutoMarginSize =
@ -3978,9 +3988,11 @@ void SingleLineCrossAxisPositionTracker::ResolveAutoMarginsInCrossAxis(
// OK, we have at least one auto margin and we have some available space.
// Give each auto margin a share of the space.
const auto* styleMargin = aItem.Frame()->StyleMargin();
const auto positionProperty = aItem.Frame()->StyleDisplay()->mPosition;
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(aItem.Frame());
for (const auto side : {StartSide(), EndSide()}) {
if (styleMargin->GetMargin(side, mWM, positionProperty)->IsAuto()) {
if (styleMargin->GetMargin(side, mWM, anchorResolutionParams.mPosition)
->IsAuto()) {
MOZ_ASSERT(aItem.GetMarginComponentForSide(side) == 0,
"Expecting auto margins to have value '0' before we "
"update them");

80
layout/generic/nsGridContainerFrame.cpp
View file

@ -339,12 +339,13 @@ struct RepeatTrackSizingInput {
// This should be used in intrinsic sizing (i.e. when we can't initialize
// the sizes directly from ReflowInput values).
void InitFromStyle(LogicalAxis aAxis, WritingMode aWM,
void InitFromStyle(LogicalAxis aAxis, WritingMode aWM, const nsIFrame* aFrame,
const ComputedStyle* aStyle,
const AspectRatio& aAspectRatio,
const Maybe<LogicalSize>& aContainingBlockSize) {
const auto& pos = aStyle->StylePosition();
const auto positionProperty = aStyle->StyleDisplay()->mPosition;
const AnchorPosResolutionParams anchorResolutionParams{
aFrame, aStyle->StyleDisplay()->mPosition};
BoxSizingAdjustment boxSizingAdjustment(aWM, *aStyle);
const nscoord cbSizeInAxis = aContainingBlockSize
? aContainingBlockSize->Size(aAxis, aWM)
@ -357,7 +358,8 @@ struct RepeatTrackSizingInput {
};
nscoord& min = mMin.Size(aAxis, aWM);
const auto styleMinSize = pos->MinSize(aAxis, aWM, positionProperty);
const auto styleMinSize =
pos->MinSize(aAxis, aWM, anchorResolutionParams.mPosition);
if (styleMinSize->ConvertsToLength()) {
min = adjustForBoxSizing(styleMinSize->ToLength());
} else if (styleMinSize->HasPercent() &&
@ -367,8 +369,8 @@ struct RepeatTrackSizingInput {
} else if (aAspectRatio && styleMinSize->BehavesLikeInitialValue(aAxis)) {
// Use GetOrthogonalAxis() to get the ratio-determining axis. Same for max
// and size below in this function.
const auto styleRDMinSize =
pos->MinSize(GetOrthogonalAxis(aAxis), aWM, positionProperty);
const auto styleRDMinSize = pos->MinSize(
GetOrthogonalAxis(aAxis), aWM, anchorResolutionParams.mPosition);
if (Maybe<nscoord> resolvedMinSize = ComputeTransferredSize(
styleRDMinSize, aAxis, aWM, aAspectRatio, boxSizingAdjustment,
aContainingBlockSize)) {
@ -377,7 +379,8 @@ struct RepeatTrackSizingInput {
}
nscoord& max = mMax.Size(aAxis, aWM);
const auto styleMaxSize = pos->MaxSize(aAxis, aWM, positionProperty);
const auto styleMaxSize =
pos->MaxSize(aAxis, aWM, anchorResolutionParams.mPosition);
if (styleMaxSize->ConvertsToLength()) {
max = std::max(min, adjustForBoxSizing(styleMaxSize->ToLength()));
} else if (styleMaxSize->HasPercent() &&
@ -386,8 +389,8 @@ struct RepeatTrackSizingInput {
min, adjustForBoxSizing(
styleMaxSize->AsLengthPercentage().Resolve(cbSizeInAxis)));
} else if (aAspectRatio && styleMaxSize->BehavesLikeInitialValue(aAxis)) {
const auto styleRDMaxSize =
pos->MaxSize(GetOrthogonalAxis(aAxis), aWM, positionProperty);
const auto styleRDMaxSize = pos->MaxSize(
GetOrthogonalAxis(aAxis), aWM, anchorResolutionParams.mPosition);
if (Maybe<nscoord> resolvedMaxSize = ComputeTransferredSize(
styleRDMaxSize, aAxis, aWM, aAspectRatio, boxSizingAdjustment,
aContainingBlockSize)) {
@ -398,9 +401,10 @@ struct RepeatTrackSizingInput {
nscoord& size = mSize.Size(aAxis, aWM);
// When computing the intrinsic inline size, disregard the explicit
// inline-size property as it should not affect the final result.
const auto styleSize = aAxis == LogicalAxis::Inline
? AnchorResolvedSizeHelper::Auto()
: pos->BSize(aWM, positionProperty);
const auto styleSize =
aAxis == LogicalAxis::Inline
? AnchorResolvedSizeHelper::Auto()
: pos->BSize(aWM, anchorResolutionParams.mPosition);
if (styleSize->ConvertsToLength()) {
size = std::clamp(adjustForBoxSizing(styleSize->ToLength()), min, max);
} else if (styleSize->HasPercent() &&
@ -410,8 +414,8 @@ struct RepeatTrackSizingInput {
styleSize->AsLengthPercentage().Resolve(cbSizeInAxis)),
min, max);
} else if (aAspectRatio && styleSize->BehavesLikeInitialValue(aAxis)) {
const auto styleRDSize =
pos->Size(GetOrthogonalAxis(aAxis), aWM, positionProperty);
const auto styleRDSize = pos->Size(GetOrthogonalAxis(aAxis), aWM,
anchorResolutionParams.mPosition);
if (Maybe<nscoord> resolvedSize = ComputeTransferredSize(
styleRDSize, aAxis, aWM, aAspectRatio, boxSizingAdjustment,
aContainingBlockSize)) {
@ -928,8 +932,10 @@ struct nsGridContainerFrame::GridItemInfo {
? mFrame->PrincipalChildList().FirstChild()
: mFrame;
const auto* pos = styleFrame->StylePosition();
const auto positionProperty = styleFrame->StyleDisplay()->mPosition;
const auto size = pos->Size(aContainerAxis, aContainerWM, positionProperty);
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(styleFrame);
const auto size = pos->Size(aContainerAxis, aContainerWM,
anchorResolutionParams.mPosition);
// max-content and min-content should behave as initial value in block axis.
// FIXME: Bug 567039: moz-fit-content and -moz-available are not supported
// for block size dimension on sizing properties (e.g. height), so we
@ -942,8 +948,8 @@ struct nsGridContainerFrame::GridItemInfo {
if (!isAuto && !size->HasPercent()) {
return false;
}
const auto minSize =
pos->MinSize(aContainerAxis, aContainerWM, positionProperty);
const auto minSize = pos->MinSize(aContainerAxis, aContainerWM,
anchorResolutionParams.mPosition);
// max-content and min-content should behave as initial value in block axis.
// FIXME: Bug 567039: moz-fit-content and -moz-available are not supported
// for block size dimension on sizing properties (e.g. height), so we
@ -1014,13 +1020,14 @@ struct nsGridContainerFrame::GridItemInfo {
};
const nsStylePosition* stylePos = mFrame->StylePosition();
const auto positionProperty = mFrame->StyleDisplay()->mPosition;
bool isItemAutoSize = IsDependentOnContainerSize(*stylePos->BSize(
aContainerWM, positionProperty)) ||
IsDependentOnContainerSize(*stylePos->MinBSize(
aContainerWM, positionProperty)) ||
IsDependentOnContainerSize(*stylePos->MaxBSize(
aContainerWM, positionProperty));
const auto anchorResolutionParams = AnchorPosResolutionParams::From(mFrame);
bool isItemAutoSize =
IsDependentOnContainerSize(
*stylePos->BSize(aContainerWM, anchorResolutionParams.mPosition)) ||
IsDependentOnContainerSize(*stylePos->MinBSize(
aContainerWM, anchorResolutionParams.mPosition)) ||
IsDependentOnContainerSize(*stylePos->MaxBSize(
aContainerWM, anchorResolutionParams.mPosition));
return isItemAutoSize;
}
@ -5199,13 +5206,13 @@ void nsGridContainerFrame::Grid::SubgridPlaceGridItems(
// subgrid. Otherwise, we may have to know the area size that this grid item
// is placed, and pass the area size as the containing block size to this
// function.
repeatSizing.InitFromStyle(LogicalAxis::Inline, gridRI.mWM,
repeatSizing.InitFromStyle(LogicalAxis::Inline, gridRI.mWM, gridRI.mFrame,
gridRI.mFrame->Style(),
gridRI.mFrame->GetAspectRatio(), Nothing());
}
if (!childGrid->IsRowSubgrid() && gridRI.mRowFunctions.mHasRepeatAuto) {
// FIXME: Bug 1918794. Same as above.
repeatSizing.InitFromStyle(LogicalAxis::Block, gridRI.mWM,
repeatSizing.InitFromStyle(LogicalAxis::Block, gridRI.mWM, gridRI.mFrame,
gridRI.mFrame->Style(),
gridRI.mFrame->GetAspectRatio(), Nothing());
}
@ -6058,9 +6065,11 @@ struct CachedIntrinsicSizes {
if (aTypes.contains(GridIntrinsicSizeType::MinSize)) {
nsIFrame* const child = aGridItem.mFrame;
const nsStylePosition* const stylePos = child->StylePosition();
const auto positionProperty = child->StyleDisplay()->mPosition;
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(child);
const WritingMode cbwm = aGridRI.mWM;
auto styleSize = stylePos->Size(aAxis, cbwm, positionProperty);
auto styleSize =
stylePos->Size(aAxis, cbwm, anchorResolutionParams.mPosition);
const LogicalAxis axisInItemWM =
cbwm.IsOrthogonalTo(child->GetWritingMode())
? GetOrthogonalAxis(aAxis)
@ -6114,7 +6123,8 @@ struct CachedIntrinsicSizes {
// https://drafts.csswg.org/css-grid-2/#min-size-contribution
nsIFrame* const child = aGridItem.mFrame;
const nsStylePosition* const stylePos = child->StylePosition();
const auto positionProperty = child->StyleDisplay()->mPosition;
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(child);
const LogicalAxis axisInItemWM =
containerWM.IsOrthogonalTo(child->GetWritingMode())
? GetOrthogonalAxis(aAxis)
@ -6123,8 +6133,8 @@ struct CachedIntrinsicSizes {
// The caller must handle this case separately.
// See EnsureContributions.
{
const auto styleSize =
stylePos->Size(aAxis, containerWM, positionProperty);
const auto styleSize = stylePos->Size(
aAxis, containerWM, anchorResolutionParams.mPosition);
MOZ_ASSERT(styleSize->BehavesLikeInitialValue(axisInItemWM) ||
styleSize->HasPercent(),
"Should have been caught in EnsureContributions");
@ -6142,8 +6152,8 @@ struct CachedIntrinsicSizes {
MOZ_ASSERT((aGridItem.mState[aAxis] & ItemState::eIsBaselineAligned) ||
aGridItem.mBaselineOffset[aAxis] == (nscoord)0,
"baseline offset should be zero when not baseline-aligned");
const auto styleMinSize =
stylePos->MinSize(aAxis, containerWM, positionProperty);
const auto styleMinSize = stylePos->MinSize(
aAxis, containerWM, anchorResolutionParams.mPosition);
// max-content and min-content should behave as initial value in block
// axis.
@ -10134,7 +10144,7 @@ nscoord nsGridContainerFrame::ComputeIntrinsicISize(
RepeatTrackSizingInput repeatSizing(gridRI.mWM);
if (!IsColSubgrid() && gridRI.mColFunctions.mHasRepeatAuto) {
repeatSizing.InitFromStyle(
LogicalAxis::Inline, gridRI.mWM, gridRI.mFrame->Style(),
LogicalAxis::Inline, gridRI.mWM, gridRI.mFrame, gridRI.mFrame->Style(),
gridRI.mFrame->GetAspectRatio(), aInput.mContainingBlockSize);
}
if ((!IsRowSubgrid() && gridRI.mRowFunctions.mHasRepeatAuto &&
@ -10144,7 +10154,7 @@ nscoord nsGridContainerFrame::ComputeIntrinsicISize(
// the only case where our block-size can affect the number of columns.
// Masonry layout always depends on how many rows we have though.
repeatSizing.InitFromStyle(
LogicalAxis::Block, gridRI.mWM, gridRI.mFrame->Style(),
LogicalAxis::Block, gridRI.mWM, gridRI.mFrame, gridRI.mFrame->Style(),
gridRI.mFrame->GetAspectRatio(), aInput.mContainingBlockSize);
}

79
layout/generic/nsIFrame.cpp
View file

@ -2485,17 +2485,17 @@ bool nsIFrame::CanBeDynamicReflowRoot() const {
// FIXME: For display:block, we should probably optimize inline-size: auto.
// FIXME: Other flex and grid cases?
const auto& pos = *StylePosition();
const auto positionProperty = StyleDisplay()->mPosition;
const auto width = pos.GetWidth(positionProperty);
const auto height = pos.GetHeight(positionProperty);
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
const auto width = pos.GetWidth(anchorResolutionParams.mPosition);
const auto height = pos.GetHeight(anchorResolutionParams.mPosition);
if (!width->IsLengthPercentage() || width->HasPercent() ||
!height->IsLengthPercentage() || height->HasPercent() ||
IsIntrinsicKeyword(*pos.GetMinWidth(positionProperty)) ||
IsIntrinsicKeyword(*pos.GetMaxWidth(positionProperty)) ||
IsIntrinsicKeyword(*pos.GetMinHeight(positionProperty)) ||
IsIntrinsicKeyword(*pos.GetMaxHeight(positionProperty)) ||
((pos.GetMinWidth(positionProperty)->IsAuto() ||
pos.GetMinHeight(positionProperty)->IsAuto()) &&
IsIntrinsicKeyword(*pos.GetMinWidth(anchorResolutionParams.mPosition)) ||
IsIntrinsicKeyword(*pos.GetMaxWidth(anchorResolutionParams.mPosition)) ||
IsIntrinsicKeyword(*pos.GetMinHeight(anchorResolutionParams.mPosition)) ||
IsIntrinsicKeyword(*pos.GetMaxHeight(anchorResolutionParams.mPosition)) ||
((pos.GetMinWidth(anchorResolutionParams.mPosition)->IsAuto() ||
pos.GetMinHeight(anchorResolutionParams.mPosition)->IsAuto()) &&
IsFlexOrGridItem())) {
return false;
}
@ -6394,18 +6394,21 @@ static nsIFrame::IntrinsicSizeOffsetData IntrinsicSizeOffsets(
WritingMode wm = aFrame->GetWritingMode();
bool verticalAxis = aForISize == wm.IsVertical();
const auto* styleMargin = aFrame->StyleMargin();
const auto positionProperty = aFrame->StyleDisplay()->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(aFrame);
if (verticalAxis) {
result.margin += ResolveMargin(
styleMargin->GetMargin(eSideTop, positionProperty), aPercentageBasis);
result.margin +=
ResolveMargin(styleMargin->GetMargin(eSideBottom, positionProperty),
aPercentageBasis);
styleMargin->GetMargin(eSideTop, anchorResolutionParams.mPosition),
aPercentageBasis);
result.margin += ResolveMargin(
styleMargin->GetMargin(eSideBottom, anchorResolutionParams.mPosition),
aPercentageBasis);
} else {
result.margin += ResolveMargin(
styleMargin->GetMargin(eSideLeft, positionProperty), aPercentageBasis);
styleMargin->GetMargin(eSideLeft, anchorResolutionParams.mPosition),
aPercentageBasis);
result.margin += ResolveMargin(
styleMargin->GetMargin(eSideRight, positionProperty), aPercentageBasis);
styleMargin->GetMargin(eSideRight, anchorResolutionParams.mPosition),
aPercentageBasis);
}
const auto& padding = aFrame->StylePadding()->mPadding;
@ -6524,7 +6527,7 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize(
aBorderPadding, aSizeOverrides, aFlags);
const nsStylePosition* stylePos = StylePosition();
const nsStyleDisplay* disp = StyleDisplay();
const auto positionProperty = disp->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
auto aspectRatioUsage = AspectRatioUsage::None;
const auto boxSizingAdjust = stylePos->mBoxSizing == StyleBoxSizing::Border
@ -6540,7 +6543,7 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize(
const auto styleISize =
aSizeOverrides.mStyleISize
? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleISize)
: stylePos->ISize(aWM, positionProperty);
: stylePos->ISize(aWM, anchorResolutionParams.mPosition);
// For bsize, we consider overrides *and then* we resolve 'stretch' to a
// nscoord value, for convenience (so that we can assume that either
// isAutoBSize is true, or styleBSize is of type LengthPercentage()).
@ -6548,7 +6551,7 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize(
auto styleBSizeConsideringOverrides =
(aSizeOverrides.mStyleBSize)
? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleBSize)
: stylePos->BSize(aWM, positionProperty);
: stylePos->BSize(aWM, anchorResolutionParams.mPosition);
if (styleBSizeConsideringOverrides->BehavesLikeStretchOnBlockAxis() &&
aCBSize.BSize(aWM) != NS_UNCONSTRAINEDSIZE) {
// We've got a 'stretch' BSize; resolve it to a length:
@ -6623,7 +6626,8 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize(
bool isStretchAligned = false;
bool mayUseAspectRatio = aspectRatio && !isAutoBSize;
if (!aFlags.contains(ComputeSizeFlag::ShrinkWrap) &&
!StyleMargin()->HasInlineAxisAuto(aWM, positionProperty) &&
!StyleMargin()->HasInlineAxisAuto(aWM,
anchorResolutionParams.mPosition) &&
!alignCB->IsMasonry(isOrthogonal ? LogicalAxis::Block
: LogicalAxis::Inline)) {
auto inlineAxisAlignment =
@ -6694,8 +6698,10 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize(
// generating the flex items. So here we make the code more general for both
// definite cross size and indefinite cross size.
const bool isDefiniteISize = styleISize->IsLengthPercentage();
const auto minBSizeCoord = stylePos->MinBSize(aWM, positionProperty);
const auto maxBSizeCoord = stylePos->MaxBSize(aWM, positionProperty);
const auto minBSizeCoord =
stylePos->MinBSize(aWM, anchorResolutionParams.mPosition);
const auto maxBSizeCoord =
stylePos->MaxBSize(aWM, anchorResolutionParams.mPosition);
const bool isAutoMinBSize =
nsLayoutUtils::IsAutoBSize(*minBSizeCoord, aCBSize.BSize(aWM));
const bool isAutoMaxBSize =
@ -6740,7 +6746,8 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize(
// sizing properties in that axis.
const bool shouldIgnoreMinMaxISize =
isFlexItemInlineAxisMainAxis || isSubgriddedInInlineAxis;
const auto maxISizeCoord = stylePos->MaxISize(aWM, positionProperty);
const auto maxISizeCoord =
stylePos->MaxISize(aWM, anchorResolutionParams.mPosition);
nscoord maxISize = NS_UNCONSTRAINEDSIZE;
if (!maxISizeCoord->IsNone() && !shouldIgnoreMinMaxISize) {
maxISize =
@ -6758,7 +6765,8 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize(
aRenderingContext, Some(aCBSize.ConvertTo(GetWritingMode(), aWM)),
Some(LogicalSize(aWM, NS_UNCONSTRAINEDSIZE, bSizeAsPercentageBasis)
.ConvertTo(GetWritingMode(), aWM)));
const auto minISizeCoord = stylePos->MinISize(aWM, positionProperty);
const auto minISizeCoord =
stylePos->MinISize(aWM, anchorResolutionParams.mPosition);
nscoord minISize;
if (!minISizeCoord->IsAuto() && !shouldIgnoreMinMaxISize) {
minISize =
@ -6832,7 +6840,8 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize(
bool isStretchAligned = false;
bool mayUseAspectRatio =
aspectRatio && result.ISize(aWM) != NS_UNCONSTRAINEDSIZE;
if (!StyleMargin()->HasBlockAxisAuto(aWM, positionProperty)) {
if (!StyleMargin()->HasBlockAxisAuto(aWM,
anchorResolutionParams.mPosition)) {
auto blockAxisAlignment =
isOrthogonal ? StylePosition()->UsedJustifySelf(alignCB->Style())._0
: StylePosition()->UsedAlignSelf(alignCB->Style())._0;
@ -6991,12 +7000,12 @@ LogicalSize nsIFrame::ComputeAutoSize(
// Use basic shrink-wrapping as a default implementation.
LogicalSize result(aWM, 0xdeadbeef, NS_UNCONSTRAINEDSIZE);
const auto positionProperty = StyleDisplay()->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
// don't bother setting it if the result won't be used
const auto styleISize =
aSizeOverrides.mStyleISize
? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleISize)
: StylePosition()->ISize(aWM, positionProperty);
: StylePosition()->ISize(aWM, anchorResolutionParams.mPosition);
if (styleISize->IsAuto()) {
nscoord availBased = nsLayoutUtils::ComputeStretchContentBoxISize(
aAvailableISize, aMargin.ISize(aWM), aBorderPadding.ISize(aWM));
@ -7004,14 +7013,14 @@ LogicalSize nsIFrame::ComputeAutoSize(
const auto styleBSize =
aSizeOverrides.mStyleBSize
? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleBSize)
: stylePos->BSize(aWM, positionProperty);
: stylePos->BSize(aWM, anchorResolutionParams.mPosition);
const LogicalSize contentEdgeToBoxSizing =
stylePos->mBoxSizing == StyleBoxSizing::Border ? aBorderPadding
: LogicalSize(aWM);
const nscoord bSize = ComputeBSizeValueAsPercentageBasis(
*styleBSize, *stylePos->MinBSize(aWM, positionProperty),
*stylePos->MaxBSize(aWM, positionProperty), aCBSize.BSize(aWM),
contentEdgeToBoxSizing.BSize(aWM));
*styleBSize, *stylePos->MinBSize(aWM, anchorResolutionParams.mPosition),
*stylePos->MaxBSize(aWM, anchorResolutionParams.mPosition),
aCBSize.BSize(aWM), contentEdgeToBoxSizing.BSize(aWM));
const IntrinsicSizeInput input(
aRenderingContext, Some(aCBSize.ConvertTo(GetWritingMode(), aWM)),
Some(LogicalSize(aWM, NS_UNCONSTRAINEDSIZE, bSize)
@ -7299,11 +7308,11 @@ nsIFrame::ISizeComputationResult nsIFrame::ComputeISizeValue(
}();
const auto* stylePos = StylePosition();
const auto positionProperty = StyleDisplay()->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
const nscoord bSize = ComputeBSizeValueAsPercentageBasis(
aStyleBSize, *stylePos->MinBSize(aWM, positionProperty),
*stylePos->MaxBSize(aWM, positionProperty), aCBSize.BSize(aWM),
aContentEdgeToBoxSizing.BSize(aWM));
aStyleBSize, *stylePos->MinBSize(aWM, anchorResolutionParams.mPosition),
*stylePos->MaxBSize(aWM, anchorResolutionParams.mPosition),
aCBSize.BSize(aWM), aContentEdgeToBoxSizing.BSize(aWM));
const IntrinsicSizeInput input(
aRenderingContext, Some(aCBSize.ConvertTo(GetWritingMode(), aWM)),
Some(LogicalSize(aWM, NS_UNCONSTRAINEDSIZE, bSize)

15
layout/generic/nsImageFrame.cpp
View file

@ -356,7 +356,8 @@ static bool DependsOnIntrinsicSize(const SizeOrMaxSize& aMinOrMaxSize) {
// image's intrinsic size changing.
static bool SizeDependsOnIntrinsicSize(const ReflowInput& aReflowInput) {
const auto& position = *aReflowInput.mStylePosition;
const auto positionProperty = aReflowInput.mStyleDisplay->mPosition;
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(&aReflowInput);
WritingMode wm = aReflowInput.GetWritingMode();
// Don't try to make this optimization when an image has percentages
// in its 'width' or 'height'. The percentages might be treated like
@ -367,10 +368,14 @@ static bool SizeDependsOnIntrinsicSize(const ReflowInput& aReflowInput) {
// don't need to check them.
//
// Flex item's min-[width|height]:auto resolution depends on intrinsic size.
return !position.GetHeight(positionProperty)->ConvertsToLength() ||
!position.GetWidth(positionProperty)->ConvertsToLength() ||
DependsOnIntrinsicSize(*position.MinISize(wm, positionProperty)) ||
DependsOnIntrinsicSize(*position.MaxISize(wm, positionProperty)) ||
return !position.GetHeight(anchorResolutionParams.mPosition)
->ConvertsToLength() ||
!position.GetWidth(anchorResolutionParams.mPosition)
->ConvertsToLength() ||
DependsOnIntrinsicSize(
*position.MinISize(wm, anchorResolutionParams.mPosition)) ||
DependsOnIntrinsicSize(
*position.MaxISize(wm, anchorResolutionParams.mPosition)) ||
aReflowInput.mFrame->IsFlexItem();
}

4
layout/generic/nsInlineFrame.cpp
View file

@ -89,7 +89,7 @@ bool nsInlineFrame::IsSelfEmpty() {
const nsStyleMargin* margin = StyleMargin();
const nsStyleBorder* border = StyleBorder();
const nsStylePadding* padding = StylePadding();
const auto positionProperty = StyleDisplay()->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
// Block-start and -end ignored, since they shouldn't affect things, but this
// doesn't really match with nsLineLayout.cpp's setting of
// ZeroEffectiveSpanBox, anymore, so what should this really be?
@ -110,7 +110,7 @@ bool nsInlineFrame::IsSelfEmpty() {
auto HaveSide = [&](mozilla::Side aSide) -> bool {
return border->GetComputedBorderWidth(aSide) != 0 ||
!nsLayoutUtils::IsPaddingZero(padding->mPadding.Get(aSide)) ||
!IsMarginZero(*margin, positionProperty, aSide);
!IsMarginZero(*margin, anchorResolutionParams.mPosition, aSide);
};
// Initially set up haveStart and haveEnd in terms of visual (LTR/TTB)
// coordinates; we'll exchange them later if bidi-RTL is in effect to

16
layout/generic/nsLineLayout.cpp
View file

@ -654,9 +654,8 @@ static bool IsPercentageAware(const nsIFrame* aFrame, WritingMode aWM) {
// quite rarely.
const nsStyleMargin* margin = aFrame->StyleMargin();
const auto anchorPosResolutionParams =
AnchorPosResolutionParams::From(aFrame);
if (HasPercentageUnitMargin(*margin, anchorPosResolutionParams.mPosition)) {
const auto anchorResolutionParams = AnchorPosResolutionParams::From(aFrame);
if (HasPercentageUnitMargin(*margin, anchorResolutionParams.mPosition)) {
return true;
}
@ -668,15 +667,14 @@ static bool IsPercentageAware(const nsIFrame* aFrame, WritingMode aWM) {
// Note that borders can't be aware of percentages
const nsStylePosition* pos = aFrame->StylePosition();
const auto iSize = pos->ISize(aWM, anchorPosResolutionParams.mPosition);
const auto iSize = pos->ISize(aWM, anchorResolutionParams.mPosition);
const auto anchorOffsetResolutionParams =
AnchorPosOffsetResolutionParams::UseCBFrameSize(
anchorPosResolutionParams);
AnchorPosOffsetResolutionParams::UseCBFrameSize(anchorResolutionParams);
if ((nsStylePosition::ISizeDependsOnContainer(iSize) && !iSize->IsAuto()) ||
nsStylePosition::MaxISizeDependsOnContainer(
pos->MaxISize(aWM, anchorPosResolutionParams.mPosition)) ||
pos->MaxISize(aWM, anchorResolutionParams.mPosition)) ||
nsStylePosition::MinISizeDependsOnContainer(
pos->MinISize(aWM, anchorPosResolutionParams.mPosition)) ||
pos->MinISize(aWM, anchorResolutionParams.mPosition)) ||
pos->GetAnchorResolvedInset(LogicalSide::IStart, aWM,
anchorOffsetResolutionParams)
->HasPercent() ||
@ -709,7 +707,7 @@ static bool IsPercentageAware(const nsIFrame* aFrame, WritingMode aWM) {
nsIFrame* f = const_cast<nsIFrame*>(aFrame);
if (f->GetAspectRatio() &&
// Some percents are treated like 'auto', so check != coord
!pos->BSize(aWM, anchorPosResolutionParams.mPosition)
!pos->BSize(aWM, anchorResolutionParams.mPosition)
->ConvertsToLength()) {
const IntrinsicSize& intrinsicSize = f->GetIntrinsicSize();
if (!intrinsicSize.width && !intrinsicSize.height) {

6
layout/generic/nsPageFrame.cpp
View file

@ -124,10 +124,12 @@ nsReflowStatus nsPageFrame::ReflowPageContent(
// that we will respect a margin of zero if specified, assuming this means
// the document is intended to fit the paper size exactly, and the client is
// taking full responsibility for what happens around the edges.
const auto positionProperty = kidReflowInput.mStyleDisplay->mPosition;
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(&kidReflowInput);
if (mPD->mPrintSettings->GetHonorPageRuleMargins()) {
for (const auto side : mozilla::AllPhysicalSides()) {
if (!kidReflowInput.mStyleMargin->GetMargin(side, positionProperty)
if (!kidReflowInput.mStyleMargin
->GetMargin(side, anchorResolutionParams.mPosition)
->IsAuto()) {
// Computed margins are already in the coordinate space of the content,
// do not scale.

6
layout/generic/nsSubDocumentFrame.cpp
View file

@ -1283,10 +1283,10 @@ nsPoint nsSubDocumentFrame::GetExtraOffset() const {
void nsSubDocumentFrame::SubdocumentIntrinsicSizeOrRatioChanged() {
const nsStylePosition* pos = StylePosition();
const auto positionProperty = StyleDisplay()->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
bool dependsOnIntrinsics =
!pos->GetWidth(positionProperty)->ConvertsToLength() ||
!pos->GetHeight(positionProperty)->ConvertsToLength();
!pos->GetWidth(anchorResolutionParams.mPosition)->ConvertsToLength() ||
!pos->GetHeight(anchorResolutionParams.mPosition)->ConvertsToLength();
if (dependsOnIntrinsics || pos->mObjectFit != StyleObjectFit::Fill) {
auto dirtyHint = dependsOnIntrinsics

7
layout/generic/nsTextFrame.cpp
View file

@ -1909,7 +1909,8 @@ bool BuildTextRunsScanner::ContinueTextRunAcrossFrames(nsTextFrame* aFrame1,
Side aSide) {
while (aFrame != aAncestor) {
ComputedStyle* ctx = aFrame->Style();
const auto positionProperty = ctx->StyleDisplay()->mPosition;
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(aFrame);
// According to https://drafts.csswg.org/css-text/#boundary-shaping:
//
// Text shaping must be broken at inline box boundaries when any of
@ -1918,8 +1919,8 @@ bool BuildTextRunsScanner::ContinueTextRunAcrossFrames(nsTextFrame* aFrame1,
//
// 1. Any of margin/border/padding separating the two typographic
// character units in the inline axis is non-zero.
const auto margin =
ctx->StyleMargin()->GetMargin(aSide, positionProperty);
const auto margin = ctx->StyleMargin()->GetMargin(
aSide, anchorResolutionParams.mPosition);
if (!margin->ConvertsToLength() ||
margin->AsLengthPercentage().ToLength() != 0) {
return true;

8
layout/inspector/InspectorUtils.cpp
View file

@ -903,10 +903,12 @@ static bool FrameHasSpecifiedSize(const nsIFrame* aFrame) {
auto wm = aFrame->GetWritingMode();
const nsStylePosition* stylePos = aFrame->StylePosition();
const auto positionProperty = aFrame->StyleDisplay()->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(aFrame);
return stylePos->ISize(wm, positionProperty)->IsLengthPercentage() ||
stylePos->BSize(wm, positionProperty)->IsLengthPercentage();
return stylePos->ISize(wm, anchorResolutionParams.mPosition)
->IsLengthPercentage() ||
stylePos->BSize(wm, anchorResolutionParams.mPosition)
->IsLengthPercentage();
}
static bool IsFrameOutsideOfAncestor(const nsIFrame* aFrame,

10
layout/svg/SVGForeignObjectFrame.cpp
View file

@ -296,11 +296,15 @@ void SVGForeignObjectFrame::NotifySVGChanged(uint32_t aFlags) {
needNewCanvasTM = true;
}
const auto positionProperty = StyleDisplay()->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(this);
// Our coordinate context's width/height has changed. If we have a
// percentage width/height our dimensions will change so we must reflow.
if (StylePosition()->GetWidth(positionProperty)->HasPercent() ||
StylePosition()->GetHeight(positionProperty)->HasPercent()) {
if (StylePosition()
->GetWidth(anchorResolutionParams.mPosition)
->HasPercent() ||
StylePosition()
->GetHeight(anchorResolutionParams.mPosition)
->HasPercent()) {
needNewBounds = true;
needReflow = true;
}

40
layout/tables/BasicTableLayoutStrategy.cpp
View file

@ -79,7 +79,7 @@ static CellISizeInfo GetISizeInfo(gfxContext* aRenderingContext,
"The caller is expected to pass aFrame's writing mode!");
nscoord minCoord, prefCoord;
const nsStylePosition* stylePos = aFrame->StylePosition();
const auto positionProperty = aFrame->StyleDisplay()->mPosition;
const auto anchorResolutionParams = AnchorPosResolutionParams::From(aFrame);
bool isQuirks =
aFrame->PresContext()->CompatibilityMode() == eCompatibility_NavQuirks;
nscoord boxSizingToBorderEdge = 0;
@ -104,9 +104,9 @@ static CellISizeInfo GetISizeInfo(gfxContext* aRenderingContext,
? aFrame->IntrinsicBSizeOffsets().BorderPadding()
: 0;
const nscoord cellBSize = nsIFrame::ComputeBSizeValueAsPercentageBasis(
*stylePos->BSize(aWM, positionProperty),
*stylePos->MinBSize(aWM, positionProperty),
*stylePos->MaxBSize(aWM, positionProperty), cbBSize,
*stylePos->BSize(aWM, anchorResolutionParams.mPosition),
*stylePos->MinBSize(aWM, anchorResolutionParams.mPosition),
*stylePos->MaxBSize(aWM, anchorResolutionParams.mPosition), cbBSize,
contentEdgeToBoxSizingBSize);
const IntrinsicSizeInput input(
@ -137,7 +137,7 @@ static CellISizeInfo GetISizeInfo(gfxContext* aRenderingContext,
float prefPercent = 0.0f;
bool hasSpecifiedISize = false;
const auto iSize = stylePos->ISize(aWM, positionProperty);
const auto iSize = stylePos->ISize(aWM, anchorResolutionParams.mPosition);
// NOTE: We're ignoring calc() units with both lengths and percentages here,
// for lack of a sensible idea for what to do with them. This means calc()
// with percentages is basically handled like 'auto' for table cells and
@ -180,7 +180,7 @@ static CellISizeInfo GetISizeInfo(gfxContext* aRenderingContext,
}
}
auto maxISize = stylePos->MaxISize(aWM, positionProperty);
auto maxISize = stylePos->MaxISize(aWM, anchorResolutionParams.mPosition);
if (nsIFrame::ToExtremumLength(*maxISize)) {
if (!aIsCell || maxISize->BehavesLikeStretchOnInlineAxis()) {
maxISize = AnchorResolvedMaxSizeHelper::None();
@ -194,12 +194,13 @@ static CellISizeInfo GetISizeInfo(gfxContext* aRenderingContext,
// it separately on the columns.
const LogicalSize zeroSize(aWM);
if (maxISize->ConvertsToLength() || nsIFrame::ToExtremumLength(*maxISize)) {
nscoord c = aFrame
->ComputeISizeValue(aRenderingContext, aWM, zeroSize,
zeroSize, 0, *maxISize,
*stylePos->BSize(aWM, positionProperty),
aFrame->GetAspectRatio())
.mISize;
nscoord c =
aFrame
->ComputeISizeValue(
aRenderingContext, aWM, zeroSize, zeroSize, 0, *maxISize,
*stylePos->BSize(aWM, anchorResolutionParams.mPosition),
aFrame->GetAspectRatio())
.mISize;
minCoord = std::min(c, minCoord);
prefCoord = std::min(c, prefCoord);
} else if (maxISize->ConvertsToPercentage()) {
@ -209,7 +210,7 @@ static CellISizeInfo GetISizeInfo(gfxContext* aRenderingContext,
}
}
auto minISize = stylePos->MinISize(aWM, positionProperty);
auto minISize = stylePos->MinISize(aWM, anchorResolutionParams.mPosition);
if (nsIFrame::ToExtremumLength(*maxISize)) {
if (!aIsCell || minISize->BehavesLikeStretchOnInlineAxis()) {
minISize = AnchorResolvedSizeHelper::Zero();
@ -221,12 +222,13 @@ static CellISizeInfo GetISizeInfo(gfxContext* aRenderingContext,
}
if (minISize->ConvertsToLength() || nsIFrame::ToExtremumLength(*minISize)) {
nscoord c = aFrame
->ComputeISizeValue(aRenderingContext, aWM, zeroSize,
zeroSize, 0, *minISize,
*stylePos->BSize(aWM, positionProperty),
aFrame->GetAspectRatio())
.mISize;
nscoord c =
aFrame
->ComputeISizeValue(
aRenderingContext, aWM, zeroSize, zeroSize, 0, *minISize,
*stylePos->BSize(aWM, anchorResolutionParams.mPosition),
aFrame->GetAspectRatio())
.mISize;
minCoord = std::max(c, minCoord);
prefCoord = std::max(c, prefCoord);
} else if (minISize->ConvertsToPercentage()) {

14
layout/tables/nsTableFrame.cpp
View file

@ -3642,18 +3642,18 @@ bool nsTableFrame::ColumnHasCellSpacingBefore(int32_t aColIndex) const {
// Check if we have a <col> element with a non-zero definite inline size.
// Note: percentages and calc(%) are intentionally not considered.
if (const auto* col = fif->GetColFrame(aColIndex)) {
const auto positionProperty = col->StyleDisplay()->mPosition;
const auto iSize =
col->StylePosition()->ISize(GetWritingMode(), positionProperty);
const auto anchorResolutionParams = AnchorPosResolutionParams::From(col);
const auto iSize = col->StylePosition()->ISize(
GetWritingMode(), anchorResolutionParams.mPosition);
if (iSize->ConvertsToLength() && iSize->ToLength() > 0) {
const auto maxISize =
col->StylePosition()->MaxISize(GetWritingMode(), positionProperty);
const auto maxISize = col->StylePosition()->MaxISize(
GetWritingMode(), anchorResolutionParams.mPosition);
if (!maxISize->ConvertsToLength() || maxISize->ToLength() > 0) {
return true;
}
}
const auto minISize =
col->StylePosition()->MinISize(GetWritingMode(), positionProperty);
const auto minISize = col->StylePosition()->MinISize(
GetWritingMode(), anchorResolutionParams.mPosition);
if (minISize->ConvertsToLength() && minISize->ToLength() > 0) {
return true;
}

21
layout/xul/nsSplitterFrame.cpp
View file

@ -637,15 +637,20 @@ nsresult nsSplitterFrameInner::MouseDown(Event* aMouseEvent) {
nsSize curSize = childBox->GetSize();
const auto& pos = *childBox->StylePosition();
const auto positionProperty = childBox->StyleDisplay()->mPosition;
nsSize minSize = ToLengthWithFallback(*pos.GetMinWidth(positionProperty),
*pos.GetMinHeight(positionProperty));
nsSize maxSize = ToLengthWithFallback(*pos.GetMaxWidth(positionProperty),
*pos.GetMaxHeight(positionProperty),
NS_UNCONSTRAINEDSIZE);
const auto anchorResolutionParams =
AnchorPosResolutionParams::From(childBox);
nsSize minSize = ToLengthWithFallback(
*pos.GetMinWidth(anchorResolutionParams.mPosition),
*pos.GetMinHeight(anchorResolutionParams.mPosition));
nsSize maxSize = ToLengthWithFallback(
*pos.GetMaxWidth(anchorResolutionParams.mPosition),
*pos.GetMaxHeight(anchorResolutionParams.mPosition),
NS_UNCONSTRAINEDSIZE);
nsSize prefSize(
ToLengthWithFallback(*pos.GetWidth(positionProperty), curSize.width),
ToLengthWithFallback(*pos.GetHeight(positionProperty), curSize.height));
ToLengthWithFallback(*pos.GetWidth(anchorResolutionParams.mPosition),
curSize.width),
ToLengthWithFallback(*pos.GetHeight(anchorResolutionParams.mPosition),
curSize.height));
maxSize.width = std::max(maxSize.width, minSize.width);
maxSize.height = std::max(maxSize.height, minSize.height);

43
layout/xul/tree/nsTreeBodyFrame.cpp
View file

@ -1948,8 +1948,9 @@ nsRect nsTreeBodyFrame::GetImageSize(int32_t aRowIndex, nsTreeColumn* aCol,
GetImage(aRowIndex, aCol, aUseContext, aComputedStyle);
const nsStylePosition* myPosition = aComputedStyle->StylePosition();
const auto positionProperty = aComputedStyle->StyleDisplay()->mPosition;
const auto width = myPosition->GetWidth(positionProperty);
const AnchorPosResolutionParams anchorResolutionParams{
this, aComputedStyle->StyleDisplay()->mPosition};
const auto width = myPosition->GetWidth(anchorResolutionParams.mPosition);
if (width->ConvertsToLength()) {
int32_t val = width->ToLength();
r.width += val;
@ -1957,7 +1958,7 @@ nsRect nsTreeBodyFrame::GetImageSize(int32_t aRowIndex, nsTreeColumn* aCol,
needWidth = true;
}
const auto height = myPosition->GetHeight(positionProperty);
const auto height = myPosition->GetHeight(anchorResolutionParams.mPosition);
if (height->ConvertsToLength()) {
int32_t val = height->ToLength();
r.height += val;
@ -2009,8 +2010,9 @@ nsSize nsTreeBodyFrame::GetImageDestSize(ComputedStyle* aComputedStyle,
// Get the style position to see if the CSS has specified the
// destination width/height.
const nsStylePosition* myPosition = aComputedStyle->StylePosition();
const auto positionProperty = aComputedStyle->StyleDisplay()->mPosition;
const auto width = myPosition->GetWidth(positionProperty);
const AnchorPosResolutionParams anchorResolutionParams{
this, aComputedStyle->StyleDisplay()->mPosition};
const auto width = myPosition->GetWidth(anchorResolutionParams.mPosition);
if (width->ConvertsToLength()) {
// CSS has specified the destination width.
size.width = width->ToLength();
@ -2019,7 +2021,7 @@ nsSize nsTreeBodyFrame::GetImageDestSize(ComputedStyle* aComputedStyle,
needWidth = true;
}
const auto height = myPosition->GetHeight(positionProperty);
const auto height = myPosition->GetHeight(anchorResolutionParams.mPosition);
if (height->ConvertsToLength()) {
// CSS has specified the destination height.
size.height = height->ToLength();
@ -2099,16 +2101,19 @@ int32_t nsTreeBodyFrame::GetRowHeight() {
GetPseudoComputedStyle(nsCSSAnonBoxes::mozTreeRow());
if (rowContext) {
const nsStylePosition* myPosition = rowContext->StylePosition();
const auto positionProperty = rowContext->StyleDisplay()->mPosition;
const AnchorPosResolutionParams anchorResolutionParams{
this, rowContext->StyleDisplay()->mPosition};
nscoord minHeight = 0;
const auto styleMinHeight = myPosition->GetMinHeight(positionProperty);
const auto styleMinHeight =
myPosition->GetMinHeight(anchorResolutionParams.mPosition);
if (styleMinHeight->ConvertsToLength()) {
minHeight = styleMinHeight->ToLength();
}
nscoord height = 0;
const auto styleHeight = myPosition->GetHeight(positionProperty);
const auto styleHeight =
myPosition->GetHeight(anchorResolutionParams.mPosition);
if (styleHeight->ConvertsToLength()) {
height = styleHeight->ToLength();
}
@ -2144,8 +2149,9 @@ int32_t nsTreeBodyFrame::GetIndentation() {
GetPseudoComputedStyle(nsCSSAnonBoxes::mozTreeIndentation());
if (indentContext) {
const nsStylePosition* myPosition = indentContext->StylePosition();
const auto positionProperty = indentContext->StyleDisplay()->mPosition;
const auto width = myPosition->GetWidth(positionProperty);
const AnchorPosResolutionParams anchorResolutionParams{
this, indentContext->StyleDisplay()->mPosition};
const auto width = myPosition->GetWidth(anchorResolutionParams.mPosition);
if (width->ConvertsToLength()) {
return width->ToLength();
}
@ -2772,11 +2778,13 @@ ImgDrawResult nsTreeBodyFrame::PaintSeparator(int32_t aRowIndex,
GetPseudoComputedStyle(nsCSSAnonBoxes::mozTreeSeparator());
const nsStylePosition* stylePosition = separatorContext->StylePosition();
const auto positionProperty = separatorContext->StyleDisplay()->mPosition;
const AnchorPosResolutionParams anchorResolutionParams{
this, separatorContext->StyleDisplay()->mPosition};
// Obtain the height for the separator or use the default value.
nscoord height;
const auto styleHeight = stylePosition->GetHeight(positionProperty);
const auto styleHeight =
stylePosition->GetHeight(anchorResolutionParams.mPosition);
if (styleHeight->ConvertsToLength()) {
height = styleHeight->ToLength();
} else {
@ -3512,8 +3520,10 @@ ImgDrawResult nsTreeBodyFrame::PaintDropFeedback(
// Obtain the width for the drop feedback or use default value.
nscoord width;
const auto positionProperty = feedbackContext->StyleDisplay()->mPosition;
const auto styleWidth = stylePosition->GetWidth(positionProperty);
const AnchorPosResolutionParams anchorResolutionParams{
this, feedbackContext->StyleDisplay()->mPosition};
const auto styleWidth =
stylePosition->GetWidth(anchorResolutionParams.mPosition);
if (styleWidth->ConvertsToLength()) {
width = styleWidth->ToLength();
} else {
@ -3523,7 +3533,8 @@ ImgDrawResult nsTreeBodyFrame::PaintDropFeedback(
// Obtain the height for the drop feedback or use default value.
nscoord height;
const auto styleHeight = stylePosition->GetHeight(positionProperty);
const auto styleHeight =
stylePosition->GetHeight(anchorResolutionParams.mPosition);
if (styleHeight->ConvertsToLength()) {
height = styleHeight->ToLength();
} else {