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

Differential Revision: https://phabricator.services.mozilla.com/D268152

Author: keithamus

layout/base/AnchorPositioningUtils.cpp

@@ -504,7 +504,8 @@ static StylePositionArea ToPhysicalPositionArea(StylePositionArea aPosArea,
 
 nsRect AnchorPositioningUtils::AdjustAbsoluteContainingBlockRectForPositionArea(
     const nsRect& aAnchorRect, const nsRect& aCBRect, WritingMode aPositionedWM,
-    WritingMode aCBWM, const StylePositionArea& aPosArea) {
+    WritingMode aCBWM, const StylePositionArea& aPosArea,
+    StylePositionArea* aOutResolvedArea) {
   // 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.
@@ -536,6 +537,7 @@ 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);
+      const StylePositionArea& aPosArea, StylePositionArea* aOutResolvedArea);
 
   /**
    * Gets the used anchor name for an anchor positioned frame.

layout/generic/AbsoluteContainingBlock.cpp

@@ -506,7 +506,8 @@ static nscoord OffsetToAlignedStaticPos(
     const ReflowInput& aKidReflowInput, const LogicalSize& aKidSizeInAbsPosCBWM,
     const LogicalSize& aAbsPosCBSize,
     const nsContainerFrame* aPlaceholderContainer, WritingMode aAbsPosCBWM,
-    LogicalAxis aAbsPosCBAxis, Maybe<NonAutoAlignParams> aNonAutoAlignParams) {
+    LogicalAxis aAbsPosCBAxis, Maybe<NonAutoAlignParams> aNonAutoAlignParams,
+    const StylePositionArea& aPositionArea) {
   if (!aPlaceholderContainer) {
     // (The placeholder container should be the thing that kicks this whole
     // process off, by setting PLACEHOLDER_STATICPOS_NEEDS_CSSALIGN.  So it
@@ -526,6 +527,7 @@ 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.
@@ -609,7 +611,7 @@ static nscoord OffsetToAlignedStaticPos(
       aNonAutoAlignParams
           ? aPlaceholderContainer
                 ->CSSAlignmentForAbsPosChildWithinContainingBlock(
-                    aKidReflowInput, pcAxis)
+                    aKidReflowInput, pcAxis, aPositionArea, absPosCBSizeInPCWM)
           : aPlaceholderContainer->CSSAlignmentForAbsPosChild(aKidReflowInput,
                                                               pcAxis);
   // If the safe bit in alignConst is set, set the safe flag in |flags|.
@@ -710,7 +712,7 @@ static nscoord OffsetToAlignedStaticPos(
 void AbsoluteContainingBlock::ResolveSizeDependentOffsets(
     ReflowInput& aKidReflowInput, const LogicalSize& aLogicalCBSize,
     const LogicalSize& aKidSize, const LogicalMargin& aMargin,
-    LogicalMargin& aOffsets) {
+    const StylePositionArea& aResolvedPositionArea, LogicalMargin& aOffsets) {
   WritingMode wm = aKidReflowInput.GetWritingMode();
   WritingMode outerWM = aKidReflowInput.mParentReflowInput->GetWritingMode();
 
@@ -745,7 +747,7 @@ void AbsoluteContainingBlock::ResolveSizeDependentOffsets(
       placeholderContainer = GetPlaceholderContainer(aKidReflowInput.mFrame);
       nscoord offset = OffsetToAlignedStaticPos(
           aKidReflowInput, aKidSize, logicalCBSizeOuterWM, placeholderContainer,
-          outerWM, LogicalAxis::Inline, Nothing{});
+          outerWM, LogicalAxis::Inline, Nothing{}, aResolvedPositionArea);
       // 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.
@@ -765,7 +767,7 @@ void AbsoluteContainingBlock::ResolveSizeDependentOffsets(
       }
       nscoord offset = OffsetToAlignedStaticPos(
           aKidReflowInput, aKidSize, logicalCBSizeOuterWM, placeholderContainer,
-          outerWM, LogicalAxis::Block, Nothing{});
+          outerWM, LogicalAxis::Block, Nothing{}, aResolvedPositionArea);
       // 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.
@@ -955,13 +957,14 @@ 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();
@@ -975,7 +978,8 @@ void AbsoluteContainingBlock::ReflowAbsoluteFrame(
               AdjustAbsoluteContainingBlockRectForPositionArea(
                   *defaultAnchorInfo.mRect, aOriginalContainingBlockRect,
                   aKidFrame->GetWritingMode(),
-                  aDelegatingFrame->GetWritingMode(), positionArea);
+                  aDelegatingFrame->GetWritingMode(), positionArea,
+                  &resolvedPositionArea);
         }
       }
 
@@ -1096,7 +1100,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, offsets);
+                                  margin, resolvedPositionArea, offsets);
 
       if (kidReflowInput.mFlags.mDeferAutoMarginComputation) {
         ResolveAutoMarginsAfterLayout(kidReflowInput, logicalCBSize, kidSize,
@@ -1108,10 +1112,12 @@ 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::UseCBFrameSize(
+          AnchorPosOffsetResolutionParams::ExplicitCBFrameSize(
               AnchorPosResolutionParams::From(aKidFrame,
-                                              aAnchorPosReferenceData));
+                                              aAnchorPosReferenceData),
+              &logicalCBSizeOuterWM);
       const bool iInsetAuto =
           stylePos
               ->GetAnchorResolvedInset(LogicalSide::IStart, outerWM,
@@ -1130,7 +1136,6 @@ 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)};
@@ -1148,7 +1153,8 @@ void AbsoluteContainingBlock::ReflowAbsoluteFrame(
             Some(NonAutoAlignParams{
                 offsets.IStart(outerWM),
                 offsets.IEnd(outerWM),
-            }));
+            }),
+            resolvedPositionArea);
 
         offsets.IStart(outerWM) += alignOffset;
         offsets.IEnd(outerWM) =
@@ -1165,7 +1171,8 @@ 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,6 +28,7 @@ enum class AbsPosReflowFlag : uint8_t {
   IsGridContainerCB,
 };
 using AbsPosReflowFlags = EnumSet<AbsPosReflowFlag>;
+struct StylePositionArea;
 
 /**
  * This class contains the logic for being an absolute containing block.  This
@@ -122,11 +123,10 @@ class AbsoluteContainingBlock {
    *
    * aOffset is an outparam.
    */
-  void ResolveSizeDependentOffsets(ReflowInput& aKidReflowInput,
-                                   const LogicalSize& aLogicalCBSize,
-                                   const LogicalSize& aKidSize,
-                                   const LogicalMargin& aMargin,
-                                   LogicalMargin& aOffsets);
+  void ResolveSizeDependentOffsets(
+      ReflowInput& aKidReflowInput, const LogicalSize& aLogicalCBSize,
+      const LogicalSize& aKidSize, const LogicalMargin& aMargin,
+      const StylePositionArea& aResolvedPositionArea, LogicalMargin& aOffsets);
 
   /**
    * For frames that have intrinsic block sizes, since we want to use the

layout/generic/ReflowInput.h

@@ -981,9 +981,12 @@ struct ReflowInput : public SizeComputationInput {
 }  // namespace mozilla
 
 inline AnchorPosResolutionParams AnchorPosResolutionParams::From(
-    const mozilla::ReflowInput* aRI) {
-  return {aRI->mFrame, aRI->mStyleDisplay->mPosition,
-          aRI->mStylePosition->mPositionArea, aRI->mAnchorPosReferenceData};
+    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};
 }
 
 #endif  // mozilla_ReflowInput_h

layout/generic/WritingModes.h

@@ -2189,6 +2189,17 @@ inline AnchorResolvedInset nsStylePosition::GetAnchorResolvedInset(
   return GetAnchorResolvedInset(aWM.PhysicalSide(aSide), aParams);
 }
 
+inline mozilla::Maybe<mozilla::Side> nsStylePosition::GetSingleAutoInsetInAxis(
+    LogicalAxis aAxis, WritingMode aWM,
+    const AnchorPosOffsetResolutionParams& aParams) const {
+  const bool isInlineAxis = (aAxis == LogicalAxis::Inline);
+  const mozilla::StylePhysicalAxis physicalAxis =
+      (isInlineAxis == aWM.IsVertical())
+          ? mozilla::StylePhysicalAxis::Vertical
+          : mozilla::StylePhysicalAxis::Horizontal;
+  return GetSingleAutoInsetInAxis(physicalAxis, aParams);
+}
+
 inline AnchorResolvedSize nsStylePosition::ISize(
     WritingMode aWM, const AnchorPosResolutionParams& aParams) const {
   return aWM.IsVertical() ? GetHeight(aParams) : GetWidth(aParams);

layout/generic/nsContainerFrame.cpp

@@ -10,6 +10,7 @@
 
 #include <algorithm>
 
+#include "AnchorPositioningUtils.h"
 #include "mozilla/AbsoluteContainingBlock.h"
 #include "mozilla/AutoRestore.h"
 #include "mozilla/ComputedStyle.h"
@@ -2624,7 +2625,9 @@ StyleAlignFlags nsContainerFrame::CSSAlignmentForAbsPosChild(
 
 StyleAlignFlags
 nsContainerFrame::CSSAlignmentForAbsPosChildWithinContainingBlock(
-    const ReflowInput& aChildRI, LogicalAxis aLogicalAxis) const {
+    const ReflowInput& aChildRI, LogicalAxis aLogicalAxis,
+    const StylePositionArea& aResolvedPositionArea,
+    const LogicalSize& aCBSize) const {
   MOZ_ASSERT(aChildRI.mFrame->IsAbsolutelyPositioned(),
              "This method should only be called for abspos children");
   // When determining the position of absolutely-positioned boxes,
@@ -2634,6 +2637,45 @@ 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) {
+    const WritingMode cbWM = GetWritingMode();
+    const auto anchorResolutionParams = AnchorPosResolutionParams::From(
+        &aChildRI, /* aIgnorePositionArea = */ true);
+    const auto anchorOffsetResolutionParams =
+        AnchorPosOffsetResolutionParams::ExplicitCBFrameSize(
+            anchorResolutionParams, &aCBSize);
+
+    // Check if we have exactly one auto inset in this axis (IMCB situation)
+    const auto singleAutoInset =
+        aChildRI.mStylePosition->GetSingleAutoInsetInAxis(
+            aLogicalAxis, cbWM, anchorOffsetResolutionParams);
+
+    // 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."
+    if (singleAutoInset.isSome()) {
+      const LogicalSide startSide = aLogicalAxis == LogicalAxis::Inline
+                                        ? LogicalSide::IStart
+                                        : LogicalSide::BStart;
+      const mozilla::Side autoSide = *singleAutoInset;
+      const mozilla::Side startPhysicalSide = cbWM.PhysicalSide(startSide);
+      // Exactly one inset is auto - align toward the non-auto edge, unsafely
+      alignment = (autoSide == startPhysicalSide) ? 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,6 +21,7 @@ class nsOverflowContinuationTracker;
 
 namespace mozilla {
 class PresShell;
+struct StylePositionArea;
 }  // namespace mozilla
 
 // Some macros for container classes to do sanity checking on
@@ -492,7 +493,9 @@ class nsContainerFrame : public nsSplittableFrame {
    * on its type (By overriding `CSSAlignmentForAbsPosChild`).
    */
   mozilla::StyleAlignFlags CSSAlignmentForAbsPosChildWithinContainingBlock(
-      const ReflowInput& aChildRI, mozilla::LogicalAxis aLogicalAxis) const;
+      const ReflowInput& aChildRI, mozilla::LogicalAxis aLogicalAxis,
+      const mozilla::StylePositionArea& aResolvedPositionArea,
+      const mozilla::LogicalSize& aContainingBlockSize) const;
 
 #define NS_DECLARE_FRAME_PROPERTY_FRAMELIST(prop) \
   NS_DECLARE_FRAME_PROPERTY_WITH_DTOR_NEVER_CALLED(prop, nsFrameList)

layout/style/nsStyleStruct.h

@@ -399,7 +399,8 @@ struct AnchorPosResolutionParams {
   static inline AnchorPosResolutionParams From(
       const nsIFrame* aFrame,
       mozilla::AnchorPosReferenceData* aAnchorPosReferenceData = nullptr);
-  static inline AnchorPosResolutionParams From(const mozilla::ReflowInput* aRI);
+  static inline AnchorPosResolutionParams From(
+      const mozilla::ReflowInput* aRI, bool aIgnorePositionArea = false);
   static inline AnchorPosResolutionParams From(
       const nsComputedDOMStyle* aComputedDOMStyle);
 };
@@ -1089,6 +1090,40 @@ struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsStylePosition {
       mozilla::LogicalSide aSide, WritingMode aWM,
       const AnchorPosOffsetResolutionParams& aParams) const;
 
+  // Returns the side with an auto inset if exactly one inset in the given
+  // physical axis is auto. Otherwise returns Nothing().
+  mozilla::Maybe<mozilla::Side> GetSingleAutoInsetInAxis(
+      mozilla::StylePhysicalAxis aAxis,
+      const AnchorPosOffsetResolutionParams& aParams) const {
+    const mozilla::Side startSide =
+        aAxis == mozilla::StylePhysicalAxis::Horizontal ? mozilla::eSideLeft
+                                                        : mozilla::eSideTop;
+    const mozilla::Side endSide =
+        aAxis == mozilla::StylePhysicalAxis::Horizontal ? mozilla::eSideRight
+                                                        : mozilla::eSideBottom;
+
+    const bool startInsetIsAuto =
+        AnchorResolvedInsetHelper::FromUnresolved(mOffset.Get(startSide),
+                                                  startSide, aParams)
+            ->IsAuto();
+    const bool endInsetIsAuto = AnchorResolvedInsetHelper::FromUnresolved(
+                                    mOffset.Get(endSide), endSide, aParams)
+                                    ->IsAuto();
+
+    if (startInsetIsAuto && !endInsetIsAuto) {
+      return mozilla::Some(startSide);
+    }
+    if (!startInsetIsAuto && endInsetIsAuto) {
+      return mozilla::Some(endSide);
+    }
+    return mozilla::Nothing();
+  }
+
+  // Logical-axis version, defined in WritingModes.h
+  inline mozilla::Maybe<mozilla::Side> GetSingleAutoInsetInAxis(
+      LogicalAxis aAxis, WritingMode aWM,
+      const AnchorPosOffsetResolutionParams& aParams) const;
+
   AnchorResolvedSize GetWidth(const AnchorPosResolutionParams& aParams) const {
     return AnchorResolvedSizeHelper::FromUnresolved(
         mWidth, mozilla::StylePhysicalAxis::Horizontal, aParams);

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

@@ -21,6 +21,7 @@ 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};
@@ -1184,6 +1185,29 @@ 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> {
+        let track = self.track()?;
+        Some(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(