/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
 * code for managing absolutely positioned children of a rendering
 * object that is a containing block for them
 */

#include "mozilla/AbsoluteContainingBlock.h"

#include "AnchorPositioningUtils.h"
#include "mozilla/CSSAlignUtils.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/PresShell.h"
#include "mozilla/ReflowInput.h"
#include "mozilla/ScrollContainerFrame.h"
#include "mozilla/ServoStyleSet.h"
#include "mozilla/ViewportFrame.h"
#include "mozilla/dom/ViewTransition.h"
#include "nsCSSFrameConstructor.h"
#include "nsContainerFrame.h"
#include "nsGridContainerFrame.h"
#include "nsIFrameInlines.h"
#include "nsPlaceholderFrame.h"
#include "nsPresContext.h"
#include "nsPresContextInlines.h"

#ifdef DEBUG
#  include "fmt/format.h"
#  include "nsBlockFrame.h"
#endif

using namespace mozilla;

void AbsoluteContainingBlock::SetInitialChildList(nsIFrame* aDelegatingFrame,
                                                  FrameChildListID aListID,
                                                  nsFrameList&& aChildList) {
  MOZ_ASSERT(aListID == FrameChildListID::Absolute, "unexpected child list");
#ifdef DEBUG
  nsIFrame::VerifyDirtyBitSet(aChildList);
  for (nsIFrame* f : aChildList) {
    MOZ_ASSERT(f->GetParent() == aDelegatingFrame, "Unexpected parent");
  }
#endif
  mAbsoluteFrames = std::move(aChildList);
}

void AbsoluteContainingBlock::AppendFrames(nsIFrame* aDelegatingFrame,
                                           FrameChildListID aListID,
                                           nsFrameList&& aFrameList) {
  MOZ_ASSERT(aListID == FrameChildListID::Absolute, "unexpected child list");

  // Append the frames to our list of absolutely positioned frames
#ifdef DEBUG
  nsIFrame::VerifyDirtyBitSet(aFrameList);
#endif
  mAbsoluteFrames.AppendFrames(nullptr, std::move(aFrameList));

  // no damage to intrinsic widths, since absolutely positioned frames can't
  // change them
  aDelegatingFrame->PresShell()->FrameNeedsReflow(
      aDelegatingFrame, IntrinsicDirty::None, NS_FRAME_HAS_DIRTY_CHILDREN);
}

void AbsoluteContainingBlock::InsertFrames(nsIFrame* aDelegatingFrame,
                                           FrameChildListID aListID,
                                           nsIFrame* aPrevFrame,
                                           nsFrameList&& aFrameList) {
  MOZ_ASSERT(aListID == FrameChildListID::Absolute, "unexpected child list");
  NS_ASSERTION(!aPrevFrame || aPrevFrame->GetParent() == aDelegatingFrame,
               "inserting after sibling frame with different parent");

#ifdef DEBUG
  nsIFrame::VerifyDirtyBitSet(aFrameList);
#endif
  mAbsoluteFrames.InsertFrames(nullptr, aPrevFrame, std::move(aFrameList));

  // no damage to intrinsic widths, since absolutely positioned frames can't
  // change them
  aDelegatingFrame->PresShell()->FrameNeedsReflow(
      aDelegatingFrame, IntrinsicDirty::None, NS_FRAME_HAS_DIRTY_CHILDREN);
}

void AbsoluteContainingBlock::RemoveFrame(FrameDestroyContext& aContext,
                                          FrameChildListID aListID,
                                          nsIFrame* aOldFrame) {
  MOZ_ASSERT(aListID == FrameChildListID::Absolute, "unexpected child list");

  AutoTArray<nsIFrame*, 8> delFrames;
  for (nsIFrame* f = aOldFrame; f; f = f->GetNextInFlow()) {
    delFrames.AppendElement(f);
  }
  for (nsIFrame* delFrame : Reversed(delFrames)) {
    delFrame->GetParent()->GetAbsoluteContainingBlock()->StealFrame(delFrame);
    delFrame->Destroy(aContext);
  }
}

// In a fragmented context, for an absolutely positioned frame, this property
// stores the logical border-box position that the frame would have, if its
// abspos containing block were not being fragmented. The value for this
// property is determined by performing a special reflow on the abspos
// containing block (or a larger subtree that includes it), with an
// unconstrained available block-size.
//
// The position is relative to the absolute containing block's border-box, and
// is stored in the containing block's writing mode.
//
// Note: caller should use GetUnfragmentedPosition() helper to get the property.
NS_DECLARE_FRAME_PROPERTY_DELETABLE(UnfragmentedPositionProperty, LogicalPoint)

// Corresponding property to above, for the size of an absolutely positioned
// frame. However, there are important distinctions to note:
// 1. Writing mode is that of the absolutely positioned frame's.
// 2. Stores border-box size for box-sizing: border-box, or content box size for
//    box-sizing: content-box.
NS_DECLARE_FRAME_PROPERTY_DELETABLE(UnfragmentedSizeProperty, LogicalSize)

// In a fragmented context, for an absolute containing block, this property
// stores the unfragmented containing block rects. This is used to allow
// proper percentage-sizing of its children.
NS_DECLARE_FRAME_PROPERTY_DELETABLE(
    UnfragmentedContainingBlockProperty,
    AbsoluteContainingBlock::ContainingBlockRects)

static LogicalPoint* GetUnfragmentedPosition(const ReflowInput& aCBReflowInput,
                                             const nsIFrame* aFrame) {
  // If the absolute containing block is in a measuring reflow, then aFrame's
  // unfragmented position is going to be updated. Don't return the obsolete
  // value in the property.
  return aCBReflowInput.mFlags.mIsInFragmentainerMeasuringReflow
             ? nullptr
             : aFrame->GetProperty(UnfragmentedPositionProperty());
}

static LogicalSize* GetUnfragmentedSize(const ReflowInput& aCBReflowInput,
                                        const nsIFrame* aFrame) {
  return aCBReflowInput.mFlags.mIsInFragmentainerMeasuringReflow
             ? nullptr
             // Later fragment frames need to know the size for resolving
             // automatic sizes.
             : aFrame->FirstInFlow()->GetProperty(UnfragmentedSizeProperty());
}

nsFrameList AbsoluteContainingBlock::StealPushedChildList() {
  return std::move(mPushedAbsoluteFrames);
}

void AbsoluteContainingBlock::DrainPushedChildList(
    const nsIFrame* aDelegatingFrame) {
  MOZ_ASSERT(aDelegatingFrame->GetAbsoluteContainingBlock() == this,
             "aDelegatingFrame's absCB should be us!");

  // Our pushed absolute child list might be non-empty if our next-in-flow
  // hasn't reflowed yet. Move any child in that list that is a first-in-flow,
  // or whose prev-in-flow is not in our absolute child list, into our absolute
  // child list.
  for (auto iter = mPushedAbsoluteFrames.begin();
       iter != mPushedAbsoluteFrames.end();) {
    // Advance the iterator first, so it's safe to move |child|.
    nsIFrame* const child = *iter++;
    if (!child->GetPrevInFlow() ||
        child->GetPrevInFlow()->GetParent() != aDelegatingFrame) {
      mPushedAbsoluteFrames.RemoveFrame(child);
      mAbsoluteFrames.AppendFrame(nullptr, child);
      if (!child->GetPrevInFlow()) {
        child->RemoveStateBits(NS_FRAME_IS_PUSHED_OUT_OF_FLOW);
      }
    }
  }
}

bool AbsoluteContainingBlock::PrepareAbsoluteFrames(
    nsContainerFrame* aDelegatingFrame) {
  if (const nsIFrame* prevInFlow = aDelegatingFrame->GetPrevInFlow()) {
    AbsoluteContainingBlock* prevAbsCB =
        prevInFlow->GetAbsoluteContainingBlock();
    MOZ_ASSERT(prevAbsCB,
               "If this delegating frame has an absCB, its prev-in-flow must "
               "have one, too!");

    // Prepend the pushed absolute frames from the previous absCB to our
    // absolute child list.
    nsFrameList pushedFrames = prevAbsCB->StealPushedChildList();
    if (pushedFrames.NotEmpty()) {
      mAbsoluteFrames.InsertFrames(aDelegatingFrame, nullptr,
                                   std::move(pushedFrames));

      // After stealing children from the previous absCB, traverse our children
      // and see if any child has a prev-in-flow that is also in our child list.
      // If so, we insert them at the front of our pushed child list.
      nsFrameList newPushedAbsoluteFrames;
      for (auto iter = mAbsoluteFrames.begin();
           iter != mAbsoluteFrames.end();) {
        // Advance the iterator first, so it's safe to move |child|.
        nsIFrame* const child = *iter++;
        nsIFrame* const childPrevInFlow = child->GetPrevInFlow();
        if (childPrevInFlow &&
            childPrevInFlow->GetParent() == aDelegatingFrame) {
          mAbsoluteFrames.RemoveFrame(child);
          newPushedAbsoluteFrames.AppendFrame(nullptr, child);
        }
      }
      if (newPushedAbsoluteFrames.NotEmpty()) {
        // Prepend the new pushed frames to the front of mPushedAbsoluteFrames.
        mPushedAbsoluteFrames.InsertFrames(nullptr, nullptr,
                                           std::move(newPushedAbsoluteFrames));
      }
    }
  }

  // Similarly, for any children in our pushed child list that don't have a
  // prev-in-flow in our regular child list, we move those children back into
  // our child list.
  DrainPushedChildList(aDelegatingFrame);

  // Steal absolute frame's first-in-flow from our next-in-flow's child lists.
  for (const nsIFrame* nextInFlow = aDelegatingFrame->GetNextInFlow();
       nextInFlow; nextInFlow = nextInFlow->GetNextInFlow()) {
    AbsoluteContainingBlock* nextAbsCB =
        nextInFlow->GetAbsoluteContainingBlock();
    MOZ_ASSERT(nextAbsCB,
               "If this delegating frame has an absCB, its next-in-flow must "
               "have one, too!");

    nextAbsCB->DrainPushedChildList(nextInFlow);

    for (auto iter = nextAbsCB->GetChildList().begin();
         iter != nextAbsCB->GetChildList().end();) {
      // Advance the iterator first, so it's safe to move |child|.
      nsIFrame* const child = *iter++;
      if (!child->GetPrevInFlow()) {
        nextAbsCB->StealFrame(child);
        mAbsoluteFrames.AppendFrame(aDelegatingFrame, child);
        child->RemoveStateBits(NS_FRAME_IS_PUSHED_OUT_OF_FLOW);
      }
    }
  }

  return HasAbsoluteFrames();
}

void AbsoluteContainingBlock::StealFrame(nsIFrame* aFrame) {
  const DebugOnly<bool> frameRemoved =
      mAbsoluteFrames.StartRemoveFrame(aFrame) ||
      mPushedAbsoluteFrames.ContinueRemoveFrame(aFrame);
  MOZ_ASSERT(frameRemoved, "Failed to find aFrame from our child lists!");
}

#ifdef DEBUG
void AbsoluteContainingBlock::SanityCheckChildListsBeforeReflow(
    const nsIFrame* aDelegatingFrame) const {
  // TODO(TYLin): This is potentially O(N^2), where N is the number of
  // continuations that an abspos frame gets. Consider putting this behind an
  // about:config pref if it turns out to slow down debug builds too much.
  for (const nsIFrame* child : mAbsoluteFrames) {
    for (nsIFrame* prev = child->GetPrevInFlow(); prev;
         prev = prev->GetPrevInFlow()) {
      MOZ_ASSERT(!GetChildList().ContainsFrame(prev),
                 "It is wrong that both a child and its prev-in-flow are in "
                 "our child list!");
    }
  }

  {
    // Verify that continuations are ordered across both lists concatenated.
    // If a frame and its continuation are both present, the continuation must
    // appear later.
    nsTHashSet<const nsIFrame*> allFrames;
    for (const nsFrameList* list : {&mAbsoluteFrames, &mPushedAbsoluteFrames}) {
      for (const nsIFrame* child : *list) {
        allFrames.Insert(child);
      }
    }

    nsTHashSet<const nsIFrame*> seen;
    auto CheckOrder = [&](const nsIFrame* child) {
      seen.Insert(child);
      const nsIFrame* prev = child->GetPrevInFlow();
      if (prev && allFrames.Contains(prev)) {
        MOZ_ASSERT(seen.Contains(prev),
                   "A frame's continuation appears before the frame in "
                   "mAbsoluteFrames + mPushedAbsoluteFrames!");
      }
    };
    for (const nsFrameList* list : {&mAbsoluteFrames, &mPushedAbsoluteFrames}) {
      for (const nsIFrame* child : *list) {
        CheckOrder(child);
      }
    }
  }

  for (const nsIFrame* next = aDelegatingFrame->GetNextInFlow(); next;
       next = next->GetNextInFlow()) {
    auto* nextAbsCB = next->GetAbsoluteContainingBlock();
    MOZ_ASSERT(nextAbsCB,
               "Delegating frame's next-in-flow should have "
               "AbsoluteContainingBlock!");
    for (nsIFrame* child : nextAbsCB->GetChildList()) {
      MOZ_ASSERT(
          child->GetPrevInFlow(),
          "We should've pulled all abspos first-in-flows to our child list!");
    }
  }
}
#endif

static void MaybeMarkAncestorsAsHavingDescendantDependentOnItsStaticPos(
    nsIFrame* aFrame, nsIFrame* aContainingBlockFrame) {
  MOZ_ASSERT(aFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW));
  if (!aFrame->StylePosition()->NeedsHypotheticalPositionIfAbsPos()) {
    return;
  }
  // We should have set the bit when reflowing the previous continuations
  // already.
  if (aFrame->GetPrevContinuation()) {
    return;
  }

  auto* placeholder = aFrame->GetPlaceholderFrame();
  MOZ_ASSERT(placeholder);

  // Only fixed-pos frames can escape their containing block.
  if (!placeholder->HasAnyStateBits(PLACEHOLDER_FOR_FIXEDPOS)) {
    return;
  }

  for (nsIFrame* ancestor = placeholder->GetParent(); ancestor;
       ancestor = ancestor->GetParent()) {
    // Walk towards the ancestor's first continuation. That's the only one that
    // really matters, since it's the only one restyling will look at. We also
    // flag the following continuations just so it's caught on the first
    // early-return ones just to avoid walking them over and over.
    do {
      if (ancestor->DescendantMayDependOnItsStaticPosition()) {
        return;
      }
      // Moving the containing block or anything above it would move our static
      // position as well, so no need to flag it or any of its ancestors.
      if (aFrame == aContainingBlockFrame) {
        return;
      }
      ancestor->SetDescendantMayDependOnItsStaticPosition(true);
      nsIFrame* prev = ancestor->GetPrevContinuation();
      if (!prev) {
        break;
      }
      ancestor = prev;
    } while (true);
  }
}

static bool IsSnapshotContainingBlock(const nsIFrame* aFrame) {
  return aFrame->Style()->GetPseudoType() ==
         PseudoStyleType::MozSnapshotContainingBlock;
}

static PhysicalAxes CheckEarlyCompensatingForScroll(const nsIFrame* aKidFrame) {
  // Three conditions to compensate for scroll, once a default anchor
  // exists:
  // * Used alignment property is `anchor-center`,
  // * `position-area` is not `none`, or
  // * `anchor()` function refers to default anchor, or an anchor that
  //   shares the same scroller with it.
  // First two conditions are checkable right now, so do that.
  if (!aKidFrame->StylePosition()->mPositionArea.IsNone()) {
    return PhysicalAxes{PhysicalAxis::Horizontal, PhysicalAxis::Vertical};
  }
  PhysicalAxes result;
  const auto cbwm = aKidFrame->GetParent()->GetWritingMode();
  // We don't concern ourselves with align/justify-items here, because
  // they don't apply to absolute positioned boxes [1].
  // [1]: https://drafts.csswg.org/css-align-3/#justify-self-property
  if (aKidFrame->StylePosition()->mAlignSelf._0 &
      StyleAlignFlags::ANCHOR_CENTER) {
    result +=
        cbwm.IsVertical() ? PhysicalAxis::Horizontal : PhysicalAxis::Vertical;
  }
  if (aKidFrame->StylePosition()->mJustifySelf._0 &
      StyleAlignFlags::ANCHOR_CENTER) {
    result +=
        cbwm.IsVertical() ? PhysicalAxis::Vertical : PhysicalAxis::Horizontal;
  }
  return result;
}

static AnchorPosResolutionCache PopulateAnchorResolutionCache(
    const nsIFrame* aKidFrame, AnchorPosReferenceData* aData,
    bool aReuseUnfragmentedAnchorPosReferences) {
  MOZ_ASSERT(aKidFrame->HasAnchorPosReference());
  if (aReuseUnfragmentedAnchorPosReferences) [[unlikely]] {
    MOZ_ASSERT(
        aKidFrame->FirstInFlow()->HasProperty(UnfragmentedPositionProperty()));
    // We inherited reference data from unfragmented reflow, but still need to
    // repopulate the cache.
    AnchorPosDefaultAnchorCache cache;
    if (aData->mDefaultAnchorName) {
      const auto* presShell = aKidFrame->PresShell();
      cache.mAnchor = presShell->GetAnchorPosAnchor(
          ScopedNameRef{aData->mDefaultAnchorName, aData->mAnchorTreeScope},
          aKidFrame->FirstInFlow());
      MOZ_ASSERT(cache.mAnchor);
      cache.mScrollContainer =
          AnchorPositioningUtils::GetNearestScrollFrame(cache.mAnchor)
              .mScrollContainer;
    }
    return {aData, cache};
  }

  // If the default anchor exists, it will likely be referenced (Except when
  // authors then use `anchor()` without referring to anchors whose nearest
  // scroller that of the default anchor, but that seems
  // counter-productive). This is a prerequisite for scroll compensation. We
  // also need to check for `anchor()` resolutions, so cache information for
  // default anchor and its scrollers right now.
  AnchorPosResolutionCache result{aData, {}};
  // Let this call populate the cache.
  const auto defaultAnchorInfo = AnchorPositioningUtils::ResolveAnchorPosRect(
      aKidFrame, aKidFrame->GetParent(),
      {nullptr, StyleCascadeLevel::Default()}, false, &result);
  if (defaultAnchorInfo) {
    aData->AdjustCompensatingForScroll(
        CheckEarlyCompensatingForScroll(aKidFrame));
  }
  return result;
}

static nsRect ComputeScrollableContainingBlock(
    const nsContainerFrame* aDelegatingFrame, const nsRect& aContainingBlock,
    const OverflowAreas* aOverflowAreas) {
  if (aOverflowAreas && aDelegatingFrame->Style()->GetPseudoType() ==
                            PseudoStyleType::MozScrolledContent) {
    // FIXME(bug 2004432): This is close enough to what we want. In practice
    // we don't want to account for relative positioning and so on, but this
    // seems good enough for now.
    ScrollContainerFrame* sf = do_QueryFrame(aDelegatingFrame->GetParent());
    // Clamp to the scrollable range.
    return sf->GetUnsnappedScrolledRectInternal(
        aOverflowAreas->ScrollableOverflow(), aContainingBlock.Size());
  }
  return aContainingBlock;
}

static SideBits GetScrollCompensatedSidesFor(
    const StylePositionArea& aPositionArea) {
  SideBits sides{SideBits::eNone};
  // The opposite side of the direction keyword is attached to the
  // position-anchor grid, which is then attached to the anchor, and so is
  // scroll compensated. `center` is constrained by the position-area grid
  // on both sides. `span-all` is unconstrained in that axis.
  if (aPositionArea.first == StylePositionAreaKeyword::Left ||
      aPositionArea.first == StylePositionAreaKeyword::SpanLeft) {
    sides |= SideBits::eRight;
  } else if (aPositionArea.first == StylePositionAreaKeyword::Right ||
             aPositionArea.first == StylePositionAreaKeyword::SpanRight) {
    sides |= SideBits::eLeft;
  } else if (aPositionArea.first == StylePositionAreaKeyword::Center) {
    sides |= SideBits::eLeftRight;
  }

  if (aPositionArea.second == StylePositionAreaKeyword::Top ||
      aPositionArea.second == StylePositionAreaKeyword::SpanTop) {
    sides |= SideBits::eBottom;
  } else if (aPositionArea.second == StylePositionAreaKeyword::Bottom ||
             aPositionArea.second == StylePositionAreaKeyword::SpanBottom) {
    sides |= SideBits::eTop;
  } else if (aPositionArea.first == StylePositionAreaKeyword::Center) {
    sides |= SideBits::eTopBottom;
  }

  return sides;
}

struct ModifiedContainingBlock {
  using AnchorOffsetInfo = AbsoluteContainingBlock::AnchorOffsetInfo;

  Maybe<AnchorOffsetInfo> mAnchorOffsetInfo;
  // Unmodified scrollable or local containing block
  nsRect mMaybeScrollableRect;
  // Containing block after all its modifications e.g. By grid/position-area.
  nsRect mFinalRect;

  explicit ModifiedContainingBlock(const nsRect& aRect)
      : mMaybeScrollableRect{aRect}, mFinalRect{aRect} {}
  ModifiedContainingBlock(const nsRect& aMaybeScrollableRect,
                          const nsRect& aFinalRect)
      : mMaybeScrollableRect{aMaybeScrollableRect}, mFinalRect{aFinalRect} {}
  ModifiedContainingBlock(const nsPoint& aOffset,
                          const StylePositionArea& aResolvedArea,
                          const nsRect& aMaybeScrollableRect,
                          const nsRect& aFinalRect)
      : mAnchorOffsetInfo{Some(AnchorOffsetInfo{aOffset, aResolvedArea})},
        mMaybeScrollableRect{aMaybeScrollableRect},
        mFinalRect{aFinalRect} {}

  AnchorOffsetInfo GetAnchorOffsetInfo() const {
    return mAnchorOffsetInfo.valueOr(AnchorOffsetInfo{});
  }
  StylePositionArea ResolvedPositionArea() const {
    return mAnchorOffsetInfo
        .map([](const AnchorOffsetInfo& aInfo) {
          return aInfo.mResolvedPositionArea;
        })
        .valueOr(StylePositionArea{});
  }
};

static ModifiedContainingBlock ComputeContainingBlock(
    bool aIsGrid, const nsContainerFrame* aDelegatingFrame,
    const ReflowInput& aReflowInput,
    const AbsoluteContainingBlock::ContainingBlockRects& aContainingBlockRects,
    nsIFrame* aKidFrame, AnchorPosResolutionCache* aAnchorPosResolutionCache,
    bool aReuseUnfragmentedAnchorPosReferences) {
  if (aReuseUnfragmentedAnchorPosReferences) {
    MOZ_ASSERT(aAnchorPosResolutionCache);
    const auto* referenceData = aAnchorPosResolutionCache->mReferenceData;
    if (const auto positionArea = aKidFrame->StylePosition()->mPositionArea;
        !positionArea.IsNone()) {
      return ModifiedContainingBlock{
          referenceData->mDefaultScrollShift,
          AnchorPositioningUtils::PhysicalizePositionArea(positionArea,
                                                          aKidFrame),
          referenceData->mOriginalContainingBlockRect,
          referenceData->mAdjustedContainingBlock};
    }
    return ModifiedContainingBlock{referenceData->mOriginalContainingBlockRect,
                                   referenceData->mAdjustedContainingBlock};
  }
  // The current containing block, with ongoing modifications.
  // Starts as a local containing block.
  nsRect containingBlock = aContainingBlockRects.mLocal;
  nsRect scrollableContainingBlock = aContainingBlockRects.mScrollable;
  const auto defaultAnchorInfo = [&]() -> Maybe<AnchorPosInfo> {
    if (!aAnchorPosResolutionCache) {
      return Nothing{};
    }
    return AnchorPositioningUtils::ResolveAnchorPosRect(
        aKidFrame, aDelegatingFrame, {nullptr, StyleCascadeLevel::Default()},
        false, aAnchorPosResolutionCache);
  }();
  if (defaultAnchorInfo) {
    // Presence of a valid default anchor causes us to use the scrollable
    // containing block.
    // https://github.com/w3c/csswg-drafts/issues/12552#issuecomment-3210696721
    containingBlock = aContainingBlockRects.mScrollable;
  }

  if (const ViewportFrame* viewport = do_QueryFrame(aDelegatingFrame)) {
    if (IsSnapshotContainingBlock(aKidFrame)) {
      return ModifiedContainingBlock{
          dom::ViewTransition::SnapshotContainingBlockRect(
              viewport->PresContext())};
    }
    MOZ_ASSERT(aContainingBlockRects.mScrollable ==
               aContainingBlockRects.mLocal);
    containingBlock = scrollableContainingBlock =
        viewport->GetContainingBlockAdjustedForScrollbars(aReflowInput);
  }

  // https://drafts.csswg.org/css-position/#original-cb
  // Handle grid-based adjustment first...
  if (aIsGrid) {
    const auto border = aDelegatingFrame->GetUsedBorder();
    const nsPoint borderShift{border.left, border.top};
    const nsRect preGridCB = containingBlock;
    // Shift in by border of the overall grid container.
    containingBlock = nsGridContainerFrame::GridItemCB(aKidFrame) + borderShift;
    if (!defaultAnchorInfo) {
      return ModifiedContainingBlock{preGridCB, containingBlock};
    }
  }
  // ... Then the position-area based adjustment.
  if (defaultAnchorInfo) {
    auto positionArea = aKidFrame->StylePosition()->mPositionArea;
    // Offset should be up to, but not including the containing block's
    // scroll offset.
    const auto offset = AnchorPositioningUtils::GetScrollOffsetFor(
        aAnchorPosResolutionCache->mReferenceData->CompensatingForScrollAxes(),
        aKidFrame, aAnchorPosResolutionCache->mDefaultAnchorCache);
    StylePositionArea resolvedPositionArea{};
    if (!positionArea.IsNone()) {
      // Imagine an abspos container with a scroller in it, and then an
      // anchor in it, where the anchor is visually in the middle of the
      // scrollport. Then, when the scroller moves such that the anchor's
      // left edge is on that of the scrollports, w.r.t. containing block,
      // the anchor is zero left offset horizontally. The position-area
      // grid needs to account for this.
      const auto scrolledAnchorRect = defaultAnchorInfo->mRect - offset;
      const auto scrolledAnchorCb = AnchorPositioningUtils::
          AdjustAbsoluteContainingBlockRectForPositionArea(
              scrolledAnchorRect + aContainingBlockRects.mLocal.TopLeft(),
              containingBlock, aKidFrame->GetWritingMode(),
              aDelegatingFrame->GetWritingMode(), positionArea,
              &resolvedPositionArea);
      // By definition, we're using the default anchor, and are scroll
      // compensated.
      aAnchorPosResolutionCache->mReferenceData->mScrollCompensatedSides =
          GetScrollCompensatedSidesFor(resolvedPositionArea);
      // Unscroll the CB by canceling out the previously applied
      // scroll offset (See above), the offset will be applied later.
      containingBlock = scrolledAnchorCb + offset;
    }
    return ModifiedContainingBlock{offset, resolvedPositionArea,
                                   scrollableContainingBlock, containingBlock};
  }
  return ModifiedContainingBlock{containingBlock};
}

void AbsoluteContainingBlock::Reflow(nsContainerFrame* aDelegatingFrame,
                                     nsPresContext* aPresContext,
                                     const ReflowInput& aReflowInput,
                                     nsReflowStatus& aReflowStatus,
                                     const nsRect& aContainingBlock,
                                     AbsPosReflowFlags aFlags,
                                     OverflowAreas* aOverflowAreas) {
  const auto scrollableContainingBlock = ComputeScrollableContainingBlock(
      aDelegatingFrame, aContainingBlock, aOverflowAreas);
  const ContainingBlockRects passedContainingBlock{aContainingBlock,
                                                   scrollableContainingBlock};

  const auto* unfragmentedContainingBlockRects =
      [&]() -> const ContainingBlockRects* {
    if (aReflowInput.mFlags.mIsInFragmentainerMeasuringReflow) {
      // Doing the measuring reflow, so set the unfragmented containing sizes
      // here.
      NS_WARNING_ASSERTION(aDelegatingFrame->FirstInFlow() == aDelegatingFrame,
                           "Saving unfragmented CB into non-first-in-flow");
      aDelegatingFrame->SetOrUpdateDeletableProperty(
          UnfragmentedContainingBlockProperty(), passedContainingBlock);
      // Just reuse what was passed in.
      return &passedContainingBlock;
    }
    if (const auto* unfragmented = aDelegatingFrame->FirstInFlow()->GetProperty(
            UnfragmentedContainingBlockProperty())) {
      return unfragmented;
    }
    return &passedContainingBlock;
  }();

  const auto* fragmentedContainingBlockRects =
      unfragmentedContainingBlockRects != &passedContainingBlock
          ? &passedContainingBlock
          : nullptr;

#ifdef DEBUG
  SanityCheckChildListsBeforeReflow(aDelegatingFrame);
#endif

  if (nsIFrame* prevInFlow = aDelegatingFrame->GetPrevInFlow()) {
    const auto* prevAbsCB = prevInFlow->GetAbsoluteContainingBlock();
    MOZ_ASSERT(prevAbsCB,
               "If this delegating frame has an absCB, its prev-in-flow must "
               "have one, too!");
    mCumulativeContainingBlockBSize =
        prevAbsCB->mCumulativeContainingBlockBSize;
  } else {
    mCumulativeContainingBlockBSize = 0;
  }

  nsReflowStatus reflowStatus;
  // Assume all the kids may need a reflow when they are in a fragmented
  // context. We'll perform more targeted check below. For example, skip reflow
  // them when they are positioned in a later fragment.
  const bool reflowAll = aReflowInput.ShouldReflowAllKids() ||
                         aReflowInput.IsInFragmentedContext();
  const bool cbWidthChanged = aFlags.contains(AbsPosReflowFlag::CBWidthChanged);
  const bool cbHeightChanged =
      aFlags.contains(AbsPosReflowFlag::CBHeightChanged);
  const nscoord availBSize = aReflowInput.AvailableBSize();
  const WritingMode containerWM = aReflowInput.GetWritingMode();
  nsFrameList newPushedAbsoluteFrames;
  for (auto iter = mAbsoluteFrames.begin(); iter != mAbsoluteFrames.end();) {
    // Advance the iterator first, so it's safe to move |kidFrame|.
    nsIFrame* const kidFrame = *iter++;
    bool reuseUnfragmentedAnchorPosReferences = false;
    Maybe<AnchorPosResolutionCache> anchorPosResolutionCache;
    if (kidFrame->HasAnchorPosReference()) {
      AnchorPosReferenceData* referenceData = nullptr;
      if (const auto* firstInFlow = kidFrame->FirstInFlow();
          GetUnfragmentedPosition(aReflowInput, firstInFlow)) {
        // Ok, we've done a measuring reflow with no fragmentation, and so the
        // unfragmented position property is now set. Use the existing
        // references, which contains the anchor lookup data from the measuring
        // reflow.
        referenceData =
            firstInFlow->GetProperty(nsIFrame::AnchorPosReferences());
        reuseUnfragmentedAnchorPosReferences = true;
      }
      if (!referenceData) {
        referenceData = kidFrame->SetOrUpdateDeletableProperty(
            nsIFrame::AnchorPosReferences());
      }
      anchorPosResolutionCache = Some(PopulateAnchorResolutionCache(
          kidFrame, referenceData, reuseUnfragmentedAnchorPosReferences));
    } else {
      kidFrame->RemoveProperty(nsIFrame::AnchorPosReferences());
    }

    bool kidNeedsReflow =
        reflowAll || kidFrame->IsSubtreeDirty() ||
        FrameDependsOnContainer(kidFrame, cbWidthChanged, cbHeightChanged,
                                anchorPosResolutionCache.ptrOr(nullptr));
    if (kidFrame->IsSubtreeDirty()) {
      MaybeMarkAncestorsAsHavingDescendantDependentOnItsStaticPos(
          kidFrame, aDelegatingFrame);
    }
    if (kidNeedsReflow && !aPresContext->HasPendingInterrupt()) {
      const LogicalSize cbSize(containerWM,
                               unfragmentedContainingBlockRects->mLocal.Size());
      const LogicalMargin border =
          aDelegatingFrame->GetLogicalUsedBorder(containerWM)
              .ApplySkipSides(
                  aDelegatingFrame->PreReflowBlockLevelLogicalSkipSides());
      const nsSize cbBorderBoxSize =
          (cbSize + border.Size(containerWM)).GetPhysicalSize(containerWM);

      bool kidFrameNeedsPush = false;
      if (const auto* unfragPos =
              GetUnfragmentedPosition(aReflowInput, kidFrame);
          unfragPos && availBSize != NS_UNCONSTRAINEDSIZE) {
        // If kidFrame's position in this fragment is beyond the end of this
        // fragmentainer, push it to the next fragmentainer.
        const nscoord kidBPosInThisFragment =
            unfragPos->B(containerWM) - mCumulativeContainingBlockBSize;
        if (kidBPosInThisFragment > availBSize) {
          kidFrameNeedsPush = true;
        }
      }

      OverflowAreas kidOverflowAreas;
      nsReflowStatus kidStatus;
      if (!kidFrameNeedsPush) {
        ReflowAbsoluteFrame(aDelegatingFrame, aPresContext, aReflowInput,
                            *unfragmentedContainingBlockRects, aFlags, kidFrame,
                            kidStatus, aOverflowAreas,
                            fragmentedContainingBlockRects,
                            anchorPosResolutionCache.ptrOr(nullptr),
                            reuseUnfragmentedAnchorPosReferences);

        if (aReflowInput.mFlags.mIsInFragmentainerMeasuringReflow) {
          kidFrame->SetOrUpdateDeletableProperty(
              UnfragmentedPositionProperty(),
              kidFrame->GetLogicalPosition(containerWM, cbBorderBoxSize));

          const LogicalSize kidSize =
              kidFrame->StylePosition()->mBoxSizing == StyleBoxSizing::BorderBox
                  ? kidFrame->GetLogicalSize()
                  : kidFrame->ContentSize();
          kidFrame->SetOrUpdateDeletableProperty(UnfragmentedSizeProperty(),
                                                 kidSize);

          // kidFrame must be a first-in-flow here. In a measuring reflow
          // starting in the first column, we only see first-in-flows (either
          // unsplit or pulled back from later continuations of this absolute
          // containing block). However, in an incremental measuring reflow, if
          // the first-in-flow is not fully-complete, it is possible that we
          // still reflow continuations here.
          NS_ASSERTION(
              !kidFrame->GetPrevInFlow(),
              "UnfragmentedPositionProperty and UnfragmentedSizeProperty "
              "should only be set on first-in-flow!");
        }
        MOZ_ASSERT(!kidStatus.IsInlineBreakBefore(),
                   "ShouldAvoidBreakInside should prevent this from happening");
      }

      nsIFrame* nextFrame = kidFrame->GetNextInFlow();
      if (kidFrameNeedsPush) {
        StealFrame(kidFrame);
        kidFrame->AddStateBits(NS_FRAME_IS_PUSHED_OUT_OF_FLOW);
        newPushedAbsoluteFrames.AppendFrame(nullptr, kidFrame);
      } else if (!kidStatus.IsFullyComplete()) {
        if (!nextFrame) {
          nextFrame = aPresContext->PresShell()
                          ->FrameConstructor()
                          ->CreateContinuingFrame(kidFrame, aDelegatingFrame);
          nextFrame->AddStateBits(NS_FRAME_IS_PUSHED_OUT_OF_FLOW);
          newPushedAbsoluteFrames.AppendFrame(nullptr, nextFrame);
        } else if (nextFrame->GetParent() !=
                   aDelegatingFrame->GetNextInFlow()) {
          nextFrame->GetParent()->GetAbsoluteContainingBlock()->StealFrame(
              nextFrame);
          // nextFrame is in a later absCB continuation. To keep the
          // continuations in order, append it to mPushedAbsoluteFrames.
          mPushedAbsoluteFrames.AppendFrame(aDelegatingFrame, nextFrame);
        }
        reflowStatus.MergeCompletionStatusFrom(kidStatus);
      } else if (nextFrame) {
        // kidFrame is fully-complete. Delete all its next-in-flows.
        FrameDestroyContext context(aPresContext->PresShell());
        nextFrame->GetParent()->GetAbsoluteContainingBlock()->RemoveFrame(
            context, FrameChildListID::Absolute, nextFrame);
      }
    } else {
      if (aOverflowAreas) {
        aDelegatingFrame->ConsiderChildOverflow(*aOverflowAreas, kidFrame);
      }
    }

    // Make a CheckForInterrupt call, here, not just HasPendingInterrupt.  That
    // will make sure that we end up reflowing aDelegatingFrame in cases when
    // one of our kids interrupted.  Otherwise we'd set the dirty or
    // dirty-children bit on the kid in the condition below, and then when
    // reflow completes and we go to mark dirty bits on all ancestors of that
    // kid we'll immediately bail out, because the kid already has a dirty bit.
    // In particular, we won't set any dirty bits on aDelegatingFrame, so when
    // the following reflow happens we won't reflow the kid in question.  This
    // might be slightly suboptimal in cases where |kidFrame| itself did not
    // interrupt, since we'll trigger a reflow of it too when it's not strictly
    // needed.  But the logic to not do that is enough more complicated, and
    // the case enough of an edge case, that this is probably better.
    if (kidNeedsReflow && aPresContext->CheckForInterrupt(aDelegatingFrame)) {
      if (aDelegatingFrame->HasAnyStateBits(NS_FRAME_IS_DIRTY)) {
        kidFrame->MarkSubtreeDirty();
      } else {
        kidFrame->AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN);
      }
    }
  }

  if (newPushedAbsoluteFrames.NotEmpty()) {
    // Prepend the new pushed frames to the front of mPushedAbsoluteFrames.
    mPushedAbsoluteFrames.InsertFrames(nullptr, nullptr,
                                       std::move(newPushedAbsoluteFrames));
  }

  if (availBSize != NS_UNCONSTRAINEDSIZE) {
    mCumulativeContainingBlockBSize += availBSize;
  }

  // Abspos frames can't cause their parent to be incomplete,
  // only overflow incomplete.
  if (reflowStatus.IsIncomplete() || mPushedAbsoluteFrames.NotEmpty()) {
    reflowStatus.SetOverflowIncomplete();
    reflowStatus.SetNextInFlowNeedsReflow();
  }

  aReflowStatus.MergeCompletionStatusFrom(reflowStatus);
}

static inline bool IsFixedPaddingSize(const LengthPercentage& aCoord) {
  return aCoord.ConvertsToLength();
}
static inline bool IsFixedMarginSize(const AnchorResolvedMargin& aCoord) {
  return aCoord->ConvertsToLength();
}
static inline bool IsFixedOffset(const AnchorResolvedInset& 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();
}

bool AbsoluteContainingBlock::FrameDependsOnContainer(
    nsIFrame* f, bool aCBWidthChanged, bool aCBHeightChanged,
    AnchorPosResolutionCache* aAnchorPosResolutionCache) {
  const nsStylePosition* pos = f->StylePosition();
  // See if f's position might have changed because it depends on a
  // placeholder's position.
  if (pos->NeedsHypotheticalPositionIfAbsPos()) {
    return true;
  }
  if (!aCBWidthChanged && !aCBHeightChanged) {
    // skip getting style data
    return false;
  }
  const nsStylePadding* padding = f->StylePadding();
  const nsStyleMargin* margin = f->StyleMargin();
  WritingMode wm = f->GetWritingMode();
  const auto anchorResolutionParams =
      AnchorPosResolutionParams::From(f, aAnchorPosResolutionCache);
  if (wm.IsVertical() ? aCBHeightChanged : aCBWidthChanged) {
    // See if f's inline-size might have changed.
    // If margin-inline-start/end, padding-inline-start/end,
    // inline-size, min/max-inline-size are all lengths, 'none', or enumerated,
    // then our frame isize does not depend on the parent isize.
    // Note that borders never depend on the parent isize.
    // XXX All of the enumerated values except -moz-available are ok too.
    if (nsStylePosition::ISizeDependsOnContainer(
            pos->ISize(wm, anchorResolutionParams)) ||
        nsStylePosition::MinISizeDependsOnContainer(
            pos->MinISize(wm, anchorResolutionParams)) ||
        nsStylePosition::MaxISizeDependsOnContainer(
            pos->MaxISize(wm, anchorResolutionParams)) ||
        !IsFixedPaddingSize(padding->mPadding.GetIStart(wm)) ||
        !IsFixedPaddingSize(padding->mPadding.GetIEnd(wm))) {
      return true;
    }

    // See if f's position might have changed. If we're RTL then the
    // rules are slightly different. We'll assume percentage or auto
    // margins will always induce a dependency on the size
    if (!IsFixedMarginSize(margin->GetMargin(LogicalSide::IStart, wm,
                                             anchorResolutionParams)) ||
        !IsFixedMarginSize(
            margin->GetMargin(LogicalSide::IEnd, wm, anchorResolutionParams))) {
      return true;
    }
  }
  if (wm.IsVertical() ? aCBWidthChanged : aCBHeightChanged) {
    // See if f's block-size might have changed.
    // If margin-block-start/end, padding-block-start/end,
    // min-block-size, and max-block-size are all lengths or 'none',
    // and bsize is a length or bsize and bend are auto and bstart is not auto,
    // then our frame bsize does not depend on the parent bsize.
    // Note that borders never depend on the parent bsize.
    //
    // FIXME(emilio): Should the BSize(wm).IsAuto() check also for the extremum
    // lengths?
    const auto bSize = pos->BSize(wm, anchorResolutionParams);
    const auto anchorOffsetResolutionParams =
        AnchorPosOffsetResolutionParams::UseCBFrameSize(anchorResolutionParams);
    if ((nsStylePosition::BSizeDependsOnContainer(bSize) &&
         !(bSize->IsAuto() &&
           pos->GetAnchorResolvedInset(LogicalSide::BEnd, wm,
                                       anchorOffsetResolutionParams)
               ->IsAuto() &&
           !pos->GetAnchorResolvedInset(LogicalSide::BStart, wm,
                                        anchorOffsetResolutionParams)
                ->IsAuto())) ||
        nsStylePosition::MinBSizeDependsOnContainer(
            pos->MinBSize(wm, anchorResolutionParams)) ||
        nsStylePosition::MaxBSizeDependsOnContainer(
            pos->MaxBSize(wm, anchorResolutionParams)) ||
        !IsFixedPaddingSize(padding->mPadding.GetBStart(wm)) ||
        !IsFixedPaddingSize(padding->mPadding.GetBEnd(wm))) {
      return true;
    }

    // See if f's position might have changed.
    if (!IsFixedMarginSize(margin->GetMargin(LogicalSide::BStart, wm,
                                             anchorResolutionParams)) ||
        !IsFixedMarginSize(
            margin->GetMargin(LogicalSide::BEnd, wm, anchorResolutionParams))) {
      return true;
    }
  }

  // Since we store coordinates relative to top and left, the position
  // of a frame depends on that of its container if it is fixed relative
  // to the right or bottom, or if it is positioned using percentages
  // relative to the left or top.  Because of the dependency on the
  // sides (left and top) that we use to store coordinates, these tests
  // are easier to do using physical coordinates rather than logical.
  if (aCBWidthChanged) {
    const auto anchorOffsetResolutionParams =
        AnchorPosOffsetResolutionParams::UseCBFrameSize(anchorResolutionParams);
    if (!IsFixedOffset(pos->GetAnchorResolvedInset(
            eSideLeft, anchorOffsetResolutionParams))) {
      return true;
    }
    // Note that even if 'left' is a length, our position can still
    // depend on the containing block width, because if our direction or
    // writing-mode moves from right to left (in either block or inline
    // progression) and 'right' is not 'auto', we will discard 'left'
    // and be positioned relative to the containing block right edge.
    // 'left' length and 'right' auto is the only combination we can be
    // sure of.
    if ((wm.GetInlineDir() == WritingMode::InlineDir::RTL ||
         wm.GetBlockDir() == WritingMode::BlockDir::RL) &&
        !pos->GetAnchorResolvedInset(eSideRight, anchorOffsetResolutionParams)
             ->IsAuto()) {
      return true;
    }
  }
  if (aCBHeightChanged) {
    const auto anchorOffsetResolutionParams =
        AnchorPosOffsetResolutionParams::UseCBFrameSize(anchorResolutionParams);
    if (!IsFixedOffset(pos->GetAnchorResolvedInset(
            eSideTop, anchorOffsetResolutionParams))) {
      return true;
    }
    // See comment above for width changes.
    if (wm.GetInlineDir() == WritingMode::InlineDir::BTT &&
        !pos->GetAnchorResolvedInset(eSideBottom, anchorOffsetResolutionParams)
             ->IsAuto()) {
      return true;
    }
  }

  return false;
}

void AbsoluteContainingBlock::DestroyFrames(DestroyContext& aContext) {
  mAbsoluteFrames.DestroyFrames(aContext);
  mPushedAbsoluteFrames.DestroyFrames(aContext);
}

void AbsoluteContainingBlock::MarkSizeDependentFramesDirty() {
  DoMarkFramesDirty(false);
}

void AbsoluteContainingBlock::MarkAllFramesDirty() { DoMarkFramesDirty(true); }

void AbsoluteContainingBlock::DoMarkFramesDirty(bool aMarkAllDirty) {
  for (nsIFrame* kidFrame : mAbsoluteFrames) {
    if (aMarkAllDirty) {
      kidFrame->MarkSubtreeDirty();
    } else if (FrameDependsOnContainer(kidFrame, true, true)) {
      // Add the weakest flags that will make sure we reflow this frame later
      kidFrame->AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN);
    }
  }
}

// Given an out-of-flow frame, this method returns the parent frame of its
// placeholder frame or null if it doesn't have a placeholder for some reason.
static nsContainerFrame* GetPlaceholderContainer(nsIFrame* aPositionedFrame) {
  nsIFrame* placeholder = aPositionedFrame->GetPlaceholderFrame();
  return placeholder ? placeholder->GetParent() : nullptr;
}

struct NonAutoAlignParams {
  nscoord mCurrentStartInset;
  nscoord mCurrentEndInset;

  NonAutoAlignParams(nscoord aStartInset, nscoord aEndInset)
      : mCurrentStartInset(aStartInset), mCurrentEndInset(aEndInset) {}
};

/**
 * This function returns the offset of an abs/fixed-pos child's static
 * position, with respect to the "start" corner of its alignment container,
 * according to CSS Box Alignment.  This function only operates in a single
 * axis at a time -- callers can choose which axis via the |aAbsPosCBAxis|
 * parameter. This is called under two scenarios:
 * 1. We're statically positioning this absolutely positioned box, meaning
 *    that the offsets are auto and will change depending on the alignment
 *    of the box.
 * 2. The offsets are non-auto, but the element may not fill the inset-reduced
 *    containing block, so its margin box needs to be aligned in that axis.
 *    This is the step 4 of [1]. Should also be noted that, unlike static
 *    positioning, where we may confine the alignment area for flex/grid
 *    parent containers, we explicitly align to the inset-reduced absolute
 *    container size.
 *
 * [1]: https://drafts.csswg.org/css-position-3/#abspos-layout
 *
 * @param aKidReflowInput The ReflowInput for the to-be-aligned abspos child.
 * @param aKidSizeInAbsPosCBWM The child frame's size (after it's been given
 *                             the opportunity to reflow), in terms of
 *                             aAbsPosCBWM.
 * @param aAbsPosCBSize The abspos CB size, in terms of aAbsPosCBWM.
 * @param aPlaceholderContainer The parent of the child frame's corresponding
 *                              placeholder frame, cast to a nsContainerFrame.
 *                              (This will help us choose which alignment enum
 *                              we should use for the child.)
 * @param aAbsPosCBWM The child frame's containing block's WritingMode.
 * @param aAbsPosCBAxis The axis (of the containing block) that we should
 *                      be doing this computation for.
 * @param aNonAutoAlignParams Parameters, if specified, indicating that we're
 *                            handling scenario 2.
 */
static nscoord OffsetToAlignedStaticPos(
    const ReflowInput& aKidReflowInput, const LogicalSize& aKidSizeInAbsPosCBWM,
    const LogicalSize& aAbsPosCBSize,
    const nsContainerFrame* aPlaceholderContainer, WritingMode aAbsPosCBWM,
    LogicalAxis aAbsPosCBAxis, Maybe<NonAutoAlignParams> aNonAutoAlignParams,
    const AbsoluteContainingBlock::AnchorOffsetInfo& aAnchorOffsetInfo) {
  if (!aPlaceholderContainer) {
    // (The placeholder container should be the thing that kicks this whole
    // process off, by setting PLACEHOLDER_STATICPOS_NEEDS_CSSALIGN.  So it
    // should exist... but bail gracefully if it doesn't.)
    NS_ERROR(
        "Missing placeholder-container when computing a "
        "CSS Box Alignment static position");
    return 0;
  }

  // (Most of this function is simply preparing args that we'll pass to
  // AlignJustifySelf at the end.)

  // NOTE: Our alignment container is aPlaceholderContainer's content-box
  // (or an area within it, if aPlaceholderContainer is a grid). So, we'll
  // perform most of our arithmetic/alignment in aPlaceholderContainer's
  // 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.
  const LogicalAxis pcAxis = aAbsPosCBWM.ConvertAxisTo(aAbsPosCBAxis, pcWM);
  const LogicalSize alignAreaSize = [&]() {
    if (!aNonAutoAlignParams) {
      const bool placeholderContainerIsContainingBlock =
          aPlaceholderContainer == aKidReflowInput.mCBReflowInput->mFrame;

      LayoutFrameType parentType = aPlaceholderContainer->Type();
      LogicalSize alignAreaSize(pcWM);
      if (parentType == LayoutFrameType::FlexContainer) {
        // We store the frame rect in FinishAndStoreOverflow, which runs _after_
        // reflowing the absolute frames, so handle the special case of the
        // frame being the actual containing block here, by getting the size
        // from aAbsPosCBSize.
        //
        // The alignment container is the flex container's content box.
        if (placeholderContainerIsContainingBlock) {
          alignAreaSize = aAbsPosCBSize.ConvertTo(pcWM, aAbsPosCBWM);
          // aAbsPosCBSize is the padding-box, so substract the padding to get
          // the content box.
          alignAreaSize -=
              aPlaceholderContainer->GetLogicalUsedPadding(pcWM).Size(pcWM);
        } else {
          alignAreaSize = aPlaceholderContainer->GetLogicalSize(pcWM);
          LogicalMargin pcBorderPadding =
              aPlaceholderContainer->GetLogicalUsedBorderAndPadding(pcWM);
          alignAreaSize -= pcBorderPadding.Size(pcWM);
        }
        return alignAreaSize;
      }
      if (parentType == LayoutFrameType::GridContainer) {
        // This abspos elem's parent is a grid container. Per CSS Grid 10.1
        // & 10.2:
        //  - If the grid container *also* generates the abspos containing block
        //  (a
        // grid area) for this abspos child, we use that abspos containing block
        // as the alignment container, too. (And its size is aAbsPosCBSize.)
        //  - Otherwise, we use the grid's padding box as the alignment
        //  container.
        // https://drafts.csswg.org/css-grid/#static-position
        if (placeholderContainerIsContainingBlock) {
          // The alignment container is the grid area that we're using as the
          // absolute containing block.
          alignAreaSize = aAbsPosCBSize.ConvertTo(pcWM, aAbsPosCBWM);
        } else {
          // The alignment container is a the grid container's content box
          // (which we can get by subtracting away its border & padding from
          // frame's size):
          alignAreaSize = aPlaceholderContainer->GetLogicalSize(pcWM);
          LogicalMargin pcBorderPadding =
              aPlaceholderContainer->GetLogicalUsedBorderAndPadding(pcWM);
          alignAreaSize -= pcBorderPadding.Size(pcWM);
        }
        return alignAreaSize;
      }
    }
    // Either we're in scenario 1 but within a non-flex/grid parent, or in
    // scenario 2.
    return aAbsPosCBSize.ConvertTo(pcWM, aAbsPosCBWM);
  }();

  const nscoord existingOffset = aNonAutoAlignParams
                                     ? aNonAutoAlignParams->mCurrentStartInset +
                                           aNonAutoAlignParams->mCurrentEndInset
                                     : 0;
  const nscoord alignAreaSizeInAxis =
      ((pcAxis == LogicalAxis::Inline) ? alignAreaSize.ISize(pcWM)
                                       : alignAreaSize.BSize(pcWM)) -
      existingOffset;

  using AlignJustifyFlag = CSSAlignUtils::AlignJustifyFlag;
  CSSAlignUtils::AlignJustifyFlags flags(AlignJustifyFlag::IgnoreAutoMargins);
  // Given that scenario 2 ignores the parent container type, special handling
  // of absolutely-positioned child is also ignored.
  StyleAlignFlags alignConst =
      aNonAutoAlignParams
          ? aPlaceholderContainer
                ->CSSAlignmentForAbsPosChildWithinContainingBlock(
                    aKidReflowInput, pcAxis,
                    aAnchorOffsetInfo.mResolvedPositionArea, absPosCBSizeInPCWM)
          : aPlaceholderContainer->CSSAlignmentForAbsPosChild(aKidReflowInput,
                                                              pcAxis);
  // If the safe bit in alignConst is set, set the safe flag in |flags|.
  const auto safetyBits =
      alignConst & (StyleAlignFlags::SAFE | StyleAlignFlags::UNSAFE);
  alignConst &= ~StyleAlignFlags::FLAG_BITS;
  if (safetyBits & StyleAlignFlags::SAFE) {
    flags += AlignJustifyFlag::OverflowSafe;
  }

  // Find out if placeholder-container & the OOF child have the same start-sides
  // in the placeholder-container's pcAxis.
  WritingMode kidWM = aKidReflowInput.GetWritingMode();
  if (pcWM.ParallelAxisStartsOnSameSide(pcAxis, kidWM)) {
    flags += AlignJustifyFlag::SameSide;
  }

  if (aNonAutoAlignParams) {
    flags += AlignJustifyFlag::AligningMarginBox;
  }

  // (baselineAdjust is unused. CSSAlignmentForAbsPosChild() should've
  // converted 'baseline'/'last baseline' enums to their fallback values.)
  const nscoord baselineAdjust = nscoord(0);

  // AlignJustifySelf operates in the kid's writing mode, so we need to
  // represent the child's size and the desired axis in that writing mode:
  LogicalSize kidSizeInOwnWM =
      aKidSizeInAbsPosCBWM.ConvertTo(kidWM, aAbsPosCBWM);
  const LogicalAxis kidAxis = aAbsPosCBWM.ConvertAxisTo(aAbsPosCBAxis, kidWM);

  // Build an Inset Modified anchor info from the anchor which can be used to
  // align to the anchor-center, if AlignJustifySelf is AnchorCenter.
  Maybe<CSSAlignUtils::AnchorAlignInfo> anchorAlignInfo;
  if (alignConst == StyleAlignFlags::ANCHOR_CENTER &&
      aKidReflowInput.mAnchorPosResolutionCache) {
    AnchorPosReferenceData* referenceData =
        aKidReflowInput.mAnchorPosResolutionCache->mReferenceData;
    if (referenceData) {
      const auto* cachedData = referenceData->Lookup(
          {referenceData->mDefaultAnchorName, referenceData->mAnchorTreeScope});
      if (cachedData && *cachedData) {
        referenceData->AdjustCompensatingForScroll(
            aAbsPosCBWM.PhysicalAxis(aAbsPosCBAxis));
        const auto& data = cachedData->ref();
        if (data.mOffsetData) {
          const nsSize containerSize =
              aAbsPosCBSize.GetPhysicalSize(aAbsPosCBWM);
          // Adjust for position-area, grid, etc.
          const auto cbOffset =
              referenceData->mAdjustedContainingBlock.TopLeft() -
              referenceData->mOriginalContainingBlockRect.TopLeft();
          const nsRect anchorRect(data.mOffsetData->mOrigin - cbOffset,
                                  data.mSize);
          const LogicalRect logicalAnchorRect{aAbsPosCBWM, anchorRect,
                                              containerSize};
          const auto axisInAbsPosCBWM =
              kidWM.ConvertAxisTo(kidAxis, aAbsPosCBWM);
          const auto anchorStart =
              logicalAnchorRect.Start(axisInAbsPosCBWM, aAbsPosCBWM);
          const auto anchorSize =
              logicalAnchorRect.Size(axisInAbsPosCBWM, aAbsPosCBWM);
          anchorAlignInfo =
              Some(CSSAlignUtils::AnchorAlignInfo{anchorStart, anchorSize});
          if (aNonAutoAlignParams) {
            anchorAlignInfo->mAnchorStart -=
                aNonAutoAlignParams->mCurrentStartInset;
          }
        }
      }
    }
  }

  nscoord offset = CSSAlignUtils::AlignJustifySelf(
      alignConst, kidAxis, flags, baselineAdjust, alignAreaSizeInAxis,
      aKidReflowInput, kidSizeInOwnWM, anchorAlignInfo);

  // Safe alignment clamping for anchor-center.
  // When using anchor-center with the safe keyword, or when both insets are
  // auto (which defaults to safe behavior), clamp the element to stay within
  // the containing block.
  if ((!aNonAutoAlignParams || (safetyBits & StyleAlignFlags::SAFE)) &&
      alignConst == StyleAlignFlags::ANCHOR_CENTER) {
    const auto cbSize = aAbsPosCBSize.Size(aAbsPosCBAxis, aAbsPosCBWM);
    const auto kidSize = aKidSizeInAbsPosCBWM.Size(aAbsPosCBAxis, aAbsPosCBWM);

    if (aNonAutoAlignParams) {
      const nscoord currentStartInset = aNonAutoAlignParams->mCurrentStartInset;
      const nscoord finalStart = currentStartInset + offset;
      const nscoord clampedStart =
          CSSMinMax(finalStart, nscoord(0), cbSize - kidSize);
      offset = clampedStart - currentStartInset;
    } else {
      offset = CSSMinMax(offset, nscoord(0), cbSize - kidSize);
    }
  }

  const auto rawAlignConst =
      (pcAxis == LogicalAxis::Inline)
          ? aKidReflowInput.mStylePosition->mJustifySelf._0
          : aKidReflowInput.mStylePosition->mAlignSelf._0;
  if (aNonAutoAlignParams && !safetyBits &&
      (rawAlignConst != StyleAlignFlags::AUTO ||
       alignConst == StyleAlignFlags::ANCHOR_CENTER)) {
    // No `safe` or `unsafe` specified - "in-between" behaviour for relevant
    // alignment values: https://drafts.csswg.org/css-position-3/#abspos-layout
    // Skip if the raw self alignment for this element is `auto` to preserve
    // legacy behaviour, except in the case where the resolved value is
    // anchor-center (where "legacy behavior" is not a concern).
    // Follows https://drafts.csswg.org/css-align-3/#auto-safety-position
    const auto cbSize = aAbsPosCBSize.Size(aAbsPosCBAxis, aAbsPosCBWM);
    // IMCB stands for "Inset-Modified Containing Block."
    const auto imcbStart = aNonAutoAlignParams->mCurrentStartInset;
    const auto imcbEnd = cbSize - aNonAutoAlignParams->mCurrentEndInset;
    // Need to pull the offset into the "current view," unless it already did.
    const auto scrollOffset = aAnchorOffsetInfo.mResolvedPositionArea.IsNone()
                                  ? aAbsPosCBWM.PhysicalAxis(aAbsPosCBAxis) ==
                                            PhysicalAxis::Horizontal
                                        ? aAnchorOffsetInfo.mScrollOffset.x
                                        : aAnchorOffsetInfo.mScrollOffset.y
                                  : 0;
    const auto kidSize = aKidSizeInAbsPosCBWM.Size(aAbsPosCBAxis, aAbsPosCBWM);
    const auto kidStart =
        aNonAutoAlignParams->mCurrentStartInset + offset - scrollOffset;
    const auto kidEnd = kidStart + kidSize;
    // "[...] the overflow limit rect is the bounding rectangle of the alignment
    // subject’s inset-modified containing block and its original containing
    // block."
    const auto overflowLimitRectStart = std::min(0, imcbStart);
    const auto overflowLimitRectEnd = std::max(cbSize, imcbEnd);

    if (kidStart >= imcbStart && kidEnd <= imcbEnd) {
      // 1. We fit inside the IMCB, no action needed.
    } else if (kidSize <= overflowLimitRectEnd - overflowLimitRectStart) {
      // 2. We overflowed IMCB, try to cover IMCB completely, if it's not.
      if (kidStart <= imcbStart && kidEnd >= imcbEnd) {
        // IMCB already covered, ensure that we aren't escaping the limit rect.
        if (kidStart < overflowLimitRectStart) {
          offset += overflowLimitRectStart - kidStart;
        } else if (kidEnd > overflowLimitRectEnd) {
          offset -= kidEnd - overflowLimitRectEnd;
        }
      } else if (kidEnd < imcbEnd && kidStart < imcbStart) {
        // Space to end, overflowing on start - nudge to end.
        offset += std::min(imcbStart - kidStart, imcbEnd - kidEnd);
      } else if (kidStart > imcbStart && kidEnd > imcbEnd) {
        // Space to start, overflowing on end - nudge to start.
        offset -= std::min(kidEnd - imcbEnd, kidStart - imcbStart);
      }
    } else {
      // 3. We'll overflow the limit rect. Start align the subject int overflow
      // limit rect.
      offset =
          -aNonAutoAlignParams->mCurrentStartInset + overflowLimitRectStart;
    }
  }

  // "offset" is in terms of the CSS Box Alignment container (i.e. it's in
  // terms of pcWM). But our return value needs to in terms of the containing
  // block's writing mode, which might have the opposite directionality in the
  // given axis. In that case, we just need to negate "offset" when returning,
  // to make it have the right effect as an offset for coordinates in the
  // containing block's writing mode.
  if (!pcWM.ParallelAxisStartsOnSameSide(pcAxis, aAbsPosCBWM)) {
    return -offset;
  }
  return offset;
}

void AbsoluteContainingBlock::ResolveSizeDependentOffsets(
    ReflowInput& aKidReflowInput, const LogicalSize& aCBSize,
    const LogicalSize& aKidSize, const LogicalMargin& aMargin,
    const AnchorOffsetInfo& aAnchorOffsetInfo, LogicalMargin& aOffsets) {
  WritingMode outerWM = aKidReflowInput.mParentReflowInput->GetWritingMode();

  // Now that we know the child's size, we resolve any sentinel values in its
  // IStart/BStart offset coordinates that depend on that size.
  //  * NS_AUTOOFFSET indicates that the child's position in the given axis
  // is determined by its end-wards offset property, combined with its size and
  // available space. e.g.: "top: auto; height: auto; bottom: 50px"
  //  * m{I,B}OffsetsResolvedAfterSize indicate that the child is using its
  // static position in that axis, *and* its static position is determined by
  // the axis-appropriate css-align property (which may require the child's
  // size, e.g. to center it within the parent).
  if ((NS_AUTOOFFSET == aOffsets.IStart(outerWM)) ||
      (NS_AUTOOFFSET == aOffsets.BStart(outerWM)) ||
      aKidReflowInput.mFlags.mIOffsetsNeedCSSAlign ||
      aKidReflowInput.mFlags.mBOffsetsNeedCSSAlign) {
    // placeholderContainer is used in each of the m{I,B}OffsetsNeedCSSAlign
    // clauses. We declare it at this scope so we can avoid having to look
    // it up twice (and only look it up if it's needed).
    nsContainerFrame* placeholderContainer = nullptr;

    if (NS_AUTOOFFSET == aOffsets.IStart(outerWM)) {
      NS_ASSERTION(NS_AUTOOFFSET != aOffsets.IEnd(outerWM),
                   "Can't solve for both start and end");
      aOffsets.IStart(outerWM) =
          aCBSize.ISize(outerWM) - aOffsets.IEnd(outerWM) -
          aMargin.IStartEnd(outerWM) - aKidSize.ISize(outerWM);
    } else if (aKidReflowInput.mFlags.mIOffsetsNeedCSSAlign) {
      placeholderContainer = GetPlaceholderContainer(aKidReflowInput.mFrame);
      nscoord offset = OffsetToAlignedStaticPos(
          aKidReflowInput, aKidSize, aCBSize, placeholderContainer, outerWM,
          LogicalAxis::Inline, Nothing{}, aAnchorOffsetInfo);
      // 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.
      aOffsets.IStart(outerWM) += offset;
      aOffsets.IEnd(outerWM) =
          aCBSize.ISize(outerWM) -
          (aOffsets.IStart(outerWM) + aKidSize.ISize(outerWM));
    }

    if (NS_AUTOOFFSET == aOffsets.BStart(outerWM)) {
      aOffsets.BStart(outerWM) =
          aCBSize.BSize(outerWM) - aOffsets.BEnd(outerWM) -
          aMargin.BStartEnd(outerWM) - aKidSize.BSize(outerWM);
    } else if (aKidReflowInput.mFlags.mBOffsetsNeedCSSAlign) {
      if (!placeholderContainer) {
        placeholderContainer = GetPlaceholderContainer(aKidReflowInput.mFrame);
      }
      nscoord offset = OffsetToAlignedStaticPos(
          aKidReflowInput, aKidSize, aCBSize, placeholderContainer, outerWM,
          LogicalAxis::Block, Nothing{}, aAnchorOffsetInfo);
      // 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.
      aOffsets.BStart(outerWM) += offset;
      aOffsets.BEnd(outerWM) =
          aCBSize.BSize(outerWM) -
          (aOffsets.BStart(outerWM) + aKidSize.BSize(outerWM));
    }
    aKidReflowInput.SetComputedLogicalOffsets(outerWM, aOffsets);
  }
}

void AbsoluteContainingBlock::ResolveAutoMarginsAfterLayout(
    ReflowInput& aKidReflowInput, const LogicalSize& aCBSize,
    const LogicalSize& aKidSize, LogicalMargin& aMargin,
    const LogicalMargin& aOffsets) {
  WritingMode outerWM = aKidReflowInput.mParentReflowInput->GetWritingMode();
  const auto& styleMargin = aKidReflowInput.mStyleMargin;
  const auto anchorResolutionParams =
      AnchorPosResolutionParams::From(&aKidReflowInput);

  auto ResolveMarginsInAxis = [&](LogicalAxis aAxis) {
    const auto startSide = MakeLogicalSide(aAxis, LogicalEdge::Start);
    const auto endSide = MakeLogicalSide(aAxis, LogicalEdge::End);

    // No need to substract border sizes because aKidSize has it included
    // already. Also, if any offset is auto, the auto margin resolves to zero.
    // https://drafts.csswg.org/css-position-3/#abspos-margins
    const bool autoOffset =
        aOffsets.Side(startSide, outerWM) == NS_AUTOOFFSET ||
        aOffsets.Side(endSide, outerWM) == NS_AUTOOFFSET;

    nscoord availMarginSpace;
    if (autoOffset) {
      availMarginSpace = 0;
    } else {
      const nscoord stretchFitSize = std::max(
          0, aCBSize.Size(aAxis, outerWM) - aOffsets.StartEnd(aAxis, outerWM) -
                 aMargin.StartEnd(aAxis, outerWM));
      availMarginSpace = stretchFitSize - aKidSize.Size(aAxis, outerWM);
    }

    const bool startSideMarginIsAuto =
        styleMargin->GetMargin(startSide, outerWM, anchorResolutionParams)
            ->IsAuto();
    const bool endSideMarginIsAuto =
        styleMargin->GetMargin(endSide, outerWM, anchorResolutionParams)
            ->IsAuto();

    if (aAxis == LogicalAxis::Inline) {
      ReflowInput::ComputeAbsPosInlineAutoMargin(availMarginSpace, outerWM,
                                                 startSideMarginIsAuto,
                                                 endSideMarginIsAuto, aMargin);
    } else {
      ReflowInput::ComputeAbsPosBlockAutoMargin(availMarginSpace, outerWM,
                                                startSideMarginIsAuto,
                                                endSideMarginIsAuto, aMargin);
    }
  };

  ResolveMarginsInAxis(LogicalAxis::Inline);
  ResolveMarginsInAxis(LogicalAxis::Block);
  aKidReflowInput.SetComputedLogicalMargin(outerWM, aMargin);

  nsMargin* propValue =
      aKidReflowInput.mFrame->GetProperty(nsIFrame::UsedMarginProperty());
  // InitOffsets should've created a UsedMarginProperty for us, if any margin is
  // auto.
  MOZ_ASSERT_IF(
      styleMargin->HasInlineAxisAuto(outerWM, anchorResolutionParams) ||
          styleMargin->HasBlockAxisAuto(outerWM, anchorResolutionParams),
      propValue);
  if (propValue) {
    *propValue = aMargin.GetPhysicalMargin(outerWM);
  }
}

struct None {};
using OldCacheState = Variant<None, AnchorPosResolutionCache::PositionTryBackup,
                              AnchorPosResolutionCache::PositionTryFullBackup>;

struct MOZ_STACK_CLASS MOZ_RAII AutoFallbackStyleSetter {
  AutoFallbackStyleSetter(nsIFrame* aFrame, ComputedStyle* aFallbackStyle,
                          AnchorPosResolutionCache* aCache, bool aIsFirstTry)
      : mFrame(aFrame), mCache{aCache}, mOldCacheState{None{}} {
    if (aFallbackStyle) {
      mOldStyle = aFrame->SetComputedStyleWithoutNotification(aFallbackStyle);
    }
    // We need to be able to "go back" to the old, first try (Which is not
    // necessarily base style) cache.
    if (!aIsFirstTry && aCache) {
      // New fallback could just be a flip keyword.
      if (mOldStyle && mOldStyle->StylePosition()->mPositionAnchor !=
                           aFrame->StylePosition()->mPositionAnchor) {
        mOldCacheState =
            OldCacheState{aCache->TryPositionWithDifferentDefaultAnchor()};
        // TODO(dshin, bug 2014913): Fragmentation _can_ change the containing
        // block size from its unfragmented version, and that may cause us to
        // choose a different fallback, and hit this code path.
        *aCache = PopulateAnchorResolutionCache(aFrame, aCache->mReferenceData,
                                                false);
      } else {
        mOldCacheState =
            OldCacheState{aCache->TryPositionWithSameDefaultAnchor()};
        if (aCache->mDefaultAnchorCache.mAnchor) {
          aCache->mReferenceData->AdjustCompensatingForScroll(
              CheckEarlyCompensatingForScroll(aFrame));
        }
      }
    }
  }

  ~AutoFallbackStyleSetter() {
    if (mOldStyle) {
      mFrame->SetComputedStyleWithoutNotification(std::move(mOldStyle));
    }
    std::move(mOldCacheState)
        .match(
            [](None&&) {},
            [&](AnchorPosResolutionCache::PositionTryBackup&& aBackup) {
              mCache->UndoTryPositionWithSameDefaultAnchor(std::move(aBackup));
            },
            [&](AnchorPosResolutionCache::PositionTryFullBackup&& aBackup) {
              mCache->UndoTryPositionWithDifferentDefaultAnchor(
                  std::move(aBackup));
            });
  }

  void CommitCurrentFallback() {
    mOldCacheState = OldCacheState{None{}};
    // If we have a non-layout dependent margin / paddings, which are different
    // from our original style, we need to make sure to commit it into the frame
    // property so that it doesn't get lost after returning from reflow.
    nsMargin margin;
    if (mOldStyle &&
        !mOldStyle->StyleMargin()->MarginEquals(*mFrame->StyleMargin()) &&
        mFrame->StyleMargin()->GetMargin(margin)) {
      mFrame->SetOrUpdateDeletableProperty(nsIFrame::UsedMarginProperty(),
                                           margin);
    }
  }

 private:
  nsIFrame* const mFrame;
  RefPtr<ComputedStyle> mOldStyle;
  AnchorPosResolutionCache* const mCache;
  OldCacheState mOldCacheState;
};

// XXX Optimize the case where it's a resize reflow and the absolutely
// positioned child has the exact same size and position and skip the
// reflow...
void AbsoluteContainingBlock::ReflowAbsoluteFrame(
    nsContainerFrame* aDelegatingFrame, nsPresContext* aPresContext,
    const ReflowInput& aReflowInput,
    const ContainingBlockRects& aContainingBlockRects, AbsPosReflowFlags aFlags,
    nsIFrame* aKidFrame, nsReflowStatus& aStatus, OverflowAreas* aOverflowAreas,
    const ContainingBlockRects* aFragmentedContainingBlockRects,
    AnchorPosResolutionCache* aAnchorPosResolutionCache,
    bool aReuseUnfragmentedAnchorPosReferences) {
  MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");

#ifdef DEBUG
  if (nsBlockFrame::gNoisyReflow) {
    nsIFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent);
    fmt::println("abspos {}: begin reflow: availSize={}, orig cbRect={}",
                 aKidFrame->ListTag(), ToString(aReflowInput.AvailableSize()),
                 ToString(aContainingBlockRects.mLocal));
  }
  AutoNoisyIndenter indent(nsBlockFrame::gNoisy);
#endif  // DEBUG

  const WritingMode outerWM = aReflowInput.GetWritingMode();
  const WritingMode wm = aKidFrame->GetWritingMode();

  const bool isGrid = aFlags.contains(AbsPosReflowFlag::IsGridContainerCB);
  const auto* kidStylePosition = aKidFrame->StylePosition();
  auto fallbacks = kidStylePosition->mPositionTryFallbacks.value._0.AsSpan();
  const auto fallbackScope = kidStylePosition->mPositionTryFallbacks.scope;
  Maybe<uint32_t> currentFallbackIndex;
  const StylePositionTryFallbacksItem* currentFallback = nullptr;
  RefPtr<ComputedStyle> currentFallbackStyle;
  RefPtr<ComputedStyle> firstTryStyle;
  Maybe<uint32_t> firstTryIndex;
  // If non-'normal' position-try-order is in effect, we keep track of the
  // index of the "best" option seen, and its size in the relevant axis, so
  // that once all fallbacks have been considered we can reset to the one
  // that provided the most space.
  Maybe<uint32_t> bestIndex;
  nscoord bestSize = -1;
  // Flag to indicate that we've determined which fallback to use and should
  // exit the loop.
  bool finalizing = false;

  auto tryOrder = kidStylePosition->mPositionTryOrder;
  // If position-try-order is a logical value, resolve to physical using
  // the containing block's writing mode.
  switch (tryOrder) {
    case StylePositionTryOrder::MostInlineSize:
      tryOrder = outerWM.IsVertical() ? StylePositionTryOrder::MostHeight
                                      : StylePositionTryOrder::MostWidth;
      break;
    case StylePositionTryOrder::MostBlockSize:
      tryOrder = outerWM.IsVertical() ? StylePositionTryOrder::MostWidth
                                      : StylePositionTryOrder::MostHeight;
      break;
    default:
      break;
  }

  const auto* baseStyle = aKidFrame->Style();
  // Set the current fallback to the given index, or reset to the base position
  // if Nothing() is passed.
  auto SeekFallbackTo = [&](Maybe<uint32_t> aIndex) -> bool {
    if (!aIndex) {
      currentFallbackIndex = Nothing();
      currentFallback = nullptr;
      currentFallbackStyle = nullptr;
      return true;
    }
    uint32_t index = *aIndex;
    if (index >= fallbacks.Length()) {
      return false;
    }

    const StylePositionTryFallbacksItem* nextFallback;
    RefPtr<ComputedStyle> nextFallbackStyle;
    while (true) {
      nextFallback = &fallbacks[index];
      nextFallbackStyle = aPresContext->StyleSet()->ResolvePositionTry(
          fallbackScope, *aKidFrame->GetContent()->AsElement(), *baseStyle,
          *nextFallback);
      if (nextFallbackStyle) {
        break;
      }
      // No @position-try rule for this name was found, per spec we should
      // skip it.
      index++;
      if (index >= fallbacks.Length()) {
        return false;
      }
    }
    currentFallbackIndex = Some(index);
    currentFallback = nextFallback;
    currentFallbackStyle = std::move(nextFallbackStyle);
    return true;
  };

  // Advance to the next fallback to be tried. Normally this is simply the next
  // index in the position-try-fallbacks list, but we have some special cases:
  // - if we're currently at the last-successful fallback (recorded as
  //   firstTryIndex), we "advance" to the base position
  // - we skip the last-successful fallback when we reach its position again
  auto TryAdvanceFallback = [&]() -> bool {
    if (fallbacks.IsEmpty()) {
      return false;
    }
    if (firstTryIndex && currentFallbackIndex == firstTryIndex) {
      return SeekFallbackTo(Nothing());
    }
    uint32_t nextFallbackIndex =
        currentFallbackIndex ? *currentFallbackIndex + 1 : 0;
    if (firstTryIndex && nextFallbackIndex == *firstTryIndex) {
      ++nextFallbackIndex;
    }
    return SeekFallbackTo(Some(nextFallbackIndex));
  };

  Maybe<nsRect> firstTryRect;
  if (auto* lastSuccessfulPosition =
          aKidFrame->GetProperty(nsIFrame::LastSuccessfulPositionFallback());
      lastSuccessfulPosition && lastSuccessfulPosition->mRecordedIndex &&
      SeekFallbackTo(lastSuccessfulPosition->mRecordedIndex)) {
    // Remember which fallback we're trying first; also record its style,
    // in case we need to restore it later.
    firstTryIndex = lastSuccessfulPosition->mRecordedIndex;
    firstTryStyle = currentFallbackStyle;
  }

  // Assume we *are* overflowing the CB and if we find a fallback that doesn't
  // overflow, we set this to false and break the loop.
  bool isOverflowingCB = true;

  do {
    AutoFallbackStyleSetter fallback(aKidFrame, currentFallbackStyle,
                                     aAnchorPosResolutionCache,
                                     firstTryIndex == currentFallbackIndex);
    auto cb = ComputeContainingBlock(isGrid, aDelegatingFrame, aReflowInput,
                                     aContainingBlockRects, aKidFrame,
                                     aAnchorPosResolutionCache,
                                     aReuseUnfragmentedAnchorPosReferences);
    PhysicalAxes earlyScrollCompensation;
    if (aAnchorPosResolutionCache) {
      const auto& originalCb = cb.mMaybeScrollableRect;
      aAnchorPosResolutionCache->mReferenceData->mOriginalContainingBlockRect =
          originalCb;
      // Stash the adjusted containing block as well, since the insets need to
      // resolve against the adjusted CB, e.g. With `position-area: bottom
      // right;`, + `left: anchor(right);`
      // resolves to 0.
      aAnchorPosResolutionCache->mReferenceData->mAdjustedContainingBlock =
          cb.mFinalRect;
      // May need to recompute scroll compensation if e.g. anchor-center in one
      // axis, then `anchor(--default-anchor)` in another.
      earlyScrollCompensation = aAnchorPosResolutionCache->mReferenceData
                                    ->CompensatingForScrollAxes();
    }
    const LogicalSize cbSize(outerWM, cb.mFinalRect.Size());

    ReflowInput::InitFlags initFlags;
    const bool staticPosIsCBOrigin = [&] {
      if (aFlags.contains(AbsPosReflowFlag::IsGridContainerCB)) {
        // When a grid container generates the abs.pos. CB for a *child* then
        // the static position is determined via CSS Box Alignment within the
        // abs.pos. CB (a grid area, i.e. a piece of the grid). In this
        // scenario, due to the multiple coordinate spaces in play, we use a
        // convenience flag to simply have the child's ReflowInput give it a
        // static position at its abs.pos. CB origin, and then we'll align &
        // offset it from there.
        nsIFrame* placeholder = aKidFrame->GetPlaceholderFrame();
        if (placeholder && placeholder->GetParent() == aDelegatingFrame) {
          return true;
        }
      }
      if (aKidFrame->IsMenuPopupFrame()) {
        // Popups never use their static pos.
        return true;
      }
      // TODO(emilio): Either reparent the top layer placeholder frames to the
      // viewport, or return true here for top layer frames more generally (not
      // only menupopups), see https://github.com/w3c/csswg-drafts/issues/8040.
      return false;
    }();

    if (staticPosIsCBOrigin) {
      initFlags += ReflowInput::InitFlag::StaticPosIsCBOrigin;
    }

    const bool kidFrameMaySplit =
        aReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE &&

        // Don't split if told not to (e.g. for fixed frames)
        aFlags.contains(AbsPosReflowFlag::AllowFragmentation) &&

        // TODO(Bug 2038072): Support splitting abspos frames under inline
        // absolute containing blocks.
        !aDelegatingFrame->IsInlineFrame() &&

        // Bug 1588623: Support splitting absolute positioned multicol
        // containers.
        !aKidFrame->IsColumnSetWrapperFrame();

    // Get the border values
    const LogicalMargin border =
        aDelegatingFrame->GetLogicalUsedBorder(outerWM).ApplySkipSides(
            aDelegatingFrame->PreReflowBlockLevelLogicalSkipSides());

    const nsIFrame* kidPrevInFlow = aKidFrame->GetPrevInFlow();
    const LogicalPoint* const unfragmentedPosition =
        GetUnfragmentedPosition(aReflowInput, aKidFrame);
    nscoord availBSize;
    if (kidFrameMaySplit) {
      if (unfragmentedPosition) {
        // The unfragmented position is relative to the absolute containing
        // block's first fragment, so we subtract
        // mCumulativeContainingBlockBSize to get the position in this fragment.
        const nscoord kidBPosInThisFragment =
            unfragmentedPosition->B(outerWM) - mCumulativeContainingBlockBSize;
        availBSize = aReflowInput.AvailableBSize() - kidBPosInThisFragment;
        NS_ASSERTION(availBSize >= 0, "Why is available block-size < 0?");
      } else if (!aDelegatingFrame->GetPrevInFlow()) {
        // aDelegatingFrame is a first-in-flow. We subtract our containing
        // block's border-block-start, to consider the available space as
        // starting at the containing block's padding-edge.
        availBSize = aReflowInput.AvailableBSize() - border.BStart(outerWM);
      } else {
        // aDelegatingFrame is *not* a first-in-flow. Then we don't need to
        // subtract the containing block's border. Instead, we consider this
        // whole fragment as our available space, i.e., we allow abspos
        // continuations to overlap any border that their containing block
        // parent might have (including borders generated by
        // 'box-decoration-break:clone').
        availBSize = aReflowInput.AvailableBSize();
      }
    } else {
      availBSize = NS_UNCONSTRAINEDSIZE;
    }
    StyleSizeOverrides sizeOverrides;
    Maybe<nscoord> unfragmentedBSizeAsMinBSize;
    if (const auto* unfragmentedSize =
            GetUnfragmentedSize(aReflowInput, aKidFrame)) {
      // ReflowInput for fragmented absolute frames will not compute absolute
      // constraints - it'd be redundant anyway, so just use the unfragmented
      // size and skip it.
      auto resolutionParams =
          AnchorPosResolutionParams::From(aKidFrame, aAnchorPosResolutionCache);
      const auto* stylePos = aKidFrame->StylePosition();
      if (stylePos->ISize(wm, resolutionParams)->IsAuto()) {
        sizeOverrides.mStyleISize.emplace(
            StyleSize::FromAppUnits(unfragmentedSize->ISize(wm)));
      }
      if (stylePos->BSize(wm, resolutionParams)->IsAuto()) {
        unfragmentedBSizeAsMinBSize = Some(unfragmentedSize->BSize(wm));
      }
    }
    const LogicalSize availSize(outerWM, cbSize.ISize(outerWM), availBSize);
    ReflowInput kidReflowInput(aPresContext, aReflowInput, aKidFrame,
                               availSize.ConvertTo(wm, outerWM),
                               Some(cbSize.ConvertTo(wm, outerWM)), initFlags,
                               sizeOverrides, {}, aAnchorPosResolutionCache);

    if (unfragmentedBSizeAsMinBSize) {
      // The kid has 'auto' block-size. Instead of setting unfragmented
      // block-size to sizeOverrides above, use it as a min-block-size lower
      // bound to keep allowing fragmentation-imposed block-size growth.
      const nscoord contentBSize =
          *unfragmentedBSizeAsMinBSize -
          (kidReflowInput.mStylePosition->mBoxSizing ==
                   StyleBoxSizing::BorderBox
               ? kidReflowInput.ComputedLogicalBorderPadding(wm).BStartEnd(wm)
               : 0);
      kidReflowInput.SetComputedMinBSize(contentBSize);
    }

    if (unfragmentedPosition) {
      // Do nothing. If aKidFrame may split, we've adjusted availBSize before
      // creating kidReflowInput.
    } else if (!kidPrevInFlow) {
      // ReflowInput's constructor may change the available block-size to
      // unconstrained, e.g. in orthogonal reflow, so we retrieve it again and
      // account for kid's constraints in its own writing-mode if needed.
      nscoord kidAvailBSize = kidReflowInput.AvailableBSize();
      if (kidAvailBSize != NS_UNCONSTRAINEDSIZE) {
        kidAvailBSize -= kidReflowInput.ComputedLogicalMargin(wm).BStart(wm);
        nscoord kidOffsetBStart =
            kidReflowInput.ComputedLogicalOffsets(wm).BStart(wm);
        if (kidOffsetBStart != NS_AUTOOFFSET) {
          kidOffsetBStart -= mCumulativeContainingBlockBSize;
          kidAvailBSize -= kidOffsetBStart;
        }
        kidReflowInput.SetAvailableBSize(kidAvailBSize);
      }
    }

    // Do the reflow
    ReflowOutput kidDesiredSize(kidReflowInput);
    aKidFrame->Reflow(aPresContext, kidDesiredSize, kidReflowInput, aStatus);

    nsMargin insets;
    if (aKidFrame->IsMenuPopupFrame()) {
      // Do nothing. Popup frame will handle its own positioning.
    } else if (unfragmentedPosition || kidPrevInFlow) {
      // We can have reflows in a spanner that is also a multicol.
      const auto maybeFragmentedCbSize =
          (aFragmentedContainingBlockRects ? *aFragmentedContainingBlockRects
                                           : aContainingBlockRects)
              .mLocal.Size();
      // TODO(dshin): Fix this up for anchor positioning. Scroll containers are
      // monolithic and will not fragment, but an anchor-positioned frame's
      // percentage size still needs to resolve against the correct containing
      // block.
      const LogicalSize unmodifiedCBSize(outerWM, maybeFragmentedCbSize);
      const nsSize cbBorderBoxSize =
          (unmodifiedCBSize + border.Size(outerWM)).GetPhysicalSize(outerWM);
      LogicalPoint kidPos(outerWM);
      if (unfragmentedPosition) {
        MOZ_ASSERT(!kidPrevInFlow, "aKidFrame should be a first-in-flow!");

        // aKidFrame is a first-in-flow. Place it at its unfragmented position
        // with the block-start position adjusted.
        kidPos = *unfragmentedPosition;
        kidPos.B(outerWM) -= mCumulativeContainingBlockBSize;
      } else {
        // aKidFrame is a next-in-flow. Place it at the block-edge start of its
        // containing block, with the same inline-position as its prev-in-flow.
        kidPos = LogicalPoint(
            outerWM, kidPrevInFlow->IStart(outerWM, cbBorderBoxSize), 0);
      }
      const LogicalSize kidSize = kidDesiredSize.Size(outerWM);
      const LogicalRect kidRect(outerWM, kidPos, kidSize);
      aKidFrame->SetRect(outerWM, kidRect, cbBorderBoxSize);
    } else {
      // Position the child relative to our padding edge.
      const LogicalSize kidSize = kidDesiredSize.Size(outerWM);

      LogicalMargin offsets = kidReflowInput.ComputedLogicalOffsets(outerWM);
      LogicalMargin margin = kidReflowInput.ComputedLogicalMargin(outerWM);

      // If we're doing CSS Box Alignment in either axis, that will apply the
      // margin for us in that axis (since the thing that's aligned is the
      // margin box).  So, we clear out the margin here to avoid applying it
      // twice.
      if (kidReflowInput.mFlags.mIOffsetsNeedCSSAlign) {
        margin.IStart(outerWM) = margin.IEnd(outerWM) = 0;
      }
      if (kidReflowInput.mFlags.mBOffsetsNeedCSSAlign) {
        margin.BStart(outerWM) = margin.BEnd(outerWM) = 0;
      }

      // If we're solving for start in either inline or block direction,
      // then compute it now that we know the dimensions.
      ResolveSizeDependentOffsets(kidReflowInput, cbSize, kidSize, margin,
                                  cb.GetAnchorOffsetInfo(), offsets);

      ResolveAutoMarginsAfterLayout(kidReflowInput, cbSize, kidSize, margin,
                                    offsets);

      // If the inset is constrained as non-auto, we may have a child that does
      // not fill out the inset-reduced containing block. In this case, we need
      // to align the child by its margin box:
      // https://drafts.csswg.org/css-position-3/#abspos-layout
      const auto* stylePos = aKidFrame->StylePosition();
      const auto anchorResolutionParams =
          AnchorPosOffsetResolutionParams::ExplicitCBFrameSize(
              AnchorPosResolutionParams::From(aKidFrame,
                                              aAnchorPosResolutionCache),
              &cbSize);
      const bool iStartInsetAuto =
          stylePos
              ->GetAnchorResolvedInset(LogicalSide::IStart, outerWM,
                                       anchorResolutionParams)
              ->IsAuto();
      const bool iEndInsetAuto =
          stylePos
              ->GetAnchorResolvedInset(LogicalSide::IEnd, outerWM,
                                       anchorResolutionParams)
              ->IsAuto();
      const bool iInsetAuto = iStartInsetAuto || iEndInsetAuto;

      const bool bStartInsetAuto =
          stylePos
              ->GetAnchorResolvedInset(LogicalSide::BStart, outerWM,
                                       anchorResolutionParams)
              ->IsAuto();
      const bool bEndInsetAuto =
          stylePos
              ->GetAnchorResolvedInset(LogicalSide::BEnd, outerWM,
                                       anchorResolutionParams)
              ->IsAuto();
      const bool bInsetAuto = bStartInsetAuto || bEndInsetAuto;
      const LogicalSize kidMarginBox{
          outerWM, margin.IStartEnd(outerWM) + kidSize.ISize(outerWM),
          margin.BStartEnd(outerWM) + kidSize.BSize(outerWM)};
      const auto* placeholderContainer =
          GetPlaceholderContainer(kidReflowInput.mFrame);

      insets = [&]() {
        auto result = offsets;
        // Zero out weaker insets, if one exists - This offset gets forced to
        // the margin edge of the child on that side, and for the purposes of
        // overflow checks, we consider them to be zero.
        if (iStartInsetAuto && !iEndInsetAuto) {
          result.IStart(outerWM) = 0;
        } else if (iInsetAuto) {
          result.IEnd(outerWM) = 0;
        }
        if (bStartInsetAuto && !bEndInsetAuto) {
          result.BStart(outerWM) = 0;
        } else if (bInsetAuto) {
          result.BEnd(outerWM) = 0;
        }
        return result.GetPhysicalMargin(outerWM);
      }();
      if (aAnchorPosResolutionCache) {
        aAnchorPosResolutionCache->mReferenceData->mInsets = insets;
      }
      if (!iInsetAuto) {
        MOZ_ASSERT(
            !kidReflowInput.mFlags.mIOffsetsNeedCSSAlign,
            "Non-auto inline inset but requires CSS alignment for static "
            "position?");
        auto alignOffset = OffsetToAlignedStaticPos(
            kidReflowInput, kidMarginBox, cbSize, placeholderContainer, outerWM,
            LogicalAxis::Inline,
            Some(NonAutoAlignParams{
                offsets.IStart(outerWM),
                offsets.IEnd(outerWM),
            }),
            cb.GetAnchorOffsetInfo());

        offsets.IStart(outerWM) += alignOffset;
        offsets.IEnd(outerWM) =
            cbSize.ISize(outerWM) -
            (offsets.IStart(outerWM) + kidMarginBox.ISize(outerWM));
      }
      if (!bInsetAuto) {
        MOZ_ASSERT(!kidReflowInput.mFlags.mBOffsetsNeedCSSAlign,
                   "Non-auto block inset but requires CSS alignment for static "
                   "position?");
        auto alignOffset = OffsetToAlignedStaticPos(
            kidReflowInput, kidMarginBox, cbSize, placeholderContainer, outerWM,
            LogicalAxis::Block,
            Some(NonAutoAlignParams{
                offsets.BStart(outerWM),
                offsets.BEnd(outerWM),
            }),
            cb.GetAnchorOffsetInfo());
        offsets.BStart(outerWM) += alignOffset;
        offsets.BEnd(outerWM) =
            cbSize.BSize(outerWM) -
            (offsets.BStart(outerWM) + kidMarginBox.BSize(outerWM));
      }

      LogicalRect rect(
          outerWM, offsets.StartOffset(outerWM) + margin.StartOffset(outerWM),
          kidSize);
      nsRect r = rect.GetPhysicalRect(outerWM, cbSize.GetPhysicalSize(outerWM));

      // So far, we've positioned against the padding edge of the containing
      // block, which is necessary for inset computation. However, the position
      // of a frame originates against the border box.
      r += cb.mFinalRect.TopLeft();

      const auto scrollShift = [&]() -> nsPoint {
        if (!aAnchorPosResolutionCache) {
          return {};
        }
        auto* referenceData = aAnchorPosResolutionCache->mReferenceData;
        if (referenceData->CompensatingForScrollAxes().isEmpty()) {
          return {};
        }
        if (cb.mAnchorOffsetInfo &&
            earlyScrollCompensation ==
                referenceData->CompensatingForScrollAxes()) {
          // Able to use the already-resolved value.
          return cb.mAnchorOffsetInfo->mScrollOffset;
        }
        return AnchorPositioningUtils::GetScrollOffsetFor(
            referenceData->CompensatingForScrollAxes(), aKidFrame,
            aAnchorPosResolutionCache->mDefaultAnchorCache);
      }();
      if (aAnchorPosResolutionCache) {
        aAnchorPosResolutionCache->mReferenceData->mDefaultScrollShift =
            scrollShift;
      }
      r -= scrollShift;
      aKidFrame->SetRect(r);
    }

    aKidFrame->DidReflow(aPresContext, &kidReflowInput);

    if (!firstTryRect) {
      firstTryRect.emplace(aKidFrame->GetRect());
    }

    const auto FitsInContainingBlock = [&]() {
      if (aAnchorPosResolutionCache) {
        return AnchorPositioningUtils::FitsInContainingBlock(
            aKidFrame, *aAnchorPosResolutionCache->mReferenceData);
      }
      auto imcbSize = cb.mFinalRect.Size();
      imcbSize -= nsSize{insets.LeftRight(), insets.TopBottom()};
      return aKidFrame->GetMarginRectRelativeToSelf().Size() <= imcbSize;
    };

    // FIXME(bug 2004495): Per spec this should be the inset-modified
    // containing-block, see:
    // https://drafts.csswg.org/css-anchor-position-1/#fallback-apply
    const auto fits = aStatus.IsComplete() && FitsInContainingBlock();
    if (fallbacks.IsEmpty() || finalizing ||
        (fits && (tryOrder == StylePositionTryOrder::Normal ||
                  currentFallbackIndex == firstTryIndex))) {
      // We completed the reflow - Either we had a fallback that fit, or we
      // didn't have any to try in the first place.
      isOverflowingCB = !fits;
      fallback.CommitCurrentFallback();
      if (currentFallbackIndex.isNothing()) {
        if (auto* prop = aKidFrame->GetProperty(
                nsIFrame::LastSuccessfulPositionFallback())) {
          // When the fallback list changes, we clear the recorded fallback data
          // as per spec, so we shouldn't get there in this case.
          MOZ_ASSERT(!fallbacks.IsEmpty(), "how?");
          prop->mLastIndex.reset();
          prop->mLastStyle = nullptr;
          prop->mTriedAllFallbacks = isOverflowingCB;
        }
      }
      break;
    }

    if (fits) {
      auto imcbSize = cb.mFinalRect.Size();
      imcbSize -= nsSize{insets.LeftRight(), insets.TopBottom()};
      switch (tryOrder) {
        case StylePositionTryOrder::MostWidth:
          if (imcbSize.Width() > bestSize) {
            bestSize = imcbSize.Width();
            bestIndex = currentFallbackIndex;
          }
          break;
        case StylePositionTryOrder::MostHeight:
          if (imcbSize.Height() > bestSize) {
            bestSize = imcbSize.Height();
            bestIndex = currentFallbackIndex;
          }
          break;
        default:
          MOZ_ASSERT_UNREACHABLE("unexpected try-order value");
          break;
      }
    }

    if (!TryAdvanceFallback()) {
      // If there are no further fallbacks, we're done.
      if (bestSize >= 0) {
        SeekFallbackTo(bestIndex);
      } else {
        // If we're going to roll back to the first try position, and the
        // target's size was different, we need to do a "finalizing" reflow
        // to ensure the inner layout is correct. If the size is unchanged,
        // we can just break the fallback loop now.
        if (isOverflowingCB && firstTryRect &&
            firstTryRect->Size() != aKidFrame->GetSize()) {
          SeekFallbackTo(firstTryIndex);
        } else {
          break;
        }
      }
      // The fallback we've just selected is the final choice, regardless of
      // whether it overflows.
      finalizing = true;
    }

    // Try with the next fallback.
    aKidFrame->AddStateBits(NS_FRAME_IS_DIRTY);
    aStatus.Reset();
  } while (true);

  [&]() {
    if (!isOverflowingCB || !firstTryRect) {
      return;
    }
    // We gave up applying fallbacks. Recover previous values, if changed, and
    // reset currentFallbackIndex/Style to match.
    // Because we rolled back to first try data, our cache should be up-to-date.
    currentFallbackIndex = firstTryIndex;
    currentFallbackStyle = firstTryStyle;
    auto rect = *firstTryRect;
    if (isOverflowingCB &&
        !aKidFrame->StylePosition()->mPositionArea.IsNone()) {
      // The anchored element overflows the IMCB of its position-area. Would it
      // have fit within the original CB? If so, shift it to stay within that.
      if (rect.width <= aContainingBlockRects.mLocal.width &&
          rect.height <= aContainingBlockRects.mLocal.height) {
        if (rect.x < aContainingBlockRects.mLocal.x) {
          rect.x = aContainingBlockRects.mLocal.x;
        } else if (rect.XMost() > aContainingBlockRects.mLocal.XMost()) {
          rect.x = aContainingBlockRects.mLocal.XMost() - rect.width;
        }
        if (rect.y < aContainingBlockRects.mLocal.y) {
          rect.y = aContainingBlockRects.mLocal.y;
        } else if (rect.YMost() > aContainingBlockRects.mLocal.YMost()) {
          rect.y = aContainingBlockRects.mLocal.YMost() - rect.height;
        }
      }
    }
    if (rect.TopLeft() == aKidFrame->GetPosition()) {
      return;
    }
    aKidFrame->SetPosition(rect.TopLeft());
    aKidFrame->UpdateOverflow();
  }();

  if (currentFallbackIndex) {
    auto* lastSuccessfulPosition = aKidFrame->GetOrCreateDeletableProperty(
        nsIFrame::LastSuccessfulPositionFallback());
    // NOTE: We don't touch the last recorded index, that's done at resize
    // observer time.
    lastSuccessfulPosition->mLastIndex = currentFallbackIndex;
    lastSuccessfulPosition->mLastStyle = std::move(currentFallbackStyle);
    lastSuccessfulPosition->mTriedAllFallbacks = isOverflowingCB;
  }

#ifdef DEBUG
  if (nsBlockFrame::gNoisyReflow) {
    nsIFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent - 1);
    fmt::println("abspos {}: rect {}", aKidFrame->ListTag().get(),
                 ToString(aKidFrame->GetRect()));
  }
#endif
  // If author asked for `position-visibility: no-overflow` and we overflow
  // `usedCB`, treat as "strongly hidden". Note that for anchored frames this
  // happens in ComputePositionVisibility. But no-overflow also applies to
  // non-anchored frames.
  if (!aAnchorPosResolutionCache) {
    aKidFrame->AddOrRemoveStateBits(
        NS_FRAME_POSITION_VISIBILITY_HIDDEN,
        isOverflowingCB && aKidFrame->StylePosition()->mPositionVisibility &
                               StylePositionVisibility::NO_OVERFLOW);
  }

  if (aOverflowAreas) {
    aDelegatingFrame->ConsiderChildOverflow(
        *aOverflowAreas, aKidFrame, OverflowAreaUnionFlags::ChildIsAbsPos);
  }
}