Revert "Bug 1924090 - Apply resolved position-area influenced self-alignment properties during alignment for abspos with cb r=emilio,layout-reviewers,dshin,firefox-style-system-reviewers" for causing Wr failures on position-try-switch-to-fixed-anchor.html

This reverts commit 0a4067b.

Author: chorotan

layout/base/AnchorPositioningUtils.cpp

@@ -504,8 +504,7 @@ static StylePositionArea ToPhysicalPositionArea(StylePositionArea aPosArea,
 
 nsRect AnchorPositioningUtils::AdjustAbsoluteContainingBlockRectForPositionArea(
     const nsRect& aAnchorRect, const nsRect& aCBRect, WritingMode aPositionedWM,
-    WritingMode aCBWM, const StylePositionArea& aPosArea,
-    StylePositionArea* aOutResolvedArea) {
+    WritingMode aCBWM, const StylePositionArea& aPosArea) {
   // Get the boundaries of 3x3 grid in CB's frame space. The edges of the
   // default anchor box are clamped to the bounds of the CB, even if that
   // results in zero width/height cells.
@@ -537,7 +536,6 @@ nsRect AnchorPositioningUtils::AdjustAbsoluteContainingBlockRectForPositionArea(
   // PositionArea, resolved to only contain Left/Right/Top/Bottom values.
   StylePositionArea posArea =
       ToPhysicalPositionArea(aPosArea, aCBWM, aPositionedWM);
-  *aOutResolvedArea = posArea;
 
   nscoord right = ltrEdges[3];
   if (posArea.first == StylePositionAreaKeyword::Left) {

layout/base/AnchorPositioningUtils.h

@@ -114,7 +114,7 @@ struct AnchorPositioningUtils {
   static nsRect AdjustAbsoluteContainingBlockRectForPositionArea(
       const nsRect& aAnchorRect, const nsRect& aCBRect,
       WritingMode aPositionedWM, WritingMode aCBWM,
-      const StylePositionArea& aPosArea, StylePositionArea* aOutResolvedArea);
+      const StylePositionArea& aPosArea);
 
   /**
    * Gets the used anchor name for an anchor positioned frame.

layout/generic/AbsoluteContainingBlock.cpp

@@ -506,8 +506,7 @@ static nscoord OffsetToAlignedStaticPos(
     const ReflowInput& aKidReflowInput, const LogicalSize& aKidSizeInAbsPosCBWM,
     const LogicalSize& aAbsPosCBSize,
     const nsContainerFrame* aPlaceholderContainer, WritingMode aAbsPosCBWM,
-    LogicalAxis aAbsPosCBAxis, Maybe<NonAutoAlignParams> aNonAutoAlignParams,
-    const StylePositionArea& aPositionArea) {
+    LogicalAxis aAbsPosCBAxis, Maybe<NonAutoAlignParams> aNonAutoAlignParams) {
   if (!aPlaceholderContainer) {
     // (The placeholder container should be the thing that kicks this whole
     // process off, by setting PLACEHOLDER_STATICPOS_NEEDS_CSSALIGN.  So it
@@ -527,7 +526,6 @@ static nscoord OffsetToAlignedStaticPos(
   // WritingMode. For brevity, we use the abbreviation "pc" for "placeholder
   // container" in variables below.
   WritingMode pcWM = aPlaceholderContainer->GetWritingMode();
-  LogicalSize absPosCBSizeInPCWM = aAbsPosCBSize.ConvertTo(pcWM, aAbsPosCBWM);
 
   // Find what axis aAbsPosCBAxis corresponds to, in placeholder's parent's
   // writing-mode.
@@ -611,7 +609,7 @@ static nscoord OffsetToAlignedStaticPos(
       aNonAutoAlignParams
           ? aPlaceholderContainer
                 ->CSSAlignmentForAbsPosChildWithinContainingBlock(
-                    aKidReflowInput, pcAxis, aPositionArea, absPosCBSizeInPCWM)
+                    aKidReflowInput, pcAxis)
           : aPlaceholderContainer->CSSAlignmentForAbsPosChild(aKidReflowInput,
                                                               pcAxis);
   // If the safe bit in alignConst is set, set the safe flag in |flags|.
@@ -712,7 +710,7 @@ static nscoord OffsetToAlignedStaticPos(
 void AbsoluteContainingBlock::ResolveSizeDependentOffsets(
     ReflowInput& aKidReflowInput, const LogicalSize& aLogicalCBSize,
     const LogicalSize& aKidSize, const LogicalMargin& aMargin,
-    const StylePositionArea& aResolvedPositionArea, LogicalMargin& aOffsets) {
+    LogicalMargin& aOffsets) {
   WritingMode wm = aKidReflowInput.GetWritingMode();
   WritingMode outerWM = aKidReflowInput.mParentReflowInput->GetWritingMode();
 
@@ -747,7 +745,7 @@ void AbsoluteContainingBlock::ResolveSizeDependentOffsets(
       placeholderContainer = GetPlaceholderContainer(aKidReflowInput.mFrame);
       nscoord offset = OffsetToAlignedStaticPos(
           aKidReflowInput, aKidSize, logicalCBSizeOuterWM, placeholderContainer,
-          outerWM, LogicalAxis::Inline, Nothing{}, aResolvedPositionArea);
+          outerWM, LogicalAxis::Inline, Nothing{});
       // Shift IStart from its current position (at start corner of the
       // alignment container) by the returned offset.  And set IEnd to the
       // distance between the kid's end edge to containing block's end edge.
@@ -767,7 +765,7 @@ void AbsoluteContainingBlock::ResolveSizeDependentOffsets(
       }
       nscoord offset = OffsetToAlignedStaticPos(
           aKidReflowInput, aKidSize, logicalCBSizeOuterWM, placeholderContainer,
-          outerWM, LogicalAxis::Block, Nothing{}, aResolvedPositionArea);
+          outerWM, LogicalAxis::Block, Nothing{});
       // Shift BStart from its current position (at start corner of the
       // alignment container) by the returned offset.  And set BEnd to the
       // distance between the kid's end edge to containing block's end edge.
@@ -957,14 +955,13 @@ void AbsoluteContainingBlock::ReflowAbsoluteFrame(
 
   do {
     AutoFallbackStyleSetter fallback(aKidFrame, currentFallbackStyle);
-    auto positionArea = aKidFrame->StylePosition()->mPositionArea;
-    StylePositionArea resolvedPositionArea;
     const nsRect usedCb = [&] {
       if (isGrid) {
         // TODO(emilio): how does position-area interact with grid?
         return nsGridContainerFrame::GridItemCB(aKidFrame);
       }
 
+      auto positionArea = aKidFrame->StylePosition()->mPositionArea;
       if (currentFallback && currentFallback->IsPositionArea()) {
         MOZ_ASSERT(currentFallback->IsPositionArea());
         positionArea = currentFallback->AsPositionArea();
@@ -978,8 +975,7 @@ void AbsoluteContainingBlock::ReflowAbsoluteFrame(
               AdjustAbsoluteContainingBlockRectForPositionArea(
                   *defaultAnchorInfo.mRect, aOriginalContainingBlockRect,
                   aKidFrame->GetWritingMode(),
-                  aDelegatingFrame->GetWritingMode(), positionArea,
-                  &resolvedPositionArea);
+                  aDelegatingFrame->GetWritingMode(), positionArea);
         }
       }
 
@@ -1100,7 +1096,7 @@ void AbsoluteContainingBlock::ReflowAbsoluteFrame(
       // If we're solving for start in either inline or block direction,
       // then compute it now that we know the dimensions.
       ResolveSizeDependentOffsets(kidReflowInput, logicalCBSize, kidSize,
-                                  margin, resolvedPositionArea, offsets);
+                                  margin, offsets);
 
       if (kidReflowInput.mFlags.mDeferAutoMarginComputation) {
         ResolveAutoMarginsAfterLayout(kidReflowInput, logicalCBSize, kidSize,
@@ -1112,12 +1108,10 @@ void AbsoluteContainingBlock::ReflowAbsoluteFrame(
       // to align the child by its margin box:
       // https://drafts.csswg.org/css-position-3/#abspos-layout
       const auto* stylePos = aKidFrame->StylePosition();
-      const LogicalSize logicalCBSizeOuterWM(outerWM, usedCb.Size());
       const auto anchorResolutionParams =
-          AnchorPosOffsetResolutionParams::ExplicitCBFrameSize(
+          AnchorPosOffsetResolutionParams::UseCBFrameSize(
               AnchorPosResolutionParams::From(aKidFrame,
-                                              aAnchorPosReferenceData),
-              &logicalCBSizeOuterWM);
+                                              aAnchorPosReferenceData));
       const bool iInsetAuto =
           stylePos
               ->GetAnchorResolvedInset(LogicalSide::IStart, outerWM,
@@ -1136,6 +1130,7 @@ void AbsoluteContainingBlock::ReflowAbsoluteFrame(
               ->GetAnchorResolvedInset(LogicalSide::BEnd, outerWM,
                                        anchorResolutionParams)
               ->IsAuto();
+      const LogicalSize logicalCBSizeOuterWM(outerWM, usedCb.Size());
       const LogicalSize kidMarginBox{
           outerWM, margin.IStartEnd(outerWM) + kidSize.ISize(outerWM),
           margin.BStartEnd(outerWM) + kidSize.BSize(outerWM)};
@@ -1153,8 +1148,7 @@ void AbsoluteContainingBlock::ReflowAbsoluteFrame(
             Some(NonAutoAlignParams{
                 offsets.IStart(outerWM),
                 offsets.IEnd(outerWM),
-            }),
-            resolvedPositionArea);
+            }));
 
         offsets.IStart(outerWM) += alignOffset;
         offsets.IEnd(outerWM) =
@@ -1171,8 +1165,7 @@ void AbsoluteContainingBlock::ReflowAbsoluteFrame(
             Some(NonAutoAlignParams{
                 offsets.BStart(outerWM),
                 offsets.BEnd(outerWM),
-            }),
-            resolvedPositionArea);
+            }));
         offsets.BStart(outerWM) += alignOffset;
         offsets.BEnd(outerWM) =
             logicalCBSizeOuterWM.BSize(outerWM) -

layout/generic/AbsoluteContainingBlock.h

@@ -28,7 +28,6 @@ enum class AbsPosReflowFlag : uint8_t {
   IsGridContainerCB,
 };
 using AbsPosReflowFlags = EnumSet<AbsPosReflowFlag>;
-struct StylePositionArea;
 
 /**
  * This class contains the logic for being an absolute containing block.  This
@@ -123,10 +122,11 @@ class AbsoluteContainingBlock {
    *
    * aOffset is an outparam.
    */
-  void ResolveSizeDependentOffsets(
-      ReflowInput& aKidReflowInput, const LogicalSize& aLogicalCBSize,
-      const LogicalSize& aKidSize, const LogicalMargin& aMargin,
-      const StylePositionArea& aResolvedPositionArea, LogicalMargin& aOffsets);
+  void ResolveSizeDependentOffsets(ReflowInput& aKidReflowInput,
+                                   const LogicalSize& aLogicalCBSize,
+                                   const LogicalSize& aKidSize,
+                                   const LogicalMargin& aMargin,
+                                   LogicalMargin& aOffsets);
 
   /**
    * For frames that have intrinsic block sizes, since we want to use the

layout/generic/ReflowInput.h

@@ -981,12 +981,9 @@ struct ReflowInput : public SizeComputationInput {
 }  // namespace mozilla
 
 inline AnchorPosResolutionParams AnchorPosResolutionParams::From(
-    const mozilla::ReflowInput* aRI, bool aIgnorePositionArea) {
-  const mozilla::StylePositionArea posArea =
-      aIgnorePositionArea ? mozilla::StylePositionArea{}
-                          : aRI->mStylePosition->mPositionArea;
-  return {aRI->mFrame, aRI->mStyleDisplay->mPosition, posArea,
-          aRI->mAnchorPosReferenceData};
+    const mozilla::ReflowInput* aRI) {
+  return {aRI->mFrame, aRI->mStyleDisplay->mPosition,
+          aRI->mStylePosition->mPositionArea, aRI->mAnchorPosReferenceData};
 }
 
 #endif  // mozilla_ReflowInput_h

layout/generic/nsContainerFrame.cpp

@@ -10,7 +10,6 @@
 
 #include <algorithm>
 
-#include "AnchorPositioningUtils.h"
 #include "mozilla/AbsoluteContainingBlock.h"
 #include "mozilla/AutoRestore.h"
 #include "mozilla/ComputedStyle.h"
@@ -2625,9 +2624,7 @@ StyleAlignFlags nsContainerFrame::CSSAlignmentForAbsPosChild(
 
 StyleAlignFlags
 nsContainerFrame::CSSAlignmentForAbsPosChildWithinContainingBlock(
-    const ReflowInput& aChildRI, LogicalAxis aLogicalAxis,
-    const StylePositionArea& aResolvedPositionArea,
-    const LogicalSize& aCBSize) const {
+    const ReflowInput& aChildRI, LogicalAxis aLogicalAxis) const {
   MOZ_ASSERT(aChildRI.mFrame->IsAbsolutelyPositioned(),
              "This method should only be called for abspos children");
   // When determining the position of absolutely-positioned boxes,
@@ -2637,51 +2634,6 @@ nsContainerFrame::CSSAlignmentForAbsPosChildWithinContainingBlock(
           ? aChildRI.mStylePosition->UsedJustifySelf(nullptr)._0
           : aChildRI.mStylePosition->UsedAlignSelf(nullptr)._0;
 
-  // Check if position-area is set - if so, it determines the default alignment
-  // https://drafts.csswg.org/css-anchor-position/#position-area-alignment
-  if (!aResolvedPositionArea.IsNone() && alignment == StyleAlignFlags::NORMAL) {
-    // Check if exactly one inset in the axis is auto
-    // https://drafts.csswg.org/css-anchor-position/#position-area-alignment
-    // "However, if only one inset property in the relevant axis is auto, the
-    // default alignment is instead towards the edge with the non-auto inset;
-    // and this is an unsafe alignment."
-    const WritingMode cbWM = GetWritingMode();
-    const auto anchorResolutionParams = AnchorPosResolutionParams::From(
-        &aChildRI, /* aIgnorePositionArea = */ true);
-    const auto anchorOffsetResolutionParams =
-        AnchorPosOffsetResolutionParams::ExplicitCBFrameSize(
-            anchorResolutionParams, &aCBSize);
-
-    const LogicalSide startSide = aLogicalAxis == LogicalAxis::Inline
-                                      ? LogicalSide::IStart
-                                      : LogicalSide::BStart;
-    const LogicalSide endSide = GetOppositeSide(startSide);
-
-    const bool startInsetIsAuto =
-        aChildRI.mStylePosition
-            ->GetAnchorResolvedInset(startSide, cbWM,
-                                     anchorOffsetResolutionParams)
-            ->IsAuto();
-    const bool endInsetIsAuto =
-        aChildRI.mStylePosition
-            ->GetAnchorResolvedInset(endSide, cbWM,
-                                     anchorOffsetResolutionParams)
-            ->IsAuto();
-
-    // Exactly one inset is auto - align toward the non-auto edge, unsafely
-    if (startInsetIsAuto != endInsetIsAuto) {
-      alignment =
-          startInsetIsAuto ? StyleAlignFlags::END : StyleAlignFlags::START;
-      alignment |= StyleAlignFlags::UNSAFE;
-    } else {
-      auto keyword = aLogicalAxis == LogicalAxis::Inline
-                         ? aResolvedPositionArea.first
-                         : aResolvedPositionArea.second;
-      // Use normal position-area alignment
-      Servo_ResolvePositionAreaSelfAlignment(&keyword, &alignment);
-    }
-  }
-
   return MapCSSAlignment(alignment, aChildRI, aLogicalAxis, GetWritingMode());
 }
 

layout/generic/nsContainerFrame.h

@@ -21,7 +21,6 @@ class nsOverflowContinuationTracker;
 
 namespace mozilla {
 class PresShell;
-struct StylePositionArea;
 }  // namespace mozilla
 
 // Some macros for container classes to do sanity checking on
@@ -493,9 +492,7 @@ class nsContainerFrame : public nsSplittableFrame {
    * on its type (By overriding `CSSAlignmentForAbsPosChild`).
    */
   mozilla::StyleAlignFlags CSSAlignmentForAbsPosChildWithinContainingBlock(
-      const ReflowInput& aChildRI, mozilla::LogicalAxis aLogicalAxis,
-      const mozilla::StylePositionArea& aResolvedPositionArea,
-      const mozilla::LogicalSize& aContainingBlockSize) const;
+      const ReflowInput& aChildRI, mozilla::LogicalAxis aLogicalAxis) const;
 
 #define NS_DECLARE_FRAME_PROPERTY_FRAMELIST(prop) \
   NS_DECLARE_FRAME_PROPERTY_WITH_DTOR_NEVER_CALLED(prop, nsFrameList)

layout/style/nsStyleStruct.h

@@ -399,8 +399,7 @@ struct AnchorPosResolutionParams {
   static inline AnchorPosResolutionParams From(
       const nsIFrame* aFrame,
       mozilla::AnchorPosReferenceData* aAnchorPosReferenceData = nullptr);
-  static inline AnchorPosResolutionParams From(
-      const mozilla::ReflowInput* aRI, bool aIgnorePositionArea = false);
+  static inline AnchorPosResolutionParams From(const mozilla::ReflowInput* aRI);
   static inline AnchorPosResolutionParams From(
       const nsComputedDOMStyle* aComputedDOMStyle);
 };

servo/components/style/values/specified/position.rs

@@ -21,7 +21,6 @@ use crate::values::generics::position::ZIndex as GenericZIndex;
 use crate::values::generics::position::{AspectRatio as GenericAspectRatio, GenericAnchorSide};
 use crate::values::generics::position::{GenericAnchorFunction, GenericInset};
 use crate::values::specified;
-use crate::values::specified::align::AlignFlags;
 use crate::values::specified::{AllowQuirks, Integer, LengthPercentage, NonNegativeNumber};
 use crate::values::DashedIdent;
 use crate::{Atom, Zero};
@@ -1185,28 +1184,6 @@ impl PositionAreaKeyword {
         let new_track = old_track.flip();
         Self::from_u8((self as u8 & !TRACK_MASK) | new_track as u8).unwrap()
     }
-
-    /// Returns a value for the self-alignment properties in order to resolve
-    /// `normal`.
-    ///
-    /// <https://drafts.csswg.org/css-anchor-position/#position-area-alignment>
-    pub fn to_self_alignment(self) -> Option<AlignFlags> {
-        self.track().map(|track| match track {
-            // "If the only the center track in an axis is selected, the default alignment in that axis is center."
-            PositionAreaTrack::Center => AlignFlags::CENTER,
-            // "If all three tracks are selected, the default alignment in that axis is anchor-center."
-            PositionAreaTrack::SpanAll => AlignFlags::ANCHOR_CENTER,
-            // "Otherwise, the default alignment in that axis is toward the non-specified side track: if it’s
-            // specifying the “start” track of its axis, the default alignment in that axis is end; etc."
-            _ => {
-                if track.start() {
-                    AlignFlags::END
-                } else {
-                    AlignFlags::START
-                }
-            },
-        })
-    }
 }
 
 #[derive(

servo/ports/geckolib/glue.rs

@@ -163,15 +163,12 @@ use style::values::computed::length_percentage::{
     AllowAnchorPosResolutionInCalcPercentage, Unpacked,
 };
 use style::values::computed::position::{AnchorFunction, PositionArea};
-use style::values::computed::{
-    self, ContentVisibility, Context, PositionAreaKeyword, ToComputedValue,
-};
+use style::values::computed::{self, ContentVisibility, Context, ToComputedValue};
 use style::values::distance::{ComputeSquaredDistance, SquaredDistance};
 use style::values::generics::color::ColorMixFlags;
 use style::values::generics::easing::BeforeFlag;
 use style::values::generics::length::GenericAnchorSizeFunction;
 use style::values::resolved;
-use style::values::specified::align::AlignFlags;
 use style::values::specified::intersection_observer::IntersectionObserverMargin;
 use style::values::specified::position::DashedIdentAndOrTryTactic;
 use style::values::specified::source_size_list::SourceSizeList;
@@ -10761,19 +10758,3 @@ pub extern "C" fn Servo_PhysicalizePositionArea(
 ) {
     *area = area.to_physical(*cb_wm, *self_wm);
 }
-
-#[no_mangle]
-pub extern "C" fn Servo_ResolvePositionAreaSelfAlignment(
-    area: &PositionAreaKeyword,
-    out: &mut AlignFlags,
-) {
-    let Some(align) = area.to_self_alignment() else {
-        debug_assert!(
-            false,
-            "ResolvePositionAreaSelfAlignment called on {:?}",
-            area
-        );
-        return;
-    };
-    *out = align;
-}