From c291c3a105df1cad06669fee4dd6dff8d5de6db8 Mon Sep 17 00:00:00 2001 From: David Shin Date: Tue, 8 Apr 2025 02:29:19 +0000 Subject: [PATCH] Bug 1958914: Treat `AnchorResolved`-using types as instantiations, not subtypes. r=layout-reviewers,emilio Differential Revision: https://phabricator.services.mozilla.com/D244658 --- layout/base/nsLayoutUtils.cpp | 18 +- layout/generic/WritingModes.h | 5 - layout/generic/nsContainerFrame.cpp | 4 +- layout/generic/nsGridContainerFrame.cpp | 2 +- layout/generic/nsIFrame.cpp | 14 +- layout/style/nsComputedDOMStyle.cpp | 4 +- layout/style/nsStyleStruct.cpp | 76 ++++---- layout/style/nsStyleStruct.h | 195 ++++++--------------- layout/tables/BasicTableLayoutStrategy.cpp | 8 +- 9 files changed, 127 insertions(+), 199 deletions(-) diff --git a/layout/base/nsLayoutUtils.cpp b/layout/base/nsLayoutUtils.cpp index 8fc726354dbb..abb53daf833c 100644 --- a/layout/base/nsLayoutUtils.cpp +++ b/layout/base/nsLayoutUtils.cpp @@ -4687,12 +4687,12 @@ nscoord nsLayoutUtils::IntrinsicForAxis( : stylePos->GetMinHeight(positionProperty); auto styleISize = [&]() { if (aFlags & MIN_INTRINSIC_ISIZE) { - return AnchorResolvedSize::Overridden(*styleMinISize); + return AnchorResolvedSizeHelper::Overridden(*styleMinISize); } const Maybe& styleISizeOverride = isInlineAxis ? aSizeOverrides.mStyleISize : aSizeOverrides.mStyleBSize; return styleISizeOverride - ? AnchorResolvedSize::Overridden(*styleISizeOverride) + ? AnchorResolvedSizeHelper::Overridden(*styleISizeOverride) : (horizontalAxis ? stylePos->GetWidth(positionProperty) : stylePos->GetHeight(positionProperty)); }(); @@ -4707,13 +4707,13 @@ nscoord nsLayoutUtils::IntrinsicForAxis( AnchorResolvedSize& aMinSize, AnchorResolvedMaxSize& aMaxSize) { if (!aSize->IsLengthPercentage()) { - aSize = AnchorResolvedSize::Auto(); + aSize = AnchorResolvedSizeHelper::Auto(); } if (!aMinSize->IsLengthPercentage()) { - aMinSize = AnchorResolvedSize::Auto(); + aMinSize = AnchorResolvedSizeHelper::Auto(); } if (!aMaxSize->IsLengthPercentage()) { - aMaxSize = AnchorResolvedMaxSize::None(); + aMaxSize = AnchorResolvedMaxSizeHelper::None(); } }; // According to the spec, max-content and min-content should behave as the @@ -4758,7 +4758,7 @@ nscoord nsLayoutUtils::IntrinsicForAxis( isInlineAxis ? aSizeOverrides.mStyleBSize : aSizeOverrides.mStyleISize; auto styleBSize = styleBSizeOverride - ? AnchorResolvedSize::Overridden(*styleBSizeOverride) + ? AnchorResolvedSizeHelper::Overridden(*styleBSizeOverride) : (horizontalAxis ? stylePos->GetHeight(positionProperty) : stylePos->GetWidth(positionProperty)); auto styleMinBSize = horizontalAxis ? stylePos->GetMinHeight(positionProperty) @@ -5071,10 +5071,10 @@ nscoord nsLayoutUtils::MinSizeContributionForAxis( // if needed. if (aAxis != ourInlineAxis) { if (size->BehavesLikeInitialValueOnBlockAxis()) { - size = AnchorResolvedSize::Auto(); + size = AnchorResolvedSizeHelper::Auto(); } if (maxSize->BehavesLikeInitialValueOnBlockAxis()) { - maxSize = AnchorResolvedMaxSize::None(); + maxSize = AnchorResolvedMaxSizeHelper::None(); } } @@ -5092,7 +5092,7 @@ nscoord nsLayoutUtils::MinSizeContributionForAxis( // values in block axis. if (aAxis != ourInlineAxis && size->BehavesLikeInitialValueOnBlockAxis()) { - size = AnchorResolvedSize::Auto(); + size = AnchorResolvedSizeHelper::Auto(); } fixedMinSize = GetAbsoluteSize(*size); diff --git a/layout/generic/WritingModes.h b/layout/generic/WritingModes.h index 1c1c466283c5..4fc43fec276a 100644 --- a/layout/generic/WritingModes.h +++ b/layout/generic/WritingModes.h @@ -2131,11 +2131,6 @@ inline bool StyleMaxSize::BehavesLikeInitialValue(LogicalAxis aAxis) const { // Definitions of inline methods for nsStylePosition, declared in // nsStyleStruct.h but not defined there because they need WritingMode. -inline AnchorResolvedInset::AnchorResolvedInset( - const mozilla::StyleInset& aValue, mozilla::LogicalAxis aAxis, - mozilla::WritingMode aWM, mozilla::StylePositionProperty aPosition) - : AnchorResolved{FromUnresolved( - aValue, ToStylePhysicalAxis(aWM.PhysicalAxis(aAxis)), aPosition)} {} inline AnchorResolvedInset nsStylePosition::GetAnchorResolvedInset( mozilla::LogicalSide aSide, WritingMode aWM, diff --git a/layout/generic/nsContainerFrame.cpp b/layout/generic/nsContainerFrame.cpp index f365fbff89d0..f8900e380f76 100644 --- a/layout/generic/nsContainerFrame.cpp +++ b/layout/generic/nsContainerFrame.cpp @@ -2207,14 +2207,14 @@ LogicalSize nsContainerFrame::ComputeSizeWithIntrinsicDimensions( const auto positionProperty = StyleDisplay()->mPosition; const auto styleISize = aSizeOverrides.mStyleISize - ? AnchorResolvedSize::Overridden(*aSizeOverrides.mStyleISize) + ? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleISize) : stylePos->ISize(aWM, positionProperty); // 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 - ? AnchorResolvedSize::Overridden(*aSizeOverrides.mStyleBSize) + ? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleBSize) : stylePos->BSize(aWM, positionProperty); const auto& aspectRatio = aSizeOverrides.mAspectRatio ? *aSizeOverrides.mAspectRatio : aAspectRatio; diff --git a/layout/generic/nsGridContainerFrame.cpp b/layout/generic/nsGridContainerFrame.cpp index 2df5511ab795..75dfbdbc59b5 100644 --- a/layout/generic/nsGridContainerFrame.cpp +++ b/layout/generic/nsGridContainerFrame.cpp @@ -338,7 +338,7 @@ struct RepeatTrackSizingInput { // 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 - ? AnchorResolvedSize::Auto() + ? AnchorResolvedSizeHelper::Auto() : pos->BSize(aWM, positionProperty); if (styleSize->ConvertsToLength()) { size = std::clamp(adjustForBoxSizing(styleSize->ToLength()), min, max); diff --git a/layout/generic/nsIFrame.cpp b/layout/generic/nsIFrame.cpp index 17da0c1f99d0..50f9f60dc347 100644 --- a/layout/generic/nsIFrame.cpp +++ b/layout/generic/nsIFrame.cpp @@ -6473,7 +6473,7 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize( : GetAspectRatio(); const auto styleISize = aSizeOverrides.mStyleISize - ? AnchorResolvedSize::Overridden(*aSizeOverrides.mStyleISize) + ? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleISize) : stylePos->ISize(aWM, positionProperty); // For bsize, we consider overrides *and then* we resolve 'stretch' to a // nscoord value, for convenience (so that we can assume that either @@ -6481,7 +6481,7 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize( const auto styleBSize = [&] { auto styleBSizeConsideringOverrides = (aSizeOverrides.mStyleBSize) - ? AnchorResolvedSize::Overridden(*aSizeOverrides.mStyleBSize) + ? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleBSize) : stylePos->BSize(aWM, positionProperty); if (styleBSizeConsideringOverrides->BehavesLikeStretchOnBlockAxis() && aCBSize.BSize(aWM) != NS_UNCONSTRAINEDSIZE) { @@ -6489,7 +6489,7 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize( nscoord stretchBSize = nsLayoutUtils::ComputeStretchBSize( aCBSize.BSize(aWM), aMargin.BSize(aWM), aBorderPadding.BSize(aWM), stylePos->mBoxSizing); - return AnchorResolvedSize::LengthPercentage( + return AnchorResolvedSizeHelper::LengthPercentage( LengthPercentage::FromAppUnits(stretchBSize)); } return styleBSizeConsideringOverrides; @@ -6928,7 +6928,7 @@ LogicalSize nsIFrame::ComputeAutoSize( // don't bother setting it if the result won't be used const auto styleISize = aSizeOverrides.mStyleISize - ? AnchorResolvedSize::Overridden(*aSizeOverrides.mStyleISize) + ? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleISize) : StylePosition()->ISize(aWM, positionProperty); if (styleISize->IsAuto()) { nscoord availBased = nsLayoutUtils::ComputeStretchContentBoxISize( @@ -6936,7 +6936,7 @@ LogicalSize nsIFrame::ComputeAutoSize( const auto* stylePos = StylePosition(); const auto styleBSize = aSizeOverrides.mStyleBSize - ? AnchorResolvedSize::Overridden(*aSizeOverrides.mStyleBSize) + ? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleBSize) : stylePos->BSize(aWM, positionProperty); const LogicalSize contentEdgeToBoxSizing = stylePos->mBoxSizing == StyleBoxSizing::Border ? aBorderPadding @@ -6981,11 +6981,11 @@ LogicalSize nsIFrame::ComputeAbsolutePosAutoSize( const auto positionProperty = StyleDisplay()->mPosition; const auto& styleISize = aSizeOverrides.mStyleISize - ? AnchorResolvedSize::Overridden(*aSizeOverrides.mStyleISize) + ? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleISize) : stylePos->ISize(aWM, positionProperty); const auto& styleBSize = aSizeOverrides.mStyleBSize - ? AnchorResolvedSize::Overridden(*aSizeOverrides.mStyleBSize) + ? AnchorResolvedSizeHelper::Overridden(*aSizeOverrides.mStyleBSize) : stylePos->BSize(aWM, positionProperty); const auto iStartOffsetIsAuto = stylePos diff --git a/layout/style/nsComputedDOMStyle.cpp b/layout/style/nsComputedDOMStyle.cpp index 348174518d73..02d435e2d4fe 100644 --- a/layout/style/nsComputedDOMStyle.cpp +++ b/layout/style/nsComputedDOMStyle.cpp @@ -1844,7 +1844,7 @@ already_AddRefed nsComputedDOMStyle::DoGetMinHeight() { if (minHeight->IsAuto() && !ShouldHonorMinSizeAutoInAxis(PhysicalAxis::Vertical)) { - minHeight = AnchorResolvedSize::Zero(); + minHeight = AnchorResolvedSizeHelper::Zero(); } SetValueToSize(val, minHeight); @@ -1858,7 +1858,7 @@ already_AddRefed nsComputedDOMStyle::DoGetMinWidth() { if (minWidth->IsAuto() && !ShouldHonorMinSizeAutoInAxis(PhysicalAxis::Horizontal)) { - minWidth = AnchorResolvedSize::Zero(); + minWidth = AnchorResolvedSizeHelper::Zero(); } SetValueToSize(val, minWidth); diff --git a/layout/style/nsStyleStruct.cpp b/layout/style/nsStyleStruct.cpp index 5554acf502a8..8f587542ad24 100644 --- a/layout/style/nsStyleStruct.cpp +++ b/layout/style/nsStyleStruct.cpp @@ -286,9 +286,8 @@ static StyleRect StyleRectWithAllSides(const T& aSide) { return {aSide, aSide, aSide, aSide}; } -AnchorResolved AnchorResolvedMargin::ResolveAnchor( - const mozilla::StyleMargin& aValue, - mozilla::StylePositionProperty aPosition) { +AnchorResolvedMargin AnchorResolvedMarginHelper::ResolveAnchor( + const StyleMargin& aValue, StylePositionProperty aPosition) { MOZ_ASSERT(aValue.HasAnchorPositioningFunction(), "Calling anchor resolution without using it?"); if (aValue.IsAnchorSizeFunction()) { @@ -296,12 +295,15 @@ AnchorResolved AnchorResolvedMargin::ResolveAnchor( Servo_ResolveAnchorSizeFunction(&*aValue.AsAnchorSizeFunction(), aPosition, &resolved); if (resolved.IsInvalid()) { - return Invalid(); + return AnchorResolvedMargin::Evaluated( + StyleMargin::LengthPercentage(StyleLengthPercentage::Zero())); } if (resolved.IsResolvedReference()) { - return Evaluated(*resolved.AsResolvedReference()); + return AnchorResolvedMargin::Evaluated( + StyleMargin::LengthPercentage(*resolved.AsResolvedReference())); } - return Evaluated(resolved.AsResolved()); + return AnchorResolvedMargin::Evaluated( + StyleMargin::LengthPercentage(resolved.AsResolved())); } const auto& lp = aValue.AsAnchorContainingCalcFunction(); @@ -309,9 +311,11 @@ AnchorResolved AnchorResolvedMargin::ResolveAnchor( auto result = StyleCalcAnchorPositioningFunctionResolution::Invalid(); Servo_ResolveAnchorFunctionsInCalcPercentage(&c, nullptr, aPosition, &result); if (result.IsInvalid()) { - return Invalid(); + return AnchorResolvedMargin::Evaluated( + StyleMargin::LengthPercentage(StyleLengthPercentage::Zero())); } - return Evaluated(result.AsValid()); + return AnchorResolvedMargin::Evaluated( + StyleMargin::LengthPercentage(result.AsValid())); } nsStyleMargin::nsStyleMargin() @@ -1363,10 +1367,9 @@ StyleJustifySelf nsStylePosition::UsedJustifySelf( return {StyleAlignFlags::NORMAL}; } -AnchorResolved AnchorResolvedInset::ResolveAnchor( +AnchorResolvedInset AnchorResolvedInsetHelper::ResolveAnchor( const mozilla::StyleInset& aValue, mozilla::StylePhysicalAxis aAxis, mozilla::StylePositionProperty aPosition) { - // TODO(dshin): Maybe worth pref-gating here. static_assert(static_cast(mozilla::PhysicalAxis::Vertical) == static_cast(StylePhysicalAxis::Vertical), "Vertical axis doesn't match"); @@ -1383,41 +1386,46 @@ AnchorResolved AnchorResolvedInset::ResolveAnchor( Servo_ResolveAnchorFunctionsInCalcPercentage(&c, &aAxis, aPosition, &result); if (result.IsInvalid()) { - return Invalid(); + return AnchorResolvedInset::Evaluated(StyleInset::Auto()); } - return Evaluated(result.AsValid()); + return AnchorResolvedInset::Evaluated( + StyleInset::LengthPercentage(result.AsValid())); } case StyleInset::Tag::AnchorFunction: { auto resolved = StyleAnchorPositioningFunctionResolution::Invalid(); Servo_ResolveAnchorFunction(&*aValue.AsAnchorFunction(), aAxis, aPosition, &resolved); if (resolved.IsInvalid()) { - return Invalid(); + return AnchorResolvedInset::Evaluated(StyleInset::Auto()); } if (resolved.IsResolvedReference()) { - return Evaluated(*resolved.AsResolvedReference()); + return AnchorResolvedInset::Evaluated( + StyleInset::LengthPercentage(*resolved.AsResolvedReference())); } - return Evaluated(resolved.AsResolved()); + return AnchorResolvedInset::Evaluated( + StyleInset::LengthPercentage(resolved.AsResolved())); } case StyleInset::Tag::AnchorSizeFunction: { auto resolved = StyleAnchorPositioningFunctionResolution::Invalid(); Servo_ResolveAnchorSizeFunction(&*aValue.AsAnchorSizeFunction(), aPosition, &resolved); if (resolved.IsInvalid()) { - return Invalid(); + return AnchorResolvedInset::Evaluated(StyleInset::Auto()); } if (resolved.IsResolvedReference()) { - return Evaluated(*resolved.AsResolvedReference()); + return AnchorResolvedInset::Evaluated( + StyleInset::LengthPercentage(*resolved.AsResolvedReference())); } - return Evaluated(resolved.AsResolved()); + return AnchorResolvedInset::Evaluated( + StyleInset::LengthPercentage(resolved.AsResolved())); } default: MOZ_ASSERT_UNREACHABLE("Unhandled inset type"); - return Invalid(); + return AnchorResolvedInset::Evaluated(StyleInset::Auto()); } } -AnchorResolved AnchorResolvedSize::ResolveAnchor( +AnchorResolvedSize AnchorResolvedSizeHelper::ResolveAnchor( const mozilla::StyleSize& aValue, mozilla::StylePositionProperty aPosition) { MOZ_ASSERT(aValue.HasAnchorPositioningFunction(), @@ -1427,12 +1435,14 @@ AnchorResolved AnchorResolvedSize::ResolveAnchor( Servo_ResolveAnchorSizeFunction(&*aValue.AsAnchorSizeFunction(), aPosition, &resolved); if (resolved.IsInvalid()) { - return Invalid(); + return AnchorResolvedSize::Evaluated(StyleSize::Auto()); } if (resolved.IsResolvedReference()) { - return Evaluated(*resolved.AsResolvedReference()); + return AnchorResolvedSize::Evaluated( + StyleSize::LengthPercentage(*resolved.AsResolvedReference())); } - return Evaluated(resolved.AsResolved()); + return AnchorResolvedSize::Evaluated( + StyleSize::LengthPercentage(resolved.AsResolved())); } const auto& lp = aValue.AsAnchorContainingCalcFunction(); @@ -1441,12 +1451,13 @@ AnchorResolved AnchorResolvedSize::ResolveAnchor( auto result = StyleCalcAnchorPositioningFunctionResolution::Invalid(); Servo_ResolveAnchorFunctionsInCalcPercentage(&c, nullptr, aPosition, &result); if (result.IsInvalid()) { - return Invalid(); + return AnchorResolvedSize::Evaluated(StyleSize::Auto()); } - return Evaluated(result.AsValid()); + return AnchorResolvedSize::Evaluated( + StyleSize::LengthPercentage(result.AsValid())); } -AnchorResolved AnchorResolvedMaxSize::ResolveAnchor( +AnchorResolvedMaxSize AnchorResolvedMaxSizeHelper::ResolveAnchor( const mozilla::StyleMaxSize& aValue, mozilla::StylePositionProperty aPosition) { MOZ_ASSERT(aValue.HasAnchorPositioningFunction(), @@ -1456,12 +1467,14 @@ AnchorResolved AnchorResolvedMaxSize::ResolveAnchor( Servo_ResolveAnchorSizeFunction(&*aValue.AsAnchorSizeFunction(), aPosition, &resolved); if (resolved.IsInvalid()) { - return Invalid(); + return AnchorResolvedMaxSize::Evaluated(StyleMaxSize::None()); } if (resolved.IsResolvedReference()) { - return Evaluated(*resolved.AsResolvedReference()); + return AnchorResolvedMaxSize::Evaluated( + StyleMaxSize::LengthPercentage(*resolved.AsResolvedReference())); } - return Evaluated(resolved.AsResolved()); + return AnchorResolvedMaxSize::Evaluated( + StyleMaxSize::LengthPercentage(resolved.AsResolved())); } const auto& lp = aValue.AsAnchorContainingCalcFunction(); @@ -1470,9 +1483,10 @@ AnchorResolved AnchorResolvedMaxSize::ResolveAnchor( auto result = StyleCalcAnchorPositioningFunctionResolution::Invalid(); Servo_ResolveAnchorFunctionsInCalcPercentage(&c, nullptr, aPosition, &result); if (result.IsInvalid()) { - return Invalid(); + return AnchorResolvedMaxSize::Evaluated(StyleMaxSize::None()); } - return Evaluated(result.AsValid()); + return AnchorResolvedMaxSize::Evaluated( + StyleMaxSize::LengthPercentage(result.AsValid())); } // -------------------- diff --git a/layout/style/nsStyleStruct.h b/layout/style/nsStyleStruct.h index 338863567b3f..1c6e2b5a3d4a 100644 --- a/layout/style/nsStyleStruct.h +++ b/layout/style/nsStyleStruct.h @@ -428,7 +428,6 @@ class AnchorResolved { AnchorResolved(const AnchorResolved& aOther) = delete; AnchorResolved& operator=(const AnchorResolved& aOther) = delete; - protected: static AnchorResolved Evaluated(T&& aValue) { AnchorResolved result; result.mIsValue = true; @@ -457,38 +456,22 @@ class AnchorResolved { }; }; -class AnchorResolvedMargin final : public AnchorResolved { - public: - AnchorResolvedMargin(const mozilla::StyleMargin& aValue, - mozilla::StylePositionProperty aPosition) - : AnchorResolved{FromUnresolved(aValue, aPosition)} {} +using AnchorResolvedMargin = AnchorResolved; - private: - static AnchorResolved FromUnresolved( +struct AnchorResolvedMarginHelper { + static AnchorResolvedMargin FromUnresolved( const mozilla::StyleMargin& aValue, mozilla::StylePositionProperty aPosition) { if (!aValue.HasAnchorPositioningFunction()) { - return Unchanged(aValue); + return AnchorResolvedMargin::Unchanged(aValue); } return ResolveAnchor(aValue, aPosition); } - static AnchorResolved ResolveAnchor( + + private: + static AnchorResolvedMargin ResolveAnchor( const mozilla::StyleMargin& aValue, mozilla::StylePositionProperty aPosition); - static AnchorResolved Invalid() { - return AnchorResolved::Evaluated(mozilla::StyleMargin::LengthPercentage( - mozilla::StyleLengthPercentage::Zero())); - } - static AnchorResolved Evaluated( - mozilla::StyleLengthPercentage&& aLP) { - return AnchorResolved::Evaluated( - mozilla::StyleMargin::LengthPercentage(aLP)); - } - static AnchorResolved Evaluated( - const mozilla::StyleLengthPercentage& aLP) { - return AnchorResolved::Evaluated( - mozilla::StyleMargin::LengthPercentage(aLP)); - } }; struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsStyleMargin { @@ -533,7 +516,8 @@ struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsStyleMargin { // a later point. AnchorResolvedMargin GetMargin( mozilla::Side aSide, mozilla::StylePositionProperty aPosition) const { - return {mMargin.Get(aSide), aPosition}; + return AnchorResolvedMarginHelper::FromUnresolved(mMargin.Get(aSide), + aPosition); } bool MarginEquals(const nsStyleMargin& aOther) const { @@ -825,155 +809,89 @@ struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsStylePage { StylePageOrientation mPageOrientation = StylePageOrientation::Upright; }; -class AnchorResolvedInset final : public AnchorResolved { - public: - AnchorResolvedInset(const mozilla::StyleInset& aValue, - mozilla::StylePhysicalAxis aAxis, - mozilla::StylePositionProperty aPosition) - : AnchorResolved{ - FromUnresolved(aValue, aAxis, aPosition)} {} - inline AnchorResolvedInset(const mozilla::StyleInset& aValue, - mozilla::LogicalAxis aAxis, - mozilla::WritingMode aWM, - mozilla::StylePositionProperty aPosition); +using AnchorResolvedInset = AnchorResolved; - private: - static AnchorResolved FromUnresolved( +struct AnchorResolvedInsetHelper { + static AnchorResolvedInset FromUnresolved( const mozilla::StyleInset& aValue, mozilla::StylePhysicalAxis aAxis, mozilla::StylePositionProperty aPosition) { if (!aValue.HasAnchorPositioningFunction()) { - return AnchorResolved::Unchanged(aValue); + return AnchorResolvedInset::Unchanged(aValue); } return ResolveAnchor(aValue, aAxis, aPosition); } - static AnchorResolved ResolveAnchor( + + private: + static AnchorResolvedInset ResolveAnchor( const mozilla::StyleInset& aValue, mozilla::StylePhysicalAxis aAxis, mozilla::StylePositionProperty aPosition); - static AnchorResolved Invalid() { - return AnchorResolved::Evaluated(mozilla::StyleInset::Auto()); - } - static AnchorResolved Evaluated( - mozilla::StyleLengthPercentage&& aLP) { - return AnchorResolved::Evaluated( - mozilla::StyleInset::LengthPercentage(aLP)); - } - static AnchorResolved Evaluated( - const mozilla::StyleLengthPercentage& aLP) { - return AnchorResolved::Evaluated( - mozilla::StyleInset::LengthPercentage(aLP)); - } }; -class AnchorResolvedSize final : public AnchorResolved { - public: - AnchorResolvedSize(const mozilla::StyleSize& aValue, - mozilla::StylePositionProperty aPosition) - : AnchorResolved{FromUnresolved(aValue, aPosition)} {} +using AnchorResolvedSize = AnchorResolved; + +struct AnchorResolvedSizeHelper { + static AnchorResolvedSize FromUnresolved( + const mozilla::StyleSize& aValue, + mozilla::StylePositionProperty aPosition) { + if (!aValue.HasAnchorPositioningFunction()) { + return AnchorResolvedSize::Unchanged(aValue); + } + return ResolveAnchor(aValue, aPosition); + } - AnchorResolvedSize(AnchorResolvedSize&& aOther) = default; - AnchorResolvedSize& operator=(AnchorResolvedSize&& aOther) = default; static AnchorResolvedSize Overridden(const mozilla::StyleSize& aSize) { - return AnchorResolvedSize{aSize}; + return AnchorResolvedSize::Unchanged(aSize); } static AnchorResolvedSize Zero() { - return AnchorResolvedSize{mozilla::StyleSize::LengthPercentage( - mozilla::StyleLengthPercentage::Zero())}; + return AnchorResolvedSize::Evaluated(mozilla::StyleSize::LengthPercentage( + mozilla::StyleLengthPercentage::Zero())); } static AnchorResolvedSize MinContent() { - return AnchorResolvedSize{mozilla::StyleSize::MinContent()}; + return AnchorResolvedSize::Evaluated(mozilla::StyleSize::MinContent()); } static AnchorResolvedSize Auto() { - return AnchorResolvedSize{mozilla::StyleSize::Auto()}; + return AnchorResolvedSize::Evaluated(mozilla::StyleSize::Auto()); } static AnchorResolvedSize LengthPercentage( const mozilla::StyleLengthPercentage& aLP) { - return AnchorResolvedSize{mozilla::StyleSize::LengthPercentage(aLP)}; + return AnchorResolvedSize::Evaluated( + mozilla::StyleSize::LengthPercentage(aLP)); } private: - explicit AnchorResolvedSize(mozilla::StyleSize&& aSize) - : AnchorResolved{ - AnchorResolved::Evaluated(std::move(aSize))} {} - explicit AnchorResolvedSize(const mozilla::StyleSize& aSize) - : AnchorResolved{AnchorResolved::Unchanged(aSize)} {} - - static AnchorResolved FromUnresolved( - const mozilla::StyleSize& aValue, - mozilla::StylePositionProperty aPosition) { - if (!aValue.HasAnchorPositioningFunction()) { - return AnchorResolved::Unchanged(aValue); - } - return ResolveAnchor(aValue, aPosition); - } - static AnchorResolved ResolveAnchor( const mozilla::StyleSize& aValue, mozilla::StylePositionProperty aPosition); - - static AnchorResolved Invalid() { - return AnchorResolved::Evaluated(mozilla::StyleSize::Auto()); - } - - static AnchorResolved Evaluated( - mozilla::StyleLengthPercentage&& aLP) { - return AnchorResolved::Evaluated(mozilla::StyleSize::LengthPercentage(aLP)); - } - - static AnchorResolved Evaluated( - const mozilla::StyleLengthPercentage& aLP) { - return AnchorResolved::Evaluated(mozilla::StyleSize::LengthPercentage(aLP)); - } }; -class AnchorResolvedMaxSize final - : public AnchorResolved { - public: - AnchorResolvedMaxSize(const mozilla::StyleMaxSize& aValue, - mozilla::StylePositionProperty aPosition) - : AnchorResolved{ - FromUnresolved(aValue, aPosition)} {} +using AnchorResolvedMaxSize = AnchorResolved; - static AnchorResolvedMaxSize MaxContent() { - return AnchorResolvedMaxSize{mozilla::StyleMaxSize::MaxContent()}; - } - - static AnchorResolvedMaxSize None() { - return AnchorResolvedMaxSize{mozilla::StyleMaxSize::None()}; - } - - private: - explicit AnchorResolvedMaxSize(mozilla::StyleMaxSize&& aSize) - : AnchorResolved{ - AnchorResolved::Evaluated(std::move(aSize))} {} - - static AnchorResolved FromUnresolved( +struct AnchorResolvedMaxSizeHelper { + static AnchorResolvedMaxSize FromUnresolved( const mozilla::StyleMaxSize& aValue, mozilla::StylePositionProperty aPosition) { if (!aValue.HasAnchorPositioningFunction()) { - return AnchorResolved::Unchanged(aValue); + return AnchorResolvedMaxSize::Unchanged(aValue); } return ResolveAnchor(aValue, aPosition); } - static AnchorResolved ResolveAnchor( + static AnchorResolvedMaxSize MaxContent() { + return AnchorResolvedMaxSize::Evaluated( + mozilla::StyleMaxSize::MaxContent()); + } + + static AnchorResolvedMaxSize None() { + return AnchorResolvedMaxSize::Evaluated(mozilla::StyleMaxSize::None()); + } + + private: + static AnchorResolvedMaxSize ResolveAnchor( const mozilla::StyleMaxSize& aValue, mozilla::StylePositionProperty aPosition); - static AnchorResolved Invalid() { - return AnchorResolved::Evaluated(mozilla::StyleMaxSize::None()); - } - static AnchorResolved Evaluated( - mozilla::StyleLengthPercentage&& aLP) { - return AnchorResolved::Evaluated( - mozilla::StyleMaxSize::LengthPercentage(aLP)); - } - static AnchorResolved Evaluated( - const mozilla::StyleLengthPercentage& aLP) { - return AnchorResolved::Evaluated( - mozilla::StyleMaxSize::LengthPercentage(aLP)); - } }; struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsStylePosition { @@ -1131,36 +1049,37 @@ struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsStylePosition { // interleaving computation is implemented. AnchorResolvedInset GetAnchorResolvedInset( mozilla::Side aSide, mozilla::StylePositionProperty aPosition) const { - return {mOffset.Get(aSide), GetStylePhysicalAxis(aSide), aPosition}; + return AnchorResolvedInsetHelper::FromUnresolved( + mOffset.Get(aSide), GetStylePhysicalAxis(aSide), aPosition); } inline AnchorResolvedInset GetAnchorResolvedInset( mozilla::LogicalSide aSide, WritingMode aWM, mozilla::StylePositionProperty aPosition) const; AnchorResolvedSize GetWidth(mozilla::StylePositionProperty aProp) const { - return {mWidth, aProp}; + return AnchorResolvedSizeHelper::FromUnresolved(mWidth, aProp); } AnchorResolvedSize GetHeight(mozilla::StylePositionProperty aProp) const { - return {mHeight, aProp}; + return AnchorResolvedSizeHelper::FromUnresolved(mHeight, aProp); } AnchorResolvedSize GetMinWidth(mozilla::StylePositionProperty aProp) const { - return {mMinWidth, aProp}; + return AnchorResolvedSizeHelper::FromUnresolved(mMinWidth, aProp); } AnchorResolvedSize GetMinHeight(mozilla::StylePositionProperty aProp) const { - return {mMinHeight, aProp}; + return AnchorResolvedSizeHelper::FromUnresolved(mMinHeight, aProp); } AnchorResolvedMaxSize GetMaxWidth( mozilla::StylePositionProperty aProp) const { - return {mMaxWidth, aProp}; + return AnchorResolvedMaxSizeHelper::FromUnresolved(mMaxWidth, aProp); } AnchorResolvedMaxSize GetMaxHeight( mozilla::StylePositionProperty aProp) const { - return {mMaxHeight, aProp}; + return AnchorResolvedMaxSizeHelper::FromUnresolved(mMaxHeight, aProp); } private: diff --git a/layout/tables/BasicTableLayoutStrategy.cpp b/layout/tables/BasicTableLayoutStrategy.cpp index ec6663ec0d26..f1735fbcc781 100644 --- a/layout/tables/BasicTableLayoutStrategy.cpp +++ b/layout/tables/BasicTableLayoutStrategy.cpp @@ -183,11 +183,11 @@ static CellISizeInfo GetISizeInfo(gfxContext* aRenderingContext, auto maxISize = stylePos->MaxISize(aWM, positionProperty); if (nsIFrame::ToExtremumLength(*maxISize)) { if (!aIsCell || maxISize->BehavesLikeStretchOnInlineAxis()) { - maxISize = AnchorResolvedMaxSize::None(); + maxISize = AnchorResolvedMaxSizeHelper::None(); } else if (maxISize->IsFitContent() || maxISize->IsFitContentFunction()) { // TODO: Bug 1708310: Make sure fit-content() work properly in table. // for 'max-inline-size', '-moz-fit-content' is like 'max-content' - maxISize = AnchorResolvedMaxSize::MaxContent(); + maxISize = AnchorResolvedMaxSizeHelper::MaxContent(); } } // XXX To really implement 'max-inline-size' well, we'd need to store @@ -212,11 +212,11 @@ static CellISizeInfo GetISizeInfo(gfxContext* aRenderingContext, auto minISize = stylePos->MinISize(aWM, positionProperty); if (nsIFrame::ToExtremumLength(*maxISize)) { if (!aIsCell || minISize->BehavesLikeStretchOnInlineAxis()) { - minISize = AnchorResolvedSize::Zero(); + minISize = AnchorResolvedSizeHelper::Zero(); } else if (minISize->IsFitContent() || minISize->IsFitContentFunction()) { // TODO: Bug 1708310: Make sure fit-content() work properly in table. // for 'min-inline-size', '-moz-fit-content' is like 'min-content' - minISize = AnchorResolvedSize::MinContent(); + minISize = AnchorResolvedSizeHelper::MinContent(); } }