commit a08fe7ba212e959f5056c0eb13c510a3a8ebf60c
parent 62ad52e72505d187d266a4f27b20616b19045459
Author: Ting-Yu Lin <tlin@mozilla.com>
Date: Wed, 19 Nov 2025 05:08:18 +0000
Bug 2000488 - Use nsStylePosition::UsedSelfAlignment() to simplify code. r=layout-reviewers,jfkthame
Note: `justif-self` and `align-self` operates on the alignment container's axis.
See https://drafts.csswg.org/css-align-3/#justify-self-property and
https://drafts.csswg.org/css-align-3/#align-self-property
Differential Revision: https://phabricator.services.mozilla.com/D272825
Diffstat:
5 files changed, 61 insertions(+), 44 deletions(-)
diff --git a/layout/generic/WritingModes.h b/layout/generic/WritingModes.h
@@ -2329,9 +2329,20 @@ inline AnchorResolvedMargin nsStyleMargin::GetMargin(
}
inline mozilla::StyleAlignFlags nsStylePosition::UsedSelfAlignment(
- mozilla::LogicalAxis aAxis, const mozilla::ComputedStyle* aParent) const {
- return aAxis == mozilla::LogicalAxis::Block ? UsedAlignSelf(aParent)._0
- : UsedJustifySelf(aParent)._0;
+ LogicalAxis aAlignContainerAxis,
+ const ComputedStyle* aAlignContainerStyle) const {
+ return aAlignContainerAxis == LogicalAxis::Block
+ ? UsedAlignSelf(aAlignContainerStyle)._0
+ : UsedJustifySelf(aAlignContainerStyle)._0;
+}
+
+inline mozilla::StyleAlignFlags nsStylePosition::UsedSelfAlignment(
+ WritingMode aAlignSubjectWM, LogicalAxis aAlignSubjectAxis,
+ WritingMode aAlignContainerWM,
+ const ComputedStyle* aAlignContainerStyle) const {
+ const auto alignContainerAxis =
+ aAlignSubjectWM.ConvertAxisTo(aAlignSubjectAxis, aAlignContainerWM);
+ return UsedSelfAlignment(alignContainerAxis, aAlignContainerStyle);
}
inline mozilla::StyleContentDistribution nsStylePosition::UsedContentAlignment(
diff --git a/layout/generic/nsContainerFrame.cpp b/layout/generic/nsContainerFrame.cpp
@@ -2038,7 +2038,6 @@ LogicalSize nsContainerFrame::ComputeSizeWithIntrinsicDimensions(
FillCB inlineFillCB = FillCB::No; // fill CB behavior in the inline axis
FillCB blockFillCB = FillCB::No; // fill CB behavior in the block axis
- const bool isOrthogonal = aWM.IsOrthogonalTo(parentFrame->GetWritingMode());
const LogicalSize fallbackIntrinsicSize(aWM, kFallbackIntrinsicSize);
const Maybe<nscoord>& maybeIntrinsicISize = aIntrinsicSize.ISize(aWM);
const bool hasIntrinsicISize = maybeIntrinsicISize.isSome();
@@ -2063,9 +2062,9 @@ LogicalSize nsContainerFrame::ComputeSizeWithIntrinsicDimensions(
if (cbSize != NS_UNCONSTRAINEDSIZE) {
if (!StyleMargin()->HasInlineAxisAuto(
aWM, AnchorPosResolutionParams::From(this))) {
- auto inlineAxisAlignment =
- isOrthogonal ? stylePos->UsedAlignSelf(GetParent()->Style())._0
- : stylePos->UsedJustifySelf(GetParent()->Style())._0;
+ auto inlineAxisAlignment = stylePos->UsedSelfAlignment(
+ aWM, LogicalAxis::Inline, parentFrame->GetWritingMode(),
+ parentFrame->Style());
if (inlineAxisAlignment == StyleAlignFlags::STRETCH) {
inlineFillCB = FillCB::Stretch;
}
@@ -2125,9 +2124,9 @@ LogicalSize nsContainerFrame::ComputeSizeWithIntrinsicDimensions(
if (cbSize != NS_UNCONSTRAINEDSIZE) {
if (!StyleMargin()->HasBlockAxisAuto(
aWM, AnchorPosResolutionParams::From(this))) {
- auto blockAxisAlignment =
- !isOrthogonal ? stylePos->UsedAlignSelf(GetParent()->Style())._0
- : stylePos->UsedJustifySelf(GetParent()->Style())._0;
+ auto blockAxisAlignment = stylePos->UsedSelfAlignment(
+ aWM, LogicalAxis::Block, parentFrame->GetWritingMode(),
+ parentFrame->Style());
if (blockAxisAlignment == StyleAlignFlags::STRETCH) {
blockFillCB = FillCB::Stretch;
}
@@ -2491,10 +2490,7 @@ StyleAlignFlags nsContainerFrame::CSSAlignmentForAbsPosChild(
// For computing the static position of an absolutely positioned box,
// `auto` takes from parent's `align-items`.
StyleAlignFlags alignment =
- (aLogicalAxis == LogicalAxis::Inline)
- ? aChildRI.mStylePosition->UsedJustifySelf(Style())._0
- : aChildRI.mStylePosition->UsedAlignSelf(Style())._0;
-
+ aChildRI.mStylePosition->UsedSelfAlignment(aLogicalAxis, Style());
return MapCSSAlignment(alignment, aChildRI, aLogicalAxis, GetWritingMode());
}
@@ -2508,9 +2504,7 @@ nsContainerFrame::CSSAlignmentForAbsPosChildWithinContainingBlock(
// When determining the position of absolutely-positioned boxes,
// `auto` behaves as `normal`.
StyleAlignFlags alignment =
- (aLogicalAxis == LogicalAxis::Inline)
- ? aChildRI.mStylePosition->UsedJustifySelf(nullptr)._0
- : aChildRI.mStylePosition->UsedAlignSelf(nullptr)._0;
+ aChildRI.mStylePosition->UsedSelfAlignment(aLogicalAxis, nullptr);
// Check if position-area is set - if so, it determines the default alignment
// https://drafts.csswg.org/css-anchor-position/#position-area-alignment
diff --git a/layout/generic/nsGridContainerFrame.cpp b/layout/generic/nsGridContainerFrame.cpp
@@ -6499,9 +6499,7 @@ void nsGridContainerFrame::Tracks::InitializeItemBaselines(
// [align|justify]-self:[last ]baseline.
auto selfAlignment =
- isInlineAxis
- ? child->StylePosition()->UsedJustifySelf(containerStyle)._0
- : child->StylePosition()->UsedAlignSelf(containerStyle)._0;
+ child->StylePosition()->UsedSelfAlignment(mAxis, containerStyle);
selfAlignment &= ~StyleAlignFlags::FLAG_BITS;
if (selfAlignment == StyleAlignFlags::BASELINE) {
state |= ItemState::eFirstBaseline | ItemState::eSelfBaseline;
@@ -10638,7 +10636,6 @@ bool nsGridContainerFrame::GridItemShouldStretch(const nsIFrame* aChild,
}
const auto cbwm = GetWritingMode();
- const bool isOrthogonal = wm.IsOrthogonalTo(cbwm);
if (IsMasonry(wm, aAxis)) {
// The child is in the container's masonry-axis.
// AlignJustifyTracksInMasonryAxis will stretch it, so we don't report that
@@ -10646,10 +10643,8 @@ bool nsGridContainerFrame::GridItemShouldStretch(const nsIFrame* aChild,
return false;
}
- const auto* pos = aChild->StylePosition();
- const auto alignment = (aAxis == LogicalAxis::Inline) == !isOrthogonal
- ? pos->UsedJustifySelf(Style())._0
- : pos->UsedAlignSelf(Style())._0;
+ const auto alignment =
+ aChild->StylePosition()->UsedSelfAlignment(wm, aAxis, cbwm, Style());
// An item with 'normal' alignment that is a replaced frame should use its
// natural size, and not fill the grid area.
// https://drafts.csswg.org/css-grid-2/#grid-item-sizing
diff --git a/layout/generic/nsIFrame.cpp b/layout/generic/nsIFrame.cpp
@@ -6650,7 +6650,6 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize(
: LogicalAxis::Block);
}
- const bool isOrthogonal = aWM.IsOrthogonalTo(alignCB->GetWritingMode());
const bool isAutoISize = styleISize->IsAuto();
const bool isAutoBSize =
nsLayoutUtils::IsAutoBSize(*styleBSize, aCBSize.BSize(aWM));
@@ -6683,9 +6682,9 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize(
if (!aFlags.contains(ComputeSizeFlag::ShrinkWrap) &&
!StyleMargin()->HasInlineAxisAuto(aWM, anchorResolutionParams) &&
!alignCB->IsMasonry(aWM, LogicalAxis::Inline)) {
- auto inlineAxisAlignment =
- isOrthogonal ? StylePosition()->UsedAlignSelf(alignCB->Style())._0
- : StylePosition()->UsedJustifySelf(alignCB->Style())._0;
+ auto inlineAxisAlignment = stylePos->UsedSelfAlignment(
+ aWM, LogicalAxis::Inline, alignCB->GetWritingMode(),
+ alignCB->Style());
isStretchAligned = inlineAxisAlignment == StyleAlignFlags::STRETCH ||
(inlineAxisAlignment == StyleAlignFlags::NORMAL &&
!mayUseAspectRatio);
@@ -6891,9 +6890,9 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize(
bool mayUseAspectRatio =
aspectRatio && result.ISize(aWM) != NS_UNCONSTRAINEDSIZE;
if (!StyleMargin()->HasBlockAxisAuto(aWM, anchorResolutionParams)) {
- auto blockAxisAlignment =
- isOrthogonal ? StylePosition()->UsedJustifySelf(alignCB->Style())._0
- : StylePosition()->UsedAlignSelf(alignCB->Style())._0;
+ auto blockAxisAlignment = stylePos->UsedSelfAlignment(
+ aWM, LogicalAxis::Block, alignCB->GetWritingMode(),
+ alignCB->Style());
isStretchAligned = blockAxisAlignment == StyleAlignFlags::STRETCH ||
(blockAxisAlignment == StyleAlignFlags::NORMAL &&
!mayUseAspectRatio);
@@ -7171,16 +7170,14 @@ LogicalSize nsIFrame::ComputeAbsolutePosAutoSize(
const auto parentWM = parent->GetWritingMode();
// Self alignment properties translate `auto` to normal for this purpose.
// https://drafts.csswg.org/css-align-3/#valdef-justify-self-auto
- const auto inlineAlignSelf = parentWM.IsOrthogonalTo(aWM)
- ? stylePos->UsedAlignSelf(nullptr)
- : stylePos->UsedJustifySelf(nullptr);
- const auto blockAlignSelf = parentWM.IsOrthogonalTo(aWM)
- ? stylePos->UsedJustifySelf(nullptr)
- : stylePos->UsedAlignSelf(nullptr);
+ const auto inlineSelfAlign =
+ stylePos->UsedSelfAlignment(aWM, LogicalAxis::Inline, parentWM, nullptr);
+ const auto blockSelfAlign =
+ stylePos->UsedSelfAlignment(aWM, LogicalAxis::Block, parentWM, nullptr);
const auto iShouldStretch = shouldStretch(
- inlineAlignSelf._0, this, iStartOffsetIsAuto, iEndOffsetIsAuto);
- const auto bShouldStretch = shouldStretch(
- blockAlignSelf._0, this, bStartOffsetIsAuto, bEndOffsetIsAuto);
+ inlineSelfAlign, this, iStartOffsetIsAuto, iEndOffsetIsAuto);
+ const auto bShouldStretch =
+ shouldStretch(blockSelfAlign, this, bStartOffsetIsAuto, bEndOffsetIsAuto);
const auto iSizeIsAuto = styleISize->IsAuto();
// Note(dshin, bug 1789477): `auto` in the context of abs-element uses
// stretch-fit sizing, given specific alignment conditions [1]. Effectively,
diff --git a/layout/style/nsStyleStruct.h b/layout/style/nsStyleStruct.h
@@ -950,12 +950,32 @@ struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsStylePosition {
StyleSelfAlignment UsedJustifySelf(const ComputedStyle*) const;
/**
- * Return the used value for 'justify/align-self' in aAxis given our parent
- * ComputedStyle aParent (or null for the root).
+ * Return the used value for 'justify/align-self' for the axis in the
+ * alignment container's writing mode.
+ *
+ * @param aAlignContainerStyle the computed style of the alignment container,
+ * or null for the root.
+ *
+ * (defined in WritingModes.h since we need the full WritingMode type)
+ */
+ inline mozilla::StyleAlignFlags UsedSelfAlignment(
+ LogicalAxis aAlignContainerAxis,
+ const mozilla::ComputedStyle* aAlignContainerStyle) const;
+
+ /**
+ * Return the used value for 'justify/align-self' for the axis in the
+ * alignment subject's writing mode.
+ *
+ * @param aAlignSubjectAxis the axis in aAlignSubjectWM.
+ * @param aAlignContainerStyle the computed style of the alignment container,
+ * or null for the root.
+ *
* (defined in WritingModes.h since we need the full WritingMode type)
*/
inline mozilla::StyleAlignFlags UsedSelfAlignment(
- LogicalAxis aAxis, const mozilla::ComputedStyle* aParent) const;
+ WritingMode aAlignSubjectWM, LogicalAxis aAlignSubjectAxis,
+ WritingMode aAlignContainerWM,
+ const ComputedStyle* aAlignContainerStyle) const;
/**
* Return the used value for 'justify/align-content' in aAxis.
