corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 1958914: Treat AnchorResolved-using types as instantiations, not subtypes. r=layout-reviewers,emilio

Browse Source 
Differential Revision: https://phabricator.services.mozilla.com/D244658
This commit is contained in:
David Shin
2025-04-08 02:29:19 +00:00
parent c6aa1be101
commit c291c3a105
9 changed files with 127 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
layout/base/nsLayoutUtils.cpp
View File

@@ -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<StyleSize>& 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);

5
layout/generic/WritingModes.h
View File

@@ -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<mozilla::StyleInset>{FromUnresolved(
aValue, ToStylePhysicalAxis(aWM.PhysicalAxis(aAxis)), aPosition)} {}
inline AnchorResolvedInset nsStylePosition::GetAnchorResolvedInset(
mozilla::LogicalSide aSide, WritingMode aWM,

4
layout/generic/nsContainerFrame.cpp
View File

@@ -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;

2
layout/generic/nsGridContainerFrame.cpp
View File

@@ -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);

14
layout/generic/nsIFrame.cpp
View File

@@ -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

4
layout/style/nsComputedDOMStyle.cpp
View File

@@ -1844,7 +1844,7 @@ already_AddRefed<CSSValue> nsComputedDOMStyle::DoGetMinHeight() {
if (minHeight->IsAuto() &&
!ShouldHonorMinSizeAutoInAxis(PhysicalAxis::Vertical)) {
minHeight = AnchorResolvedSize::Zero();
minHeight = AnchorResolvedSizeHelper::Zero();
}
SetValueToSize(val, minHeight);
@@ -1858,7 +1858,7 @@ already_AddRefed<CSSValue> nsComputedDOMStyle::DoGetMinWidth() {
if (minWidth->IsAuto() &&
!ShouldHonorMinSizeAutoInAxis(PhysicalAxis::Horizontal)) {
minWidth = AnchorResolvedSize::Zero();
minWidth = AnchorResolvedSizeHelper::Zero();
}
SetValueToSize(val, minWidth);

76
layout/style/nsStyleStruct.cpp
View File

@@ -286,9 +286,8 @@ static StyleRect<T> StyleRectWithAllSides(const T& aSide) {
return {aSide, aSide, aSide, aSide};
}
AnchorResolved<mozilla::StyleMargin> 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<mozilla::StyleMargin> 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<mozilla::StyleMargin> 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<mozilla::StyleInset> 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<uint8_t>(mozilla::PhysicalAxis::Vertical) ==
static_cast<uint8_t>(StylePhysicalAxis::Vertical),
"Vertical axis doesn't match");
@@ -1383,41 +1386,46 @@ AnchorResolved<mozilla::StyleInset> 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<mozilla::StyleSize> AnchorResolvedSize::ResolveAnchor(
AnchorResolvedSize AnchorResolvedSizeHelper::ResolveAnchor(
const mozilla::StyleSize& aValue,
mozilla::StylePositionProperty aPosition) {
MOZ_ASSERT(aValue.HasAnchorPositioningFunction(),
@@ -1427,12 +1435,14 @@ AnchorResolved<mozilla::StyleSize> 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<mozilla::StyleSize> 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<mozilla::StyleMaxSize> AnchorResolvedMaxSize::ResolveAnchor(
AnchorResolvedMaxSize AnchorResolvedMaxSizeHelper::ResolveAnchor(
const mozilla::StyleMaxSize& aValue,
mozilla::StylePositionProperty aPosition) {
MOZ_ASSERT(aValue.HasAnchorPositioningFunction(),
@@ -1456,12 +1467,14 @@ AnchorResolved<mozilla::StyleMaxSize> 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<mozilla::StyleMaxSize> 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()));
}
// --------------------

195
layout/style/nsStyleStruct.h
View File

@@ -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<mozilla::StyleMargin> {
public:
AnchorResolvedMargin(const mozilla::StyleMargin& aValue,
mozilla::StylePositionProperty aPosition)
: AnchorResolved{FromUnresolved(aValue, aPosition)} {}
using AnchorResolvedMargin = AnchorResolved<mozilla::StyleMargin>;
private:
static AnchorResolved<mozilla::StyleMargin> 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<mozilla::StyleMargin> ResolveAnchor(
private:
static AnchorResolvedMargin ResolveAnchor(
const mozilla::StyleMargin& aValue,
mozilla::StylePositionProperty aPosition);
static AnchorResolved<mozilla::StyleMargin> Invalid() {
return AnchorResolved::Evaluated(mozilla::StyleMargin::LengthPercentage(
mozilla::StyleLengthPercentage::Zero()));
}
static AnchorResolved<mozilla::StyleMargin> Evaluated(
mozilla::StyleLengthPercentage&& aLP) {
return AnchorResolved::Evaluated(
mozilla::StyleMargin::LengthPercentage(aLP));
}
static AnchorResolved<mozilla::StyleMargin> 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<mozilla::StyleInset> {
public:
AnchorResolvedInset(const mozilla::StyleInset& aValue,
mozilla::StylePhysicalAxis aAxis,
mozilla::StylePositionProperty aPosition)
: AnchorResolved<mozilla::StyleInset>{
FromUnresolved(aValue, aAxis, aPosition)} {}
inline AnchorResolvedInset(const mozilla::StyleInset& aValue,
mozilla::LogicalAxis aAxis,
mozilla::WritingMode aWM,
mozilla::StylePositionProperty aPosition);
using AnchorResolvedInset = AnchorResolved<mozilla::StyleInset>;
private:
static AnchorResolved<mozilla::StyleInset> 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<mozilla::StyleInset> ResolveAnchor(
private:
static AnchorResolvedInset ResolveAnchor(
const mozilla::StyleInset& aValue, mozilla::StylePhysicalAxis aAxis,
mozilla::StylePositionProperty aPosition);
static AnchorResolved<mozilla::StyleInset> Invalid() {
return AnchorResolved::Evaluated(mozilla::StyleInset::Auto());
}
static AnchorResolved<mozilla::StyleInset> Evaluated(
mozilla::StyleLengthPercentage&& aLP) {
return AnchorResolved::Evaluated(
mozilla::StyleInset::LengthPercentage(aLP));
}
static AnchorResolved<mozilla::StyleInset> Evaluated(
const mozilla::StyleLengthPercentage& aLP) {
return AnchorResolved::Evaluated(
mozilla::StyleInset::LengthPercentage(aLP));
}
};
class AnchorResolvedSize final : public AnchorResolved<mozilla::StyleSize> {
public:
AnchorResolvedSize(const mozilla::StyleSize& aValue,
mozilla::StylePositionProperty aPosition)
: AnchorResolved<mozilla::StyleSize>{FromUnresolved(aValue, aPosition)} {}
using AnchorResolvedSize = AnchorResolved<mozilla::StyleSize>;
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<mozilla::StyleSize>{
AnchorResolved::Evaluated(std::move(aSize))} {}
explicit AnchorResolvedSize(const mozilla::StyleSize& aSize)
: AnchorResolved<mozilla::StyleSize>{AnchorResolved::Unchanged(aSize)} {}
static AnchorResolved<mozilla::StyleSize> FromUnresolved(
const mozilla::StyleSize& aValue,
mozilla::StylePositionProperty aPosition) {
if (!aValue.HasAnchorPositioningFunction()) {
return AnchorResolved::Unchanged(aValue);
}
return ResolveAnchor(aValue, aPosition);
}
static AnchorResolved<mozilla::StyleSize> ResolveAnchor(
const mozilla::StyleSize& aValue,
mozilla::StylePositionProperty aPosition);
static AnchorResolved<mozilla::StyleSize> Invalid() {
return AnchorResolved::Evaluated(mozilla::StyleSize::Auto());
}
static AnchorResolved<mozilla::StyleSize> Evaluated(
mozilla::StyleLengthPercentage&& aLP) {
return AnchorResolved::Evaluated(mozilla::StyleSize::LengthPercentage(aLP));
}
static AnchorResolved<mozilla::StyleSize> Evaluated(
const mozilla::StyleLengthPercentage& aLP) {
return AnchorResolved::Evaluated(mozilla::StyleSize::LengthPercentage(aLP));
}
};
class AnchorResolvedMaxSize final
: public AnchorResolved<mozilla::StyleMaxSize> {
public:
AnchorResolvedMaxSize(const mozilla::StyleMaxSize& aValue,
mozilla::StylePositionProperty aPosition)
: AnchorResolved<mozilla::StyleMaxSize>{
FromUnresolved(aValue, aPosition)} {}
using AnchorResolvedMaxSize = AnchorResolved<mozilla::StyleMaxSize>;
static AnchorResolvedMaxSize MaxContent() {
return AnchorResolvedMaxSize{mozilla::StyleMaxSize::MaxContent()};
}
static AnchorResolvedMaxSize None() {
return AnchorResolvedMaxSize{mozilla::StyleMaxSize::None()};
}
private:
explicit AnchorResolvedMaxSize(mozilla::StyleMaxSize&& aSize)
: AnchorResolved<mozilla::StyleMaxSize>{
AnchorResolved::Evaluated(std::move(aSize))} {}
static AnchorResolved<mozilla::StyleMaxSize> 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<mozilla::StyleMaxSize> 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<mozilla::StyleMaxSize> Invalid() {
return AnchorResolved::Evaluated(mozilla::StyleMaxSize::None());
}
static AnchorResolved<mozilla::StyleMaxSize> Evaluated(
mozilla::StyleLengthPercentage&& aLP) {
return AnchorResolved::Evaluated(
mozilla::StyleMaxSize::LengthPercentage(aLP));
}
static AnchorResolved<mozilla::StyleMaxSize> 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:

8
layout/tables/BasicTableLayoutStrategy.cpp
View File

@@ -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();
}
}