Backed out 7 changesets (bug 1923763) for causing build bustages in nsStyleStruct.cpp. CLOSED TREE

Backed out changeset d55070e64ced (bug 1923763)
Backed out changeset a92a0bc6047f (bug 1923763)
Backed out changeset 2203e2c5268e (bug 1923763)
Backed out changeset 0cc5e744c01a (bug 1923763)
Backed out changeset d2139afa933b (bug 1923763)
Backed out changeset 93e59980eac1 (bug 1923763)
Backed out changeset 8018734b5491 (bug 1923763)

Author: sstanca-cell

layout/base/PresShell.cpp

@@ -3793,10 +3793,8 @@ bool PresShell::ScrollFrameIntoView(
     // If we're targetting a sticky element, make sure not to apply
     // scroll-padding on the direction we're stuck.
     const auto* stylePosition = aFrame->StylePosition();
-    const auto positionProperty = aFrame->StyleDisplay()->mPosition;
     for (auto side : AllPhysicalSides()) {
-      if (stylePosition->GetAnchorResolvedInset(side, positionProperty)
-              .IsAuto()) {
+      if (stylePosition->GetInset(side).IsAuto()) {
         continue;
       }
       // See if this axis is stuck.

layout/base/nsLayoutUtils.cpp

@@ -1263,24 +1263,16 @@ SideBits nsLayoutUtils::GetSideBitsForFixedPositionContent(
   SideBits sides = SideBits::eNone;
   if (aFixedPosFrame) {
     const nsStylePosition* position = aFixedPosFrame->StylePosition();
-    if (!position
-             ->GetAnchorResolvedInset(eSideRight, StylePositionProperty::Fixed)
-             .IsAuto()) {
+    if (!position->GetInset(eSideRight).IsAuto()) {
       sides |= SideBits::eRight;
     }
-    if (!position
-             ->GetAnchorResolvedInset(eSideLeft, StylePositionProperty::Fixed)
-             .IsAuto()) {
+    if (!position->GetInset(eSideLeft).IsAuto()) {
       sides |= SideBits::eLeft;
     }
-    if (!position
-             ->GetAnchorResolvedInset(eSideBottom, StylePositionProperty::Fixed)
-             .IsAuto()) {
+    if (!position->GetInset(eSideBottom).IsAuto()) {
       sides |= SideBits::eBottom;
     }
-    if (!position
-             ->GetAnchorResolvedInset(eSideTop, StylePositionProperty::Fixed)
-             .IsAuto()) {
+    if (!position->GetInset(eSideTop).IsAuto()) {
       sides |= SideBits::eTop;
     }
   }

layout/generic/ReflowInput.cpp

@@ -742,9 +742,8 @@ void ReflowInput::InitResizeFlags(nsPresContext* aPresContext,
        !mStylePosition->BSize(wm).IsAuto()) ||
       mStylePosition->MinBSizeDependsOnContainer(wm) ||
       mStylePosition->MaxBSizeDependsOnContainer(wm) ||
-      mStylePosition->mOffset.Get(LogicalSide::BStart, wm)
-          .MaybePercentageAware() ||
-      !mStylePosition->mOffset.Get(LogicalSide::BEnd, wm).MaybeAuto();
+      mStylePosition->GetInset(LogicalSide::BStart, wm).HasPercent() ||
+      !mStylePosition->GetInset(LogicalSide::BEnd, wm).IsAuto();
 
   // If mFrame is a flex item, and mFrame's block axis is the flex container's
   // main axis (e.g. in a column-oriented flex container with same
@@ -853,18 +852,15 @@ LogicalMargin ReflowInput::ComputeRelativeOffsets(WritingMode aWM,
                                                   const LogicalSize& aCBSize) {
   LogicalMargin offsets(aWM);
   const nsStylePosition* position = aFrame->StylePosition();
-  const auto positionProperty = aFrame->StyleDisplay()->mPosition;
 
   // Compute the 'inlineStart' and 'inlineEnd' values. 'inlineStart'
   // moves the boxes to the end of the line, and 'inlineEnd' moves the
   // boxes to the start of the line. The computed values are always:
   // inlineStart=-inlineEnd
-  const auto& inlineStart = position->GetAnchorResolvedInset(
-      LogicalSide::IStart, aWM, positionProperty);
-  const auto& inlineEnd = position->GetAnchorResolvedInset(
-      LogicalSide::IEnd, aWM, positionProperty);
-  bool inlineStartIsAuto = inlineStart.IsAuto();
-  bool inlineEndIsAuto = inlineEnd.IsAuto();
+  const auto& inlineStart = position->GetInset(LogicalSide::IStart, aWM);
+  const auto& inlineEnd = position->GetInset(LogicalSide::IEnd, aWM);
+  bool inlineStartIsAuto = !inlineStart.IsLengthPercentage();
+  bool inlineEndIsAuto = !inlineEnd.IsLengthPercentage();
 
   // If neither 'inlineStart' nor 'inlineEnd' is auto, then we're
   // over-constrained and we ignore one of them
@@ -877,12 +873,9 @@ LogicalMargin ReflowInput::ComputeRelativeOffsets(WritingMode aWM,
       // If both are 'auto' (their initial values), the computed values are 0
       offsets.IStart(aWM) = offsets.IEnd(aWM) = 0;
     } else {
-      // 'inlineEnd' isn't being treated as 'auto' so compute its value
+      // 'inlineEnd' isn't 'auto' so compute its value
       offsets.IEnd(aWM) =
-          inlineEnd.IsAuto()
-              ? 0
-              : nsLayoutUtils::ComputeCBDependentValue(
-                    aCBSize.ISize(aWM), inlineEnd.AsLengthPercentage());
+          nsLayoutUtils::ComputeCBDependentValue(aCBSize.ISize(aWM), inlineEnd);
 
       // Computed value for 'inlineStart' is minus the value of 'inlineEnd'
       offsets.IStart(aWM) = -offsets.IEnd(aWM);
@@ -892,8 +885,8 @@ LogicalMargin ReflowInput::ComputeRelativeOffsets(WritingMode aWM,
     NS_ASSERTION(inlineEndIsAuto, "unexpected specified constraint");
 
     // 'InlineStart' isn't 'auto' so compute its value
-    offsets.IStart(aWM) = nsLayoutUtils::ComputeCBDependentValue(
-        aCBSize.ISize(aWM), inlineStart.AsLengthPercentage());
+    offsets.IStart(aWM) =
+        nsLayoutUtils::ComputeCBDependentValue(aCBSize.ISize(aWM), inlineStart);
 
     // Computed value for 'inlineEnd' is minus the value of 'inlineStart'
     offsets.IEnd(aWM) = -offsets.IStart(aWM);
@@ -903,10 +896,8 @@ LogicalMargin ReflowInput::ComputeRelativeOffsets(WritingMode aWM,
   // and 'blockEnd' properties move relatively positioned elements in
   // the block progression direction. They also must be each other's
   // negative
-  const auto& blockStart = position->GetAnchorResolvedInset(
-      LogicalSide::BStart, aWM, positionProperty);
-  const auto& blockEnd = position->GetAnchorResolvedInset(
-      LogicalSide::BEnd, aWM, positionProperty);
+  const auto& blockStart = position->GetInset(LogicalSide::BStart, aWM);
+  const auto& blockEnd = position->GetInset(LogicalSide::BEnd, aWM);
   bool blockStartIsAuto = blockStart.IsAuto();
   bool blockEndIsAuto = blockEnd.IsAuto();
 
@@ -931,12 +922,9 @@ LogicalMargin ReflowInput::ComputeRelativeOffsets(WritingMode aWM,
       // If both are 'auto' (their initial values), the computed values are 0
       offsets.BStart(aWM) = offsets.BEnd(aWM) = 0;
     } else {
-      // 'blockEnd' isn't being treated as 'auto' so compute its value
+      // 'blockEnd' isn't 'auto' so compute its value
       offsets.BEnd(aWM) =
-          blockEnd.IsAuto()
-              ? 0
-              : nsLayoutUtils::ComputeCBDependentValue(
-                    aCBSize.BSize(aWM), blockEnd.AsLengthPercentage());
+          nsLayoutUtils::ComputeCBDependentValue(aCBSize.BSize(aWM), blockEnd);
 
       // Computed value for 'blockStart' is minus the value of 'blockEnd'
       offsets.BStart(aWM) = -offsets.BEnd(aWM);
@@ -946,8 +934,8 @@ LogicalMargin ReflowInput::ComputeRelativeOffsets(WritingMode aWM,
     NS_ASSERTION(blockEndIsAuto, "unexpected specified constraint");
 
     // 'blockStart' isn't 'auto' so compute its value
-    offsets.BStart(aWM) = nsLayoutUtils::ComputeCBDependentValue(
-        aCBSize.BSize(aWM), blockStart.AsLengthPercentage());
+    offsets.BStart(aWM) =
+        nsLayoutUtils::ComputeCBDependentValue(aCBSize.BSize(aWM), blockStart);
 
     // Computed value for 'blockEnd' is minus the value of 'blockStart'
     offsets.BEnd(aWM) = -offsets.BStart(aWM);
@@ -1566,8 +1554,8 @@ void ReflowInput::CalculateHypotheticalPosition(
 bool ReflowInput::IsInlineSizeComputableByBlockSizeAndAspectRatio(
     nscoord aBlockSize) const {
   WritingMode wm = GetWritingMode();
-  MOZ_ASSERT(!mStylePosition->mOffset.Get(LogicalSide::BStart, wm).IsAuto() &&
-                 !mStylePosition->mOffset.Get(LogicalSide::BEnd, wm).IsAuto(),
+  MOZ_ASSERT(!mStylePosition->GetInset(LogicalSide::BStart, wm).IsAuto() &&
+                 !mStylePosition->GetInset(LogicalSide::BEnd, wm).IsAuto(),
              "If any of the block-start and block-end are auto, aBlockSize "
              "doesn't make sense");
   NS_WARNING_ASSERTION(
@@ -1590,22 +1578,10 @@ bool ReflowInput::IsInlineSizeComputableByBlockSizeAndAspectRatio(
     return false;
   }
 
-  const auto position = mStyleDisplay->mPosition;
   // If both inline insets are non-auto, mFrame->ComputeSize() should get a
   // possible inline size by those insets, so we don't rely on aspect-ratio.
-  if (!mStylePosition->GetAnchorResolvedInset(LogicalSide::IStart, wm, position)
-           .IsAuto() &&
-      !mStylePosition->GetAnchorResolvedInset(LogicalSide::IEnd, wm, position)
-           .IsAuto()) {
-    return false;
-  }
-
-  // If block direction insets reference use any anchor positioning function
-  // that does not resolve, we can't rely on them.
-  if (mStylePosition->GetAnchorResolvedInset(LogicalSide::BStart, wm, position)
-          .IsAuto() ||
-      mStylePosition->GetAnchorResolvedInset(LogicalSide::BEnd, wm, position)
-          .IsAuto()) {
+  if (!mStylePosition->GetInset(LogicalSide::IStart, wm).IsAuto() &&
+      !mStylePosition->GetInset(LogicalSide::IEnd, wm).IsAuto()) {
     return false;
   }
 
@@ -1685,14 +1661,12 @@ void ReflowInput::InitAbsoluteConstraints(const ReflowInput* aCBReflowInput,
   NS_ASSERTION(mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW),
                "Why are we here?");
 
-  const auto& iStartOffset = mStylePosition->GetAnchorResolvedInset(
-      LogicalSide::IStart, cbwm, StylePositionProperty::Absolute);
-  const auto& iEndOffset = mStylePosition->GetAnchorResolvedInset(
-      LogicalSide::IEnd, cbwm, StylePositionProperty::Absolute);
-  const auto& bStartOffset = mStylePosition->GetAnchorResolvedInset(
-      LogicalSide::BStart, cbwm, StylePositionProperty::Absolute);
-  const auto& bEndOffset = mStylePosition->GetAnchorResolvedInset(
-      LogicalSide::BEnd, cbwm, StylePositionProperty::Absolute);
+  const auto& iStartOffset =
+      mStylePosition->GetInset(LogicalSide::IStart, cbwm);
+  const auto& iEndOffset = mStylePosition->GetInset(LogicalSide::IEnd, cbwm);
+  const auto& bStartOffset =
+      mStylePosition->GetInset(LogicalSide::BStart, cbwm);
+  const auto& bEndOffset = mStylePosition->GetInset(LogicalSide::BEnd, cbwm);
   bool iStartIsAuto = iStartOffset.IsAuto();
   bool iEndIsAuto = iEndOffset.IsAuto();
   bool bStartIsAuto = bStartOffset.IsAuto();
@@ -1778,13 +1752,13 @@ void ReflowInput::InitAbsoluteConstraints(const ReflowInput* aCBReflowInput,
     offsets.IStart(cbwm) = 0;
   } else {
     offsets.IStart(cbwm) = nsLayoutUtils::ComputeCBDependentValue(
-        cbSize.ISize(cbwm), iStartOffset.AsLengthPercentage());
+        cbSize.ISize(cbwm), iStartOffset);
   }
   if (iEndIsAuto) {
     offsets.IEnd(cbwm) = 0;
   } else {
-    offsets.IEnd(cbwm) = nsLayoutUtils::ComputeCBDependentValue(
-        cbSize.ISize(cbwm), iEndOffset.AsLengthPercentage());
+    offsets.IEnd(cbwm) =
+        nsLayoutUtils::ComputeCBDependentValue(cbSize.ISize(cbwm), iEndOffset);
   }
 
   if (iStartIsAuto && iEndIsAuto) {
@@ -1801,13 +1775,13 @@ void ReflowInput::InitAbsoluteConstraints(const ReflowInput* aCBReflowInput,
     offsets.BStart(cbwm) = 0;
   } else {
     offsets.BStart(cbwm) = nsLayoutUtils::ComputeCBDependentValue(
-        cbSize.BSize(cbwm), bStartOffset.AsLengthPercentage());
+        cbSize.BSize(cbwm), bStartOffset);
   }
   if (bEndIsAuto) {
     offsets.BEnd(cbwm) = 0;
   } else {
-    offsets.BEnd(cbwm) = nsLayoutUtils::ComputeCBDependentValue(
-        cbSize.BSize(cbwm), bEndOffset.AsLengthPercentage());
+    offsets.BEnd(cbwm) =
+        nsLayoutUtils::ComputeCBDependentValue(cbSize.BSize(cbwm), bEndOffset);
   }
 
   if (bStartIsAuto && bEndIsAuto) {

layout/generic/StickyScrollContainer.cpp

@@ -65,9 +65,8 @@ StickyScrollContainer::GetStickyScrollContainerForScrollFrame(
 static nscoord ComputeStickySideOffset(Side aSide,
                                        const nsStylePosition& aPosition,
                                        nscoord aPercentBasis) {
-  const auto& side =
-      aPosition.GetAnchorResolvedInset(aSide, StylePositionProperty::Sticky);
-  if (side.IsAuto()) {
+  const auto& side = aPosition.GetInset(aSide);
+  if (!side.IsLengthPercentage()) {
     return NS_AUTOOFFSET;
   }
   return nsLayoutUtils::ComputeCBDependentValue(aPercentBasis,

layout/generic/WritingModes.h

@@ -2125,6 +2125,11 @@ inline const mozilla::StyleMaxSize& nsStylePosition::MaxSize(
   return aAxis == mozilla::LogicalAxis::Inline ? MaxISize(aWM) : MaxBSize(aWM);
 }
 
+inline const mozilla::StyleInset& nsStylePosition::GetInset(
+    mozilla::LogicalSide aSide, mozilla::WritingMode aWM) const {
+  return GetInset(aWM.PhysicalSide(aSide));
+}
+
 inline bool nsStylePosition::ISizeDependsOnContainer(WritingMode aWM) const {
   const auto& iSize = ISize(aWM);
   return iSize.IsAuto() || ISizeCoordDependsOnContainer(iSize);

layout/generic/nsAbsoluteContainingBlock.cpp

@@ -286,8 +286,6 @@ static inline bool IsFixedMarginSize(const StyleMargin& aCoord) {
   return aCoord.ConvertsToLength();
 }
 static inline bool IsFixedOffset(const StyleInset& aInset) {
-  // For anchor positioning functions, even if the computed value may be a
-  // fixed length, it depends on the absolute containing block's size.
   return aInset.ConvertsToLength();
 }
 
@@ -342,8 +340,8 @@ bool nsAbsoluteContainingBlock::FrameDependsOnContainer(nsIFrame* f,
     // lengths?
     if ((pos->BSizeDependsOnContainer(wm) &&
          !(pos->BSize(wm).IsAuto() &&
-           pos->mOffset.Get(LogicalSide::BEnd, wm).MaybeAuto() &&
-           !pos->mOffset.Get(LogicalSide::BStart, wm).MaybeAuto())) ||
+           pos->GetInset(LogicalSide::BEnd, wm).IsAuto() &&
+           !pos->GetInset(LogicalSide::BStart, wm).IsAuto())) ||
         pos->MinBSizeDependsOnContainer(wm) ||
         pos->MaxBSizeDependsOnContainer(wm) ||
         !IsFixedPaddingSize(padding->mPadding.GetBStart(wm)) ||
@@ -365,7 +363,7 @@ bool nsAbsoluteContainingBlock::FrameDependsOnContainer(nsIFrame* f,
   // sides (left and top) that we use to store coordinates, these tests
   // are easier to do using physical coordinates rather than logical.
   if (aCBWidthChanged) {
-    if (!IsFixedOffset(pos->mOffset.Get(eSideLeft))) {
+    if (!IsFixedOffset(pos->GetInset(eSideLeft))) {
       return true;
     }
     // Note that even if 'left' is a length, our position can still
@@ -377,17 +375,17 @@ bool nsAbsoluteContainingBlock::FrameDependsOnContainer(nsIFrame* f,
     // sure of.
     if ((wm.GetInlineDir() == WritingMode::InlineDir::RTL ||
          wm.GetBlockDir() == WritingMode::BlockDir::RL) &&
-        !pos->mOffset.Get(eSideRight).MaybeAuto()) {
+        !pos->GetInset(eSideRight).IsAuto()) {
       return true;
     }
   }
   if (aCBHeightChanged) {
-    if (!IsFixedOffset(pos->mOffset.Get(eSideTop))) {
+    if (!IsFixedOffset(pos->GetInset(eSideTop))) {
       return true;
     }
     // See comment above for width changes.
     if (wm.GetInlineDir() == WritingMode::InlineDir::BTT &&
-        !pos->mOffset.Get(eSideBottom).MaybeAuto()) {
+        !pos->GetInset(eSideBottom).IsAuto()) {
       return true;
     }
   }
@@ -927,25 +925,12 @@ void nsAbsoluteContainingBlock::ReflowAbsoluteFrame(
     // align the child by its margin box:
     // https://drafts.csswg.org/css-position-3/#abspos-layout
     const auto* stylePos = aKidFrame->StylePosition();
-    auto positionProperty = aKidFrame->StyleDisplay()->mPosition;
     const bool iInsetAuto =
-        stylePos
-            ->GetAnchorResolvedInset(LogicalSide::IStart, outerWM,
-                                     positionProperty)
-            .IsAuto() ||
-        stylePos
-            ->GetAnchorResolvedInset(LogicalSide::IEnd, outerWM,
-                                     positionProperty)
-            .IsAuto();
+        stylePos->GetInset(LogicalSide::IStart, outerWM).IsAuto() ||
+        stylePos->GetInset(LogicalSide::IEnd, outerWM).IsAuto();
     const bool bInsetAuto =
-        stylePos
-            ->GetAnchorResolvedInset(LogicalSide::BStart, outerWM,
-                                     positionProperty)
-            .IsAuto() ||
-        stylePos
-            ->GetAnchorResolvedInset(LogicalSide::BEnd, outerWM,
-                                     positionProperty)
-            .IsAuto();
+        stylePos->GetInset(LogicalSide::BStart, outerWM).IsAuto() ||
+        stylePos->GetInset(LogicalSide::BEnd, outerWM).IsAuto();
     const LogicalSize logicalCBSizeOuterWM(outerWM, aContainingBlock.Size());
     const LogicalSize kidMarginBox{
         outerWM, margin.IStartEnd(outerWM) + kidSize.ISize(outerWM),

layout/generic/nsFlexContainerFrame.cpp

@@ -4640,8 +4640,8 @@ void nsFlexContainerFrame::Reflow(nsPresContext* aPresContext,
   if (bsize.HasPercent() ||
       (StyleDisplay()->IsAbsolutelyPositionedStyle() &&
        (bsize.IsAuto() || !bsize.IsLengthPercentage()) &&
-       !stylePos->mOffset.Get(LogicalSide::BStart, wm).MaybeAuto() &&
-       !stylePos->mOffset.Get(LogicalSide::BEnd, wm).MaybeAuto())) {
+       !stylePos->GetInset(LogicalSide::BStart, wm).IsAuto() &&
+       !stylePos->GetInset(LogicalSide::BEnd, wm).IsAuto())) {
     AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);
   }
 

layout/generic/nsGridContainerFrame.cpp

@@ -8434,11 +8434,9 @@ nscoord nsGridContainerFrame::MasonryLayout(GridReflowInput& aState,
                                      ? LogicalSide::IStart
                                      : LogicalSide::BStart;
         if (masonryStart == 0 ||
-            (masonryStart == kAutoLine &&
-             item->mFrame->StylePosition()
-                 ->GetAnchorResolvedInset(
-                     masonrySide, wm, item->mFrame->StyleDisplay()->mPosition)
-                 .IsAuto())) {
+            (masonryStart == kAutoLine && item->mFrame->StylePosition()
+                                              ->GetInset(masonrySide, wm)
+                                              .IsAuto())) {
           sortedItems.AppendElement(item);
         } else {
           item = nullptr;