summaryrefslogtreecommitdiffstats
path: root/layout/generic/nsGridContainerFrame.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'layout/generic/nsGridContainerFrame.cpp')
-rw-r--r--layout/generic/nsGridContainerFrame.cpp10261
1 files changed, 10261 insertions, 0 deletions
diff --git a/layout/generic/nsGridContainerFrame.cpp b/layout/generic/nsGridContainerFrame.cpp
new file mode 100644
index 0000000000..97d8549cb0
--- /dev/null
+++ b/layout/generic/nsGridContainerFrame.cpp
@@ -0,0 +1,10261 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+/* rendering object for CSS "display: grid | inline-grid" */
+
+#include "nsGridContainerFrame.h"
+
+#include <functional>
+#include <stdlib.h> // for div()
+#include <type_traits>
+#include "gfxContext.h"
+#include "mozilla/AutoRestore.h"
+#include "mozilla/Baseline.h"
+#include "mozilla/ComputedStyle.h"
+#include "mozilla/CSSAlignUtils.h"
+#include "mozilla/dom/Grid.h"
+#include "mozilla/dom/GridBinding.h"
+#include "mozilla/IntegerRange.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/PodOperations.h" // for PodZero
+#include "mozilla/PresShell.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "nsAbsoluteContainingBlock.h"
+#include "nsAlgorithm.h" // for clamped()
+#include "nsCSSFrameConstructor.h"
+#include "nsDisplayList.h"
+#include "nsFieldSetFrame.h"
+#include "nsHashKeys.h"
+#include "nsIFrameInlines.h" // for nsIFrame::GetLogicalNormalPosition (don't remove)
+#include "nsLayoutUtils.h"
+#include "nsPlaceholderFrame.h"
+#include "nsPresContext.h"
+#include "nsReadableUtils.h"
+#include "nsTableWrapperFrame.h"
+
+using namespace mozilla;
+
+typedef nsAbsoluteContainingBlock::AbsPosReflowFlags AbsPosReflowFlags;
+typedef nsGridContainerFrame::TrackSize TrackSize;
+typedef mozilla::CSSAlignUtils::AlignJustifyFlags AlignJustifyFlags;
+
+using GridTemplate = StyleGridTemplateComponent;
+using TrackListValue =
+ StyleGenericTrackListValue<LengthPercentage, StyleInteger>;
+using TrackRepeat = StyleGenericTrackRepeat<LengthPercentage, StyleInteger>;
+using NameList = StyleOwnedSlice<StyleCustomIdent>;
+using SizingConstraint = nsGridContainerFrame::SizingConstraint;
+using GridItemCachedBAxisMeasurement =
+ nsGridContainerFrame::CachedBAxisMeasurement;
+
+static mozilla::LazyLogModule gGridContainerLog("GridContainer");
+#define GRID_LOG(...) \
+ MOZ_LOG(gGridContainerLog, LogLevel::Debug, (__VA_ARGS__));
+
+static const int32_t kMaxLine = StyleMAX_GRID_LINE;
+static const int32_t kMinLine = StyleMIN_GRID_LINE;
+// The maximum line number, in the zero-based translated grid.
+static const uint32_t kTranslatedMaxLine = uint32_t(kMaxLine - kMinLine);
+static const uint32_t kAutoLine = kTranslatedMaxLine + 3457U;
+
+static const nsFrameState kIsSubgridBits =
+ (NS_STATE_GRID_IS_COL_SUBGRID | NS_STATE_GRID_IS_ROW_SUBGRID);
+
+namespace mozilla {
+
+template <>
+inline Span<const StyleOwnedSlice<StyleCustomIdent>>
+GridTemplate::LineNameLists(bool aIsSubgrid) const {
+ if (IsTrackList()) {
+ return AsTrackList()->line_names.AsSpan();
+ }
+ if (IsSubgrid() && aIsSubgrid) {
+ // For subgrid, we need to resolve <line-name-list> from each
+ // StyleGenericLineNameListValue, so return empty.
+ return {};
+ }
+ MOZ_ASSERT(IsNone() || IsMasonry() || (IsSubgrid() && !aIsSubgrid));
+ return {};
+}
+
+template <>
+inline const StyleTrackBreadth& StyleTrackSize::GetMax() const {
+ if (IsBreadth()) {
+ return AsBreadth();
+ }
+ if (IsMinmax()) {
+ return AsMinmax()._1;
+ }
+ MOZ_ASSERT(IsFitContent());
+ return AsFitContent();
+}
+
+template <>
+inline const StyleTrackBreadth& StyleTrackSize::GetMin() const {
+ static const StyleTrackBreadth kAuto = StyleTrackBreadth::Auto();
+ if (IsBreadth()) {
+ // <flex> behaves like minmax(auto, <flex>)
+ return AsBreadth().IsFr() ? kAuto : AsBreadth();
+ }
+ if (IsMinmax()) {
+ return AsMinmax()._0;
+ }
+ MOZ_ASSERT(IsFitContent());
+ return kAuto;
+}
+
+} // namespace mozilla
+
+static nscoord ClampToCSSMaxBSize(nscoord aSize,
+ const ReflowInput* aReflowInput) {
+ auto maxSize = aReflowInput->ComputedMaxBSize();
+ if (MOZ_UNLIKELY(maxSize != NS_UNCONSTRAINEDSIZE)) {
+ MOZ_ASSERT(aReflowInput->ComputedMinBSize() <= maxSize);
+ aSize = std::min(aSize, maxSize);
+ }
+ return aSize;
+}
+
+// Same as above and set aStatus INCOMPLETE if aSize wasn't clamped.
+// (If we clamp aSize it means our size is less than the break point,
+// i.e. we're effectively breaking in our overflow, so we should leave
+// aStatus as is (it will likely be set to OVERFLOW_INCOMPLETE later)).
+static nscoord ClampToCSSMaxBSize(nscoord aSize,
+ const ReflowInput* aReflowInput,
+ nsReflowStatus* aStatus) {
+ auto maxSize = aReflowInput->ComputedMaxBSize();
+ if (MOZ_UNLIKELY(maxSize != NS_UNCONSTRAINEDSIZE)) {
+ MOZ_ASSERT(aReflowInput->ComputedMinBSize() <= maxSize);
+ if (aSize < maxSize) {
+ aStatus->SetIncomplete();
+ } else {
+ aSize = maxSize;
+ }
+ } else {
+ aStatus->SetIncomplete();
+ }
+ return aSize;
+}
+
+template <typename Size>
+static bool IsPercentOfIndefiniteSize(const Size& aCoord,
+ nscoord aPercentBasis) {
+ return aPercentBasis == NS_UNCONSTRAINEDSIZE && aCoord.HasPercent();
+}
+
+static nscoord ResolveToDefiniteSize(const StyleTrackBreadth& aBreadth,
+ nscoord aPercentBasis) {
+ MOZ_ASSERT(aBreadth.IsBreadth());
+ if (::IsPercentOfIndefiniteSize(aBreadth.AsBreadth(), aPercentBasis)) {
+ return nscoord(0);
+ }
+ return std::max(nscoord(0), aBreadth.AsBreadth().Resolve(aPercentBasis));
+}
+
+// Synthesize a baseline from a border box. For an alphabetical baseline
+// this is the end edge of the border box. For a central baseline it's
+// the center of the border box.
+// https://drafts.csswg.org/css-align-3/#synthesize-baseline
+// For a 'first baseline' the measure is from the border-box start edge and
+// for a 'last baseline' the measure is from the border-box end edge.
+//
+// The 'LogicalAxis aAxis' represents the axis (in terms of aWM) that the
+// baseline corresponds to. (Typically, baselines are a measurement in the
+// block axis; e.g. for English horizontal-tb text, a traditional baseline
+// would be a y-axis measurement. But in some cases (e.g. orthogonal WMs), we
+// may need to synthesize a baseline in a child's inline axis, which is when
+// this function might receive an aAxis of eLogicalAxisInline. In that case, we
+// assume that the writing mode's preference for central vs. alphabetic
+// baselines is irrelevant, since that's a choice about its block-axis
+// baselines, and we just unconditionally use the alphabetic baseline
+// (e.g. border-box bottom edge).
+static nscoord SynthesizeBaselineFromBorderBox(BaselineSharingGroup aGroup,
+ WritingMode aWM,
+ LogicalAxis aAxis,
+ nscoord aBorderBoxSize) {
+ const bool useAlphabeticBaseline =
+ (aAxis == eLogicalAxisInline) ? true : aWM.IsAlphabeticalBaseline();
+
+ if (aGroup == BaselineSharingGroup::First) {
+ return useAlphabeticBaseline ? aBorderBoxSize : aBorderBoxSize / 2;
+ }
+ MOZ_ASSERT(aGroup == BaselineSharingGroup::Last);
+ // Round up for central baseline offset, to be consistent with eFirst.
+ return useAlphabeticBaseline ? 0
+ : (aBorderBoxSize / 2) + (aBorderBoxSize % 2);
+}
+
+// The input sizes for calculating the number of repeat(auto-fill/fit) tracks.
+// https://drafts.csswg.org/css-grid/#auto-repeat
+struct RepeatTrackSizingInput {
+ explicit RepeatTrackSizingInput(WritingMode aWM)
+ : mMin(aWM, 0, 0),
+ mSize(aWM, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE),
+ mMax(aWM, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE) {}
+ RepeatTrackSizingInput(const LogicalSize& aMin, const LogicalSize& aSize,
+ const LogicalSize& aMax)
+ : mMin(aMin), mSize(aSize), mMax(aMax) {}
+
+ // This should be used in intrinsic sizing (i.e. when we can't initialize
+ // the sizes directly from ReflowInput values).
+ void InitFromStyle(LogicalAxis aAxis, WritingMode aWM,
+ const ComputedStyle* aStyle) {
+ const auto& pos = aStyle->StylePosition();
+ const bool borderBoxSizing = pos->mBoxSizing == StyleBoxSizing::Border;
+ nscoord bp = NS_UNCONSTRAINEDSIZE; // a sentinel to calculate it only once
+ auto adjustForBoxSizing = [borderBoxSizing, aWM, aAxis, aStyle,
+ &bp](nscoord aSize) {
+ if (!borderBoxSizing) {
+ return aSize;
+ }
+ if (bp == NS_UNCONSTRAINEDSIZE) {
+ const auto& padding = aStyle->StylePadding()->mPadding;
+ LogicalMargin border(aWM, aStyle->StyleBorder()->GetComputedBorder());
+ // We can use zero percentage basis since this is only called from
+ // intrinsic sizing code.
+ const nscoord percentageBasis = 0;
+ if (aAxis == eLogicalAxisInline) {
+ bp = std::max(padding.GetIStart(aWM).Resolve(percentageBasis), 0) +
+ std::max(padding.GetIEnd(aWM).Resolve(percentageBasis), 0) +
+ border.IStartEnd(aWM);
+ } else {
+ bp = std::max(padding.GetBStart(aWM).Resolve(percentageBasis), 0) +
+ std::max(padding.GetBEnd(aWM).Resolve(percentageBasis), 0) +
+ border.BStartEnd(aWM);
+ }
+ }
+ return std::max(aSize - bp, 0);
+ };
+ nscoord& min = mMin.Size(aAxis, aWM);
+ nscoord& size = mSize.Size(aAxis, aWM);
+ nscoord& max = mMax.Size(aAxis, aWM);
+ const auto& minCoord =
+ aAxis == eLogicalAxisInline ? pos->MinISize(aWM) : pos->MinBSize(aWM);
+ if (minCoord.ConvertsToLength()) {
+ min = adjustForBoxSizing(minCoord.ToLength());
+ }
+ const auto& maxCoord =
+ aAxis == eLogicalAxisInline ? pos->MaxISize(aWM) : pos->MaxBSize(aWM);
+ if (maxCoord.ConvertsToLength()) {
+ max = std::max(min, adjustForBoxSizing(maxCoord.ToLength()));
+ }
+ const auto& sizeCoord =
+ aAxis == eLogicalAxisInline ? pos->ISize(aWM) : pos->BSize(aWM);
+ if (sizeCoord.ConvertsToLength()) {
+ size = Clamp(adjustForBoxSizing(sizeCoord.ToLength()), min, max);
+ }
+ }
+
+ LogicalSize mMin;
+ LogicalSize mSize;
+ LogicalSize mMax;
+};
+
+enum class GridLineSide {
+ BeforeGridGap,
+ AfterGridGap,
+};
+
+struct nsGridContainerFrame::TrackSize {
+ enum StateBits : uint16_t {
+ // clang-format off
+ eAutoMinSizing = 0x1,
+ eMinContentMinSizing = 0x2,
+ eMaxContentMinSizing = 0x4,
+ eMinOrMaxContentMinSizing = eMinContentMinSizing | eMaxContentMinSizing,
+ eIntrinsicMinSizing = eMinOrMaxContentMinSizing | eAutoMinSizing,
+ eModified = 0x8,
+ eAutoMaxSizing = 0x10,
+ eMinContentMaxSizing = 0x20,
+ eMaxContentMaxSizing = 0x40,
+ eAutoOrMaxContentMaxSizing = eAutoMaxSizing | eMaxContentMaxSizing,
+ eIntrinsicMaxSizing = eAutoOrMaxContentMaxSizing | eMinContentMaxSizing,
+ eFlexMaxSizing = 0x80,
+ eFrozen = 0x100,
+ eSkipGrowUnlimited1 = 0x200,
+ eSkipGrowUnlimited2 = 0x400,
+ eSkipGrowUnlimited = eSkipGrowUnlimited1 | eSkipGrowUnlimited2,
+ eBreakBefore = 0x800,
+ eFitContent = 0x1000,
+ eInfinitelyGrowable = 0x2000,
+
+ // These are only used in the masonry axis. They share the same value
+ // as *MinSizing above, but that's OK because we don't use those in
+ // the masonry axis.
+ //
+ // This track corresponds to an item margin-box size that is stretching.
+ eItemStretchSize = 0x1,
+ // This bit says that we should clamp that size to mLimit.
+ eClampToLimit = 0x2,
+ // This bit says that the corresponding item has `auto` margin(s).
+ eItemHasAutoMargin = 0x4,
+ // clang-format on
+ };
+
+ StateBits Initialize(nscoord aPercentageBasis, const StyleTrackSize&);
+ bool IsFrozen() const { return mState & eFrozen; }
+#ifdef DEBUG
+ static void DumpStateBits(StateBits aState);
+ void Dump() const;
+#endif
+
+ static bool IsDefiniteMaxSizing(StateBits aStateBits) {
+ return (aStateBits & (eIntrinsicMaxSizing | eFlexMaxSizing)) == 0;
+ }
+
+ nscoord mBase;
+ nscoord mLimit;
+ nscoord mPosition; // zero until we apply 'align/justify-content'
+ // mBaselineSubtreeSize is the size of a baseline-aligned subtree within
+ // this track. One subtree per baseline-sharing group (per track).
+ PerBaseline<nscoord> mBaselineSubtreeSize;
+ StateBits mState;
+};
+
+MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(TrackSize::StateBits)
+
+static_assert(
+ std::is_trivially_copyable<nsGridContainerFrame::TrackSize>::value,
+ "Must be trivially copyable");
+static_assert(
+ std::is_trivially_destructible<nsGridContainerFrame::TrackSize>::value,
+ "Must be trivially destructible");
+
+TrackSize::StateBits nsGridContainerFrame::TrackSize::Initialize(
+ nscoord aPercentageBasis, const StyleTrackSize& aSize) {
+ using Tag = StyleTrackBreadth::Tag;
+
+ MOZ_ASSERT(mBase == 0 && mLimit == 0 && mState == 0,
+ "track size data is expected to be initialized to zero");
+ mBaselineSubtreeSize[BaselineSharingGroup::First] = nscoord(0);
+ mBaselineSubtreeSize[BaselineSharingGroup::Last] = nscoord(0);
+
+ auto& min = aSize.GetMin();
+ auto& max = aSize.GetMax();
+
+ Tag minSizeTag = min.tag;
+ Tag maxSizeTag = max.tag;
+ if (aSize.IsFitContent()) {
+ // In layout, fit-content(size) behaves as minmax(auto, max-content), with
+ // 'size' as an additional upper-bound.
+ mState = eFitContent;
+ minSizeTag = Tag::Auto;
+ maxSizeTag = Tag::MaxContent;
+ }
+ if (::IsPercentOfIndefiniteSize(min, aPercentageBasis)) {
+ // https://drafts.csswg.org/css-grid/#valdef-grid-template-columns-percentage
+ // "If the inline or block size of the grid container is indefinite,
+ // <percentage> values relative to that size are treated as 'auto'."
+ minSizeTag = Tag::Auto;
+ }
+ if (::IsPercentOfIndefiniteSize(max, aPercentageBasis)) {
+ maxSizeTag = Tag::Auto;
+ }
+
+ // http://dev.w3.org/csswg/css-grid/#algo-init
+ switch (minSizeTag) {
+ case Tag::Auto:
+ mState |= eAutoMinSizing;
+ break;
+ case Tag::MinContent:
+ mState |= eMinContentMinSizing;
+ break;
+ case Tag::MaxContent:
+ mState |= eMaxContentMinSizing;
+ break;
+ default:
+ MOZ_ASSERT(!min.IsFr(), "<flex> min-sizing is invalid as a track size");
+ mBase = ::ResolveToDefiniteSize(min, aPercentageBasis);
+ }
+ switch (maxSizeTag) {
+ case Tag::Auto:
+ mState |= eAutoMaxSizing;
+ mLimit = NS_UNCONSTRAINEDSIZE;
+ break;
+ case Tag::MinContent:
+ case Tag::MaxContent:
+ mState |= maxSizeTag == Tag::MinContent ? eMinContentMaxSizing
+ : eMaxContentMaxSizing;
+ mLimit = NS_UNCONSTRAINEDSIZE;
+ break;
+ case Tag::Fr:
+ mState |= eFlexMaxSizing;
+ mLimit = mBase;
+ break;
+ default:
+ mLimit = ::ResolveToDefiniteSize(max, aPercentageBasis);
+ if (mLimit < mBase) {
+ mLimit = mBase;
+ }
+ }
+ return mState;
+}
+
+/**
+ * A LineRange can be definite or auto - when it's definite it represents
+ * a consecutive set of tracks between a starting line and an ending line.
+ * Before it's definite it can also represent an auto position with a span,
+ * where mStart == kAutoLine and mEnd is the (non-zero positive) span.
+ * For normal-flow items, the invariant mStart < mEnd holds when both
+ * lines are definite.
+ *
+ * For abs.pos. grid items, mStart and mEnd may both be kAutoLine, meaning
+ * "attach this side to the grid container containing block edge".
+ * Additionally, mStart <= mEnd holds when both are definite (non-kAutoLine),
+ * i.e. the invariant is slightly relaxed compared to normal flow items.
+ */
+struct nsGridContainerFrame::LineRange {
+ LineRange(int32_t aStart, int32_t aEnd)
+ : mUntranslatedStart(aStart), mUntranslatedEnd(aEnd) {
+#ifdef DEBUG
+ if (!IsAutoAuto()) {
+ if (IsAuto()) {
+ MOZ_ASSERT(aEnd >= kMinLine && aEnd <= kMaxLine, "invalid span");
+ } else {
+ MOZ_ASSERT(aStart >= kMinLine && aStart <= kMaxLine,
+ "invalid start line");
+ MOZ_ASSERT(aEnd == int32_t(kAutoLine) ||
+ (aEnd >= kMinLine && aEnd <= kMaxLine),
+ "invalid end line");
+ }
+ }
+#endif
+ }
+ bool IsAutoAuto() const { return mStart == kAutoLine && mEnd == kAutoLine; }
+ bool IsAuto() const { return mStart == kAutoLine; }
+ bool IsDefinite() const { return mStart != kAutoLine; }
+ uint32_t Extent() const {
+ MOZ_ASSERT(mEnd != kAutoLine, "Extent is undefined for abs.pos. 'auto'");
+ if (IsAuto()) {
+ MOZ_ASSERT(mEnd >= 1 && mEnd < uint32_t(kMaxLine), "invalid span");
+ return mEnd;
+ }
+ return mEnd - mStart;
+ }
+
+ /**
+ * Return an object suitable for iterating this range.
+ */
+ auto Range() const { return IntegerRange<uint32_t>(mStart, mEnd); }
+
+ /**
+ * Resolve this auto range to start at aStart, making it definite.
+ * @param aClampMaxLine the maximum allowed line number (zero-based)
+ * Precondition: this range IsAuto()
+ */
+ void ResolveAutoPosition(uint32_t aStart, uint32_t aClampMaxLine) {
+ MOZ_ASSERT(IsAuto(), "Why call me?");
+ mStart = aStart;
+ mEnd += aStart;
+ // Clamp to aClampMaxLine, which is where kMaxLine is in the explicit
+ // grid in a non-subgrid axis; this implements clamping per
+ // http://dev.w3.org/csswg/css-grid/#overlarge-grids
+ // In a subgrid axis it's the end of the grid in that axis.
+ if (MOZ_UNLIKELY(mStart >= aClampMaxLine)) {
+ mEnd = aClampMaxLine;
+ mStart = mEnd - 1;
+ } else if (MOZ_UNLIKELY(mEnd > aClampMaxLine)) {
+ mEnd = aClampMaxLine;
+ }
+ }
+ /**
+ * Translate the lines to account for (empty) removed tracks. This method
+ * is only for grid items and should only be called after placement.
+ * aNumRemovedTracks contains a count for each line in the grid how many
+ * tracks were removed between the start of the grid and that line.
+ */
+ void AdjustForRemovedTracks(const nsTArray<uint32_t>& aNumRemovedTracks) {
+ MOZ_ASSERT(mStart != kAutoLine, "invalid resolved line for a grid item");
+ MOZ_ASSERT(mEnd != kAutoLine, "invalid resolved line for a grid item");
+ uint32_t numRemovedTracks = aNumRemovedTracks[mStart];
+ MOZ_ASSERT(numRemovedTracks == aNumRemovedTracks[mEnd],
+ "tracks that a grid item spans can't be removed");
+ mStart -= numRemovedTracks;
+ mEnd -= numRemovedTracks;
+ }
+ /**
+ * Translate the lines to account for (empty) removed tracks. This method
+ * is only for abs.pos. children and should only be called after placement.
+ * Same as for in-flow items, but we don't touch 'auto' lines here and we
+ * also need to adjust areas that span into the removed tracks.
+ */
+ void AdjustAbsPosForRemovedTracks(
+ const nsTArray<uint32_t>& aNumRemovedTracks) {
+ if (mStart != kAutoLine) {
+ mStart -= aNumRemovedTracks[mStart];
+ }
+ if (mEnd != kAutoLine) {
+ MOZ_ASSERT(mStart == kAutoLine || mEnd > mStart, "invalid line range");
+ mEnd -= aNumRemovedTracks[mEnd];
+ }
+ }
+ /**
+ * Return the contribution of this line range for step 2 in
+ * http://dev.w3.org/csswg/css-grid/#auto-placement-algo
+ */
+ uint32_t HypotheticalEnd() const { return mEnd; }
+ /**
+ * Given an array of track sizes, return the starting position and length
+ * of the tracks in this line range.
+ */
+ void ToPositionAndLength(const nsTArray<TrackSize>& aTrackSizes,
+ nscoord* aPos, nscoord* aLength) const;
+ /**
+ * Given an array of track sizes, return the length of the tracks in this
+ * line range.
+ */
+ nscoord ToLength(const nsTArray<TrackSize>& aTrackSizes) const;
+ /**
+ * Given an array of track sizes and a grid origin coordinate, adjust the
+ * abs.pos. containing block along an axis given by aPos and aLength.
+ * aPos and aLength should already be initialized to the grid container
+ * containing block for this axis before calling this method.
+ */
+ void ToPositionAndLengthForAbsPos(const Tracks& aTracks, nscoord aGridOrigin,
+ nscoord* aPos, nscoord* aLength) const;
+
+ void Translate(int32_t aOffset) {
+ MOZ_ASSERT(IsDefinite());
+ mStart += aOffset;
+ mEnd += aOffset;
+ }
+
+ /** Swap the start/end sides of this range. */
+ void ReverseDirection(uint32_t aGridEnd) {
+ MOZ_ASSERT(IsDefinite());
+ MOZ_ASSERT(aGridEnd >= mEnd);
+ uint32_t newStart = aGridEnd - mEnd;
+ mEnd = aGridEnd - mStart;
+ mStart = newStart;
+ }
+
+ /**
+ * @note We'll use the signed member while resolving definite positions
+ * to line numbers (1-based), which may become negative for implicit lines
+ * to the top/left of the explicit grid. PlaceGridItems() then translates
+ * the whole grid to a 0,0 origin and we'll use the unsigned member from
+ * there on.
+ */
+ union {
+ uint32_t mStart;
+ int32_t mUntranslatedStart;
+ };
+ union {
+ uint32_t mEnd;
+ int32_t mUntranslatedEnd;
+ };
+
+ protected:
+ LineRange() : mStart(0), mEnd(0) {}
+};
+
+/**
+ * Helper class to construct a LineRange from translated lines.
+ * The ctor only accepts translated definite line numbers.
+ */
+struct nsGridContainerFrame::TranslatedLineRange : public LineRange {
+ TranslatedLineRange(uint32_t aStart, uint32_t aEnd) {
+ MOZ_ASSERT(aStart < aEnd && aEnd <= kTranslatedMaxLine);
+ mStart = aStart;
+ mEnd = aEnd;
+ }
+};
+
+/**
+ * A GridArea is the area in the grid for a grid item.
+ * The area is represented by two LineRanges, both of which can be auto
+ * (@see LineRange) in intermediate steps while the item is being placed.
+ * @see PlaceGridItems
+ */
+struct nsGridContainerFrame::GridArea {
+ GridArea(const LineRange& aCols, const LineRange& aRows)
+ : mCols(aCols), mRows(aRows) {}
+ bool IsDefinite() const { return mCols.IsDefinite() && mRows.IsDefinite(); }
+ LineRange& LineRangeForAxis(LogicalAxis aAxis) {
+ return aAxis == eLogicalAxisInline ? mCols : mRows;
+ }
+ const LineRange& LineRangeForAxis(LogicalAxis aAxis) const {
+ return aAxis == eLogicalAxisInline ? mCols : mRows;
+ }
+ LineRange mCols;
+ LineRange mRows;
+};
+
+struct nsGridContainerFrame::GridItemInfo {
+ /**
+ * Item state per axis.
+ */
+ enum StateBits : uint16_t {
+ // Does the item span a flex track?
+ eIsFlexing = 0x1,
+
+ // First or last baseline alignment preference. They are mutually exclusive.
+ // This does *NOT* represent the baseline alignment group. See the member
+ // variable for that.
+ // <https://drafts.csswg.org/css-align-3/#baseline-alignment-preference>
+ eFirstBaseline = 0x2,
+ eLastBaseline = 0x4,
+ eIsBaselineAligned = eFirstBaseline | eLastBaseline,
+
+ // One of e[Self|Content]Baseline is set when eIsBaselineAligned is true
+ eSelfBaseline = 0x8, // is it *-self:[last ]baseline alignment?
+ // Ditto *-content:[last ]baseline. Mutually exclusive w. eSelfBaseline.
+ eContentBaseline = 0x10,
+
+ // The baseline affects the margin or padding on the item's end side when
+ // this bit is set. In a grid-axis it's always set for eLastBaseline and
+ // always unset for eFirstBaseline. In a masonry-axis, it's set for
+ // baseline groups in the EndStretch set and unset for the StartStretch set.
+ eEndSideBaseline = 0x20,
+ eAllBaselineBits = eIsBaselineAligned | eSelfBaseline | eContentBaseline |
+ eEndSideBaseline,
+
+ // Should apply Automatic Minimum Size per:
+ // https://drafts.csswg.org/css-grid/#min-size-auto
+ eApplyAutoMinSize = 0x40,
+ // Clamp per https://drafts.csswg.org/css-grid/#min-size-auto
+ eClampMarginBoxMinSize = 0x80,
+ eIsSubgrid = 0x100,
+ // set on subgrids and items in subgrids if they are adjacent to the grid
+ // start/end edge (excluding grid-aligned abs.pos. frames)
+ eStartEdge = 0x200,
+ eEndEdge = 0x400,
+ eEdgeBits = eStartEdge | eEndEdge,
+ // Set if this item was auto-placed in this axis.
+ eAutoPlacement = 0x800,
+ // Set if this item is the last item in its track (masonry layout only)
+ eIsLastItemInMasonryTrack = 0x1000,
+ };
+
+ GridItemInfo(nsIFrame* aFrame, const GridArea& aArea);
+
+ GridItemInfo(const GridItemInfo& aOther)
+ : mFrame(aOther.mFrame), mArea(aOther.mArea) {
+ mBaselineOffset = aOther.mBaselineOffset;
+ mState = aOther.mState;
+ }
+
+ GridItemInfo& operator=(const GridItemInfo&) = delete;
+
+ static bool BaselineAlignmentAffectsEndSide(StateBits state) {
+ return state & StateBits::eEndSideBaseline;
+ }
+
+ /**
+ * Inhibit subgrid layout unless the item is placed in the first "track" in
+ * a parent masonry-axis, or has definite placement or spans all tracks in
+ * the parent grid-axis.
+ * TODO: this is stricter than what the Masonry proposal currently states
+ * (bug 1627581)
+ */
+ void MaybeInhibitSubgridInMasonry(nsGridContainerFrame* aParent,
+ uint32_t aGridAxisTrackCount);
+
+ /**
+ * Inhibit subgridding in aAxis for this item.
+ */
+ void InhibitSubgrid(nsGridContainerFrame* aParent, LogicalAxis aAxis);
+
+ /**
+ * Return a copy of this item with its row/column data swapped.
+ */
+ GridItemInfo Transpose() const {
+ GridItemInfo info(mFrame, GridArea(mArea.mRows, mArea.mCols));
+ info.mState[eLogicalAxisBlock] = mState[eLogicalAxisInline];
+ info.mState[eLogicalAxisInline] = mState[eLogicalAxisBlock];
+ info.mBaselineOffset[eLogicalAxisBlock] =
+ mBaselineOffset[eLogicalAxisInline];
+ info.mBaselineOffset[eLogicalAxisInline] =
+ mBaselineOffset[eLogicalAxisBlock];
+ return info;
+ }
+
+ /** Swap the start/end sides in aAxis. */
+ inline void ReverseDirection(LogicalAxis aAxis, uint32_t aGridEnd);
+
+ // Is this item a subgrid in the given container axis?
+ bool IsSubgrid(LogicalAxis aAxis) const {
+ return mState[aAxis] & StateBits::eIsSubgrid;
+ }
+
+ // Is this item a subgrid in either axis?
+ bool IsSubgrid() const {
+ return IsSubgrid(eLogicalAxisInline) || IsSubgrid(eLogicalAxisBlock);
+ }
+
+ // Return the (inner) grid container frame associated with this subgrid item.
+ nsGridContainerFrame* SubgridFrame() const {
+ MOZ_ASSERT(IsSubgrid());
+ nsGridContainerFrame* gridFrame = GetGridContainerFrame(mFrame);
+ MOZ_ASSERT(gridFrame && gridFrame->IsSubgrid());
+ return gridFrame;
+ }
+
+ /**
+ * Adjust our grid areas to account for removed auto-fit tracks in aAxis.
+ */
+ void AdjustForRemovedTracks(LogicalAxis aAxis,
+ const nsTArray<uint32_t>& aNumRemovedTracks);
+
+ /**
+ * If the item is [align|justify]-self:[last ]baseline aligned in the given
+ * axis then set aBaselineOffset to the baseline offset and return aAlign.
+ * Otherwise, return a fallback alignment.
+ */
+ StyleAlignFlags GetSelfBaseline(StyleAlignFlags aAlign, LogicalAxis aAxis,
+ nscoord* aBaselineOffset) const {
+ MOZ_ASSERT(aAlign == StyleAlignFlags::BASELINE ||
+ aAlign == StyleAlignFlags::LAST_BASELINE);
+ if (!(mState[aAxis] & eSelfBaseline)) {
+ return aAlign == StyleAlignFlags::BASELINE ? StyleAlignFlags::SELF_START
+ : StyleAlignFlags::SELF_END;
+ }
+ *aBaselineOffset = mBaselineOffset[aAxis];
+ return aAlign;
+ }
+
+ // Return true if we should apply Automatic Minimum Size to this item.
+ // https://drafts.csswg.org/css-grid/#min-size-auto
+ // @note the caller should also check that the item spans at least one track
+ // that has a min track sizing function that is 'auto' before applying it.
+ bool ShouldApplyAutoMinSize(WritingMode aContainerWM,
+ LogicalAxis aContainerAxis,
+ nscoord aPercentageBasis) const {
+ const bool isInlineAxis = aContainerAxis == eLogicalAxisInline;
+ const auto* pos =
+ mFrame->IsTableWrapperFrame()
+ ? mFrame->PrincipalChildList().FirstChild()->StylePosition()
+ : mFrame->StylePosition();
+ const auto& size =
+ isInlineAxis ? pos->ISize(aContainerWM) : pos->BSize(aContainerWM);
+ // max-content and min-content should behave as initial value in block axis.
+ // FIXME: Bug 567039: moz-fit-content and -moz-available are not supported
+ // for block size dimension on sizing properties (e.g. height), so we
+ // treat it as `auto`.
+ bool isAuto = size.IsAuto() ||
+ (isInlineAxis ==
+ aContainerWM.IsOrthogonalTo(mFrame->GetWritingMode()) &&
+ size.BehavesLikeInitialValueOnBlockAxis());
+ // NOTE: if we have a definite size then our automatic minimum size
+ // can't affect our size. Excluding these simplifies applying
+ // the clamping in the right cases later.
+ if (!isAuto && !::IsPercentOfIndefiniteSize(size, aPercentageBasis)) {
+ return false;
+ }
+ const auto& minSize = isInlineAxis ? pos->MinISize(aContainerWM)
+ : pos->MinBSize(aContainerWM);
+ // max-content and min-content should behave as initial value in block axis.
+ // FIXME: Bug 567039: moz-fit-content and -moz-available are not supported
+ // for block size dimension on sizing properties (e.g. height), so we
+ // treat it as `auto`.
+ isAuto = minSize.IsAuto() ||
+ (isInlineAxis ==
+ aContainerWM.IsOrthogonalTo(mFrame->GetWritingMode()) &&
+ minSize.BehavesLikeInitialValueOnBlockAxis());
+ return isAuto && !mFrame->StyleDisplay()->IsScrollableOverflow();
+ }
+
+#ifdef DEBUG
+ void Dump() const;
+#endif
+
+ static bool IsStartRowLessThan(const GridItemInfo* a, const GridItemInfo* b) {
+ return a->mArea.mRows.mStart < b->mArea.mRows.mStart;
+ }
+
+ // Sorting functions for 'masonry-auto-flow:next'. We sort the items that
+ // were placed into the first track by the Grid placement algorithm first
+ // (to honor that placement). All other items will be placed by the Masonry
+ // layout algorithm (their Grid placement in the masonry axis is irrelevant).
+ static bool RowMasonryOrdered(const GridItemInfo* a, const GridItemInfo* b) {
+ return a->mArea.mRows.mStart == 0 && b->mArea.mRows.mStart != 0 &&
+ !a->mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW);
+ }
+ static bool ColMasonryOrdered(const GridItemInfo* a, const GridItemInfo* b) {
+ return a->mArea.mCols.mStart == 0 && b->mArea.mCols.mStart != 0 &&
+ !a->mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW);
+ }
+
+ // Sorting functions for 'masonry-auto-flow:definite-first'. Similar to
+ // the above, but here we also sort items with a definite item placement in
+ // the grid axis in track order before 'auto'-placed items. We also sort all
+ // continuations first since they use the same placement as their
+ // first-in-flow (we treat them as "definite" regardless of eAutoPlacement).
+ static bool RowMasonryDefiniteFirst(const GridItemInfo* a,
+ const GridItemInfo* b) {
+ bool isContinuationA = a->mFrame->GetPrevInFlow();
+ bool isContinuationB = b->mFrame->GetPrevInFlow();
+ if (isContinuationA != isContinuationB) {
+ return isContinuationA;
+ }
+ auto masonryA = a->mArea.mRows.mStart;
+ auto gridA = a->mState[eLogicalAxisInline] & StateBits::eAutoPlacement;
+ auto masonryB = b->mArea.mRows.mStart;
+ auto gridB = b->mState[eLogicalAxisInline] & StateBits::eAutoPlacement;
+ return (masonryA == 0 ? masonryB != 0 : (masonryB != 0 && gridA < gridB)) &&
+ !a->mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW);
+ }
+ static bool ColMasonryDefiniteFirst(const GridItemInfo* a,
+ const GridItemInfo* b) {
+ MOZ_ASSERT(!a->mFrame->GetPrevInFlow() && !b->mFrame->GetPrevInFlow(),
+ "fragmentation not supported in inline axis");
+ auto masonryA = a->mArea.mCols.mStart;
+ auto gridA = a->mState[eLogicalAxisBlock] & StateBits::eAutoPlacement;
+ auto masonryB = b->mArea.mCols.mStart;
+ auto gridB = b->mState[eLogicalAxisBlock] & StateBits::eAutoPlacement;
+ return (masonryA == 0 ? masonryB != 0 : (masonryB != 0 && gridA < gridB)) &&
+ !a->mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW);
+ }
+
+ // Return true if this items block size is dependent on the size of the
+ // container it is in.
+ bool IsBSizeDependentOnContainerSize(WritingMode aContainerWM) const {
+ const auto IsDependentOnContainerSize = [](const auto& size) -> bool {
+ return size.HasPercent() || size.IsMozAvailable();
+ };
+
+ const nsStylePosition* stylePos = mFrame->StylePosition();
+ bool isItemAutoSize =
+ IsDependentOnContainerSize(stylePos->BSize(aContainerWM)) ||
+ IsDependentOnContainerSize(stylePos->MinBSize(aContainerWM)) ||
+ IsDependentOnContainerSize(stylePos->MaxBSize(aContainerWM));
+
+ return isItemAutoSize;
+ }
+
+ nsIFrame* const mFrame;
+ GridArea mArea;
+
+ // Offset from the margin edge to the baseline (LogicalAxis index). It's from
+ // the start edge for first baseline sharing group, otherwise from the end
+ // edge.
+ // It's mutable since we update the value fairly late (just before reflowing
+ // the item).
+ mutable PerLogicalAxis<nscoord> mBaselineOffset;
+
+ // State bits per axis.
+ mutable PerLogicalAxis<StateBits> mState;
+};
+
+using GridItemInfo = nsGridContainerFrame::GridItemInfo;
+using ItemState = GridItemInfo::StateBits;
+MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(ItemState)
+
+GridItemInfo::GridItemInfo(nsIFrame* aFrame, const GridArea& aArea)
+ : mFrame(aFrame), mArea(aArea), mBaselineOffset{0, 0} {
+ mState[eLogicalAxisBlock] =
+ StateBits(mArea.mRows.mStart == kAutoLine ? eAutoPlacement : 0);
+ mState[eLogicalAxisInline] =
+ StateBits(mArea.mCols.mStart == kAutoLine ? eAutoPlacement : 0);
+
+ if (auto* gridFrame = GetGridContainerFrame(mFrame)) {
+ auto parentWM = aFrame->GetParent()->GetWritingMode();
+ bool isOrthogonal = parentWM.IsOrthogonalTo(gridFrame->GetWritingMode());
+ if (gridFrame->IsColSubgrid()) {
+ mState[isOrthogonal ? eLogicalAxisBlock : eLogicalAxisInline] |=
+ StateBits::eIsSubgrid;
+ }
+ if (gridFrame->IsRowSubgrid()) {
+ mState[isOrthogonal ? eLogicalAxisInline : eLogicalAxisBlock] |=
+ StateBits::eIsSubgrid;
+ }
+ }
+}
+
+void GridItemInfo::ReverseDirection(LogicalAxis aAxis, uint32_t aGridEnd) {
+ mArea.LineRangeForAxis(aAxis).ReverseDirection(aGridEnd);
+ ItemState& state = mState[aAxis];
+ ItemState newState = state & ~ItemState::eEdgeBits;
+ if (state & ItemState::eStartEdge) {
+ newState |= ItemState::eEndEdge;
+ }
+ if (state & ItemState::eEndEdge) {
+ newState |= ItemState::eStartEdge;
+ }
+ state = newState;
+}
+
+void GridItemInfo::InhibitSubgrid(nsGridContainerFrame* aParent,
+ LogicalAxis aAxis) {
+ MOZ_ASSERT(IsSubgrid(aAxis));
+ auto bit = NS_STATE_GRID_IS_COL_SUBGRID;
+ if (aParent->GetWritingMode().IsOrthogonalTo(mFrame->GetWritingMode()) !=
+ (aAxis == eLogicalAxisBlock)) {
+ bit = NS_STATE_GRID_IS_ROW_SUBGRID;
+ }
+ MOZ_ASSERT(SubgridFrame()->HasAnyStateBits(bit));
+ SubgridFrame()->RemoveStateBits(bit);
+ mState[aAxis] &= StateBits(~StateBits::eIsSubgrid);
+}
+
+void GridItemInfo::MaybeInhibitSubgridInMasonry(nsGridContainerFrame* aParent,
+ uint32_t aGridAxisTrackCount) {
+ if (IsSubgrid(eLogicalAxisInline) && aParent->IsMasonry(eLogicalAxisBlock) &&
+ mArea.mRows.mStart != 0 && mArea.mCols.Extent() != aGridAxisTrackCount &&
+ (mState[eLogicalAxisInline] & eAutoPlacement)) {
+ InhibitSubgrid(aParent, eLogicalAxisInline);
+ return;
+ }
+ if (IsSubgrid(eLogicalAxisBlock) && aParent->IsMasonry(eLogicalAxisInline) &&
+ mArea.mCols.mStart != 0 && mArea.mRows.Extent() != aGridAxisTrackCount &&
+ (mState[eLogicalAxisBlock] & eAutoPlacement)) {
+ InhibitSubgrid(aParent, eLogicalAxisBlock);
+ }
+}
+
+// Each subgrid stores this data about its items etc on a frame property.
+struct nsGridContainerFrame::Subgrid {
+ Subgrid(const GridArea& aArea, bool aIsOrthogonal, WritingMode aCBWM)
+ : mArea(aArea),
+ mGridColEnd(0),
+ mGridRowEnd(0),
+ mMarginBorderPadding(aCBWM),
+ mIsOrthogonal(aIsOrthogonal) {}
+
+ // Return the relevant line range for the subgrid column axis.
+ const LineRange& SubgridCols() const {
+ return mIsOrthogonal ? mArea.mRows : mArea.mCols;
+ }
+ // Return the relevant line range for the subgrid row axis.
+ const LineRange& SubgridRows() const {
+ return mIsOrthogonal ? mArea.mCols : mArea.mRows;
+ }
+
+ // The subgrid's items.
+ nsTArray<GridItemInfo> mGridItems;
+ // The subgrid's abs.pos. items.
+ nsTArray<GridItemInfo> mAbsPosItems;
+ // The subgrid's area as a grid item, i.e. in its parent's grid space.
+ GridArea mArea;
+ // The (inner) grid size for the subgrid, zero-based.
+ uint32_t mGridColEnd;
+ uint32_t mGridRowEnd;
+ // The margin+border+padding for the subgrid box in its parent grid's WM.
+ // (This also includes the size of any scrollbars.)
+ LogicalMargin mMarginBorderPadding;
+ // Does the subgrid frame have orthogonal writing-mode to its parent grid
+ // container?
+ bool mIsOrthogonal;
+
+ NS_DECLARE_FRAME_PROPERTY_DELETABLE(Prop, Subgrid)
+};
+using Subgrid = nsGridContainerFrame::Subgrid;
+
+void GridItemInfo::AdjustForRemovedTracks(
+ LogicalAxis aAxis, const nsTArray<uint32_t>& aNumRemovedTracks) {
+ const bool abspos = mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW);
+ auto& lines = mArea.LineRangeForAxis(aAxis);
+ if (abspos) {
+ lines.AdjustAbsPosForRemovedTracks(aNumRemovedTracks);
+ } else {
+ lines.AdjustForRemovedTracks(aNumRemovedTracks);
+ }
+ if (IsSubgrid()) {
+ auto* subgrid = SubgridFrame()->GetProperty(Subgrid::Prop());
+ if (subgrid) {
+ auto& lines = subgrid->mArea.LineRangeForAxis(aAxis);
+ if (abspos) {
+ lines.AdjustAbsPosForRemovedTracks(aNumRemovedTracks);
+ } else {
+ lines.AdjustForRemovedTracks(aNumRemovedTracks);
+ }
+ }
+ }
+}
+
+/**
+ * Track size data for use by subgrids (which don't do sizing of their own
+ * in a subgridded axis). A non-subgrid container stores its resolved sizes,
+ * but only if it has any subgrid children. A subgrid always stores one.
+ * In a subgridded axis, we copy the parent's sizes (see CopyUsedTrackSizes).
+ *
+ * This struct us stored on a frame property, which may be null before the track
+ * sizing step for the given container. A null property is semantically
+ * equivalent to mCanResolveLineRangeSize being false in both axes.
+ * @note the axis used to access this data is in the grid container's own
+ * writing-mode, same as in other track-sizing functions.
+ */
+struct nsGridContainerFrame::UsedTrackSizes {
+ UsedTrackSizes() : mCanResolveLineRangeSize{false, false} {}
+
+ /**
+ * Setup mSizes by copying track sizes from aFrame's grid container
+ * parent when aAxis is subgridded (and recurse if the parent is a subgrid
+ * that doesn't have sizes yet), or by running the Track Sizing Algo when
+ * the axis is not subgridded (for a subgrid).
+ * Set mCanResolveLineRangeSize[aAxis] to true once we have obtained
+ * sizes for an axis (if it's already true then this method is a NOP).
+ */
+ void ResolveTrackSizesForAxis(nsGridContainerFrame* aFrame, LogicalAxis aAxis,
+ gfxContext& aRC);
+
+ /** Helper function for the above method */
+ void ResolveSubgridTrackSizesForAxis(nsGridContainerFrame* aFrame,
+ LogicalAxis aAxis, Subgrid* aSubgrid,
+ gfxContext& aRC,
+ nscoord aContentBoxSize);
+
+ // This only has valid sizes when mCanResolveLineRangeSize is true in
+ // the same axis. It may have zero tracks (a grid with only abs.pos.
+ // subgrids/items may have zero tracks).
+ PerLogicalAxis<nsTArray<TrackSize>> mSizes;
+ // True if mSizes can be used to resolve line range sizes in an axis.
+ PerLogicalAxis<bool> mCanResolveLineRangeSize;
+
+ NS_DECLARE_FRAME_PROPERTY_DELETABLE(Prop, UsedTrackSizes)
+};
+using UsedTrackSizes = nsGridContainerFrame::UsedTrackSizes;
+
+#ifdef DEBUG
+void nsGridContainerFrame::GridItemInfo::Dump() const {
+ auto Dump1 = [this](const char* aMsg, LogicalAxis aAxis) {
+ auto state = mState[aAxis];
+ if (!state) {
+ return;
+ }
+ printf("%s", aMsg);
+ if (state & ItemState::eEdgeBits) {
+ printf("subgrid-adjacent-edges(");
+ if (state & ItemState::eStartEdge) {
+ printf("start ");
+ }
+ if (state & ItemState::eEndEdge) {
+ printf("end");
+ }
+ printf(") ");
+ }
+ if (state & ItemState::eAutoPlacement) {
+ printf("masonry-auto ");
+ }
+ if (state & ItemState::eIsSubgrid) {
+ printf("subgrid ");
+ }
+ if (state & ItemState::eIsFlexing) {
+ printf("flexing ");
+ }
+ if (state & ItemState::eApplyAutoMinSize) {
+ printf("auto-min-size ");
+ }
+ if (state & ItemState::eClampMarginBoxMinSize) {
+ printf("clamp ");
+ }
+ if (state & ItemState::eIsLastItemInMasonryTrack) {
+ printf("last-in-track ");
+ }
+ if (state & ItemState::eFirstBaseline) {
+ printf("first baseline %s-alignment ",
+ (state & ItemState::eSelfBaseline) ? "self" : "content");
+ }
+ if (state & ItemState::eLastBaseline) {
+ printf("last baseline %s-alignment ",
+ (state & ItemState::eSelfBaseline) ? "self" : "content");
+ }
+ if (state & ItemState::eIsBaselineAligned) {
+ printf("%.2fpx", NSAppUnitsToFloatPixels(mBaselineOffset[aAxis],
+ AppUnitsPerCSSPixel()));
+ }
+ printf("\n");
+ };
+ printf("grid-row: %d %d\n", mArea.mRows.mStart, mArea.mRows.mEnd);
+ Dump1(" grid block-axis: ", eLogicalAxisBlock);
+ printf("grid-column: %d %d\n", mArea.mCols.mStart, mArea.mCols.mEnd);
+ Dump1(" grid inline-axis: ", eLogicalAxisInline);
+}
+#endif
+
+/**
+ * Encapsulates CSS track-sizing functions.
+ */
+struct nsGridContainerFrame::TrackSizingFunctions {
+ private:
+ TrackSizingFunctions(const GridTemplate& aTemplate,
+ const StyleImplicitGridTracks& aAutoSizing,
+ const Maybe<size_t>& aRepeatAutoIndex, bool aIsSubgrid)
+ : mTemplate(aTemplate),
+ mTrackListValues(aTemplate.TrackListValues()),
+ mAutoSizing(aAutoSizing),
+ mExplicitGridOffset(0),
+ mRepeatAutoStart(aRepeatAutoIndex.valueOr(0)),
+ mRepeatAutoEnd(mRepeatAutoStart),
+ mHasRepeatAuto(aRepeatAutoIndex.isSome()) {
+ MOZ_ASSERT(!mHasRepeatAuto || !aIsSubgrid,
+ "a track-list for a subgrid can't have an <auto-repeat> track");
+ if (!aIsSubgrid) {
+ ExpandNonRepeatAutoTracks();
+ }
+
+#ifdef DEBUG
+ if (mHasRepeatAuto) {
+ MOZ_ASSERT(mExpandedTracks.Length() >= 1);
+ const unsigned maxTrack = kMaxLine - 1;
+ // If the exanded tracks are out of range of the maximum track, we
+ // can't compare the repeat-auto start. It will be removed later during
+ // grid item placement in that situation.
+ if (mExpandedTracks.Length() < maxTrack) {
+ MOZ_ASSERT(mRepeatAutoStart < mExpandedTracks.Length());
+ }
+ }
+#endif
+ }
+
+ public:
+ TrackSizingFunctions(const GridTemplate& aGridTemplate,
+ const StyleImplicitGridTracks& aAutoSizing,
+ bool aIsSubgrid)
+ : TrackSizingFunctions(aGridTemplate, aAutoSizing,
+ aGridTemplate.RepeatAutoIndex(), aIsSubgrid) {}
+
+ private:
+ enum { ForSubgridFallbackTag };
+ TrackSizingFunctions(const GridTemplate& aGridTemplate,
+ const StyleImplicitGridTracks& aAutoSizing,
+ decltype(ForSubgridFallbackTag))
+ : TrackSizingFunctions(aGridTemplate, aAutoSizing, Nothing(),
+ /* aIsSubgrid */ true) {}
+
+ public:
+ /**
+ * This is used in a subgridded axis to resolve sizes before its parent's
+ * sizes are known for intrinsic sizing purposes. It copies the slice of
+ * the nearest non-subgridded axis' track sizing functions spanned by
+ * the subgrid.
+ *
+ * FIXME: this was written before there was a spec... the spec now says:
+ * "If calculating the layout of a grid item in this step depends on
+ * the available space in the block axis, assume the available space
+ * that it would have if any row with a definite max track sizing
+ * function had that size and all other rows were infinite."
+ * https://drafts.csswg.org/css-grid-2/#subgrid-sizing
+ */
+ static TrackSizingFunctions ForSubgridFallback(
+ nsGridContainerFrame* aSubgridFrame, const Subgrid* aSubgrid,
+ nsGridContainerFrame* aParentGridContainer, LogicalAxis aParentAxis) {
+ MOZ_ASSERT(aSubgrid);
+ MOZ_ASSERT(aSubgridFrame->IsSubgrid(aSubgrid->mIsOrthogonal
+ ? GetOrthogonalAxis(aParentAxis)
+ : aParentAxis));
+ nsGridContainerFrame* parent = aParentGridContainer;
+ auto parentAxis = aParentAxis;
+ LineRange range = aSubgrid->mArea.LineRangeForAxis(parentAxis);
+ // Find our nearest non-subgridded axis and use its track sizing functions.
+ while (parent->IsSubgrid(parentAxis)) {
+ const auto* parentSubgrid = parent->GetProperty(Subgrid::Prop());
+ auto* grandParent = parent->ParentGridContainerForSubgrid();
+ auto grandParentWM = grandParent->GetWritingMode();
+ bool isSameDirInAxis =
+ parent->GetWritingMode().ParallelAxisStartsOnSameSide(parentAxis,
+ grandParentWM);
+ if (MOZ_UNLIKELY(!isSameDirInAxis)) {
+ auto end = parentAxis == eLogicalAxisBlock ? parentSubgrid->mGridRowEnd
+ : parentSubgrid->mGridColEnd;
+ range.ReverseDirection(end);
+ // range is now in the same direction as the grand-parent's axis
+ }
+ auto grandParentAxis = parentSubgrid->mIsOrthogonal
+ ? GetOrthogonalAxis(parentAxis)
+ : parentAxis;
+ const auto& parentRange =
+ parentSubgrid->mArea.LineRangeForAxis(grandParentAxis);
+ range.Translate(parentRange.mStart);
+ // range is now in the grand-parent's coordinates
+ parentAxis = grandParentAxis;
+ parent = grandParent;
+ }
+ const auto* pos = parent->StylePosition();
+ const auto isInlineAxis = parentAxis == eLogicalAxisInline;
+ const auto& szf =
+ isInlineAxis ? pos->mGridTemplateRows : pos->mGridTemplateColumns;
+ const auto& autoSizing =
+ isInlineAxis ? pos->mGridAutoColumns : pos->mGridAutoRows;
+ return TrackSizingFunctions(szf, autoSizing, ForSubgridFallbackTag);
+ }
+
+ /**
+ * Initialize the number of auto-fill/fit tracks to use.
+ * This can be zero if no auto-fill/fit track was specified, or if the repeat
+ * begins after the maximum allowed track.
+ */
+ void InitRepeatTracks(const NonNegativeLengthPercentageOrNormal& aGridGap,
+ nscoord aMinSize, nscoord aSize, nscoord aMaxSize) {
+ const uint32_t maxTrack = kMaxLine - 1;
+ // Check for a repeat after the maximum allowed track.
+ if (MOZ_UNLIKELY(mRepeatAutoStart >= maxTrack)) {
+ mHasRepeatAuto = false;
+ mRepeatAutoStart = 0;
+ mRepeatAutoEnd = 0;
+ return;
+ }
+ uint32_t repeatTracks =
+ CalculateRepeatFillCount(aGridGap, aMinSize, aSize, aMaxSize) *
+ NumRepeatTracks();
+ // Clamp the number of repeat tracks to the maximum possible track.
+ repeatTracks = std::min(repeatTracks, maxTrack - mRepeatAutoStart);
+ SetNumRepeatTracks(repeatTracks);
+ // Blank out the removed flags for each of these tracks.
+ mRemovedRepeatTracks.SetLength(repeatTracks);
+ for (auto& track : mRemovedRepeatTracks) {
+ track = false;
+ }
+ }
+
+ uint32_t CalculateRepeatFillCount(
+ const NonNegativeLengthPercentageOrNormal& aGridGap, nscoord aMinSize,
+ nscoord aSize, nscoord aMaxSize) const {
+ if (!mHasRepeatAuto) {
+ return 0;
+ }
+ // At this point no tracks will have been collapsed, so the RepeatEndDelta
+ // should not be negative.
+ MOZ_ASSERT(RepeatEndDelta() >= 0);
+ // Note that this uses NumRepeatTracks and mRepeatAutoStart/End, although
+ // the result of this method is used to change those values to a fully
+ // expanded value. Spec quotes are from
+ // https://drafts.csswg.org/css-grid/#repeat-notation
+ const uint32_t numTracks = mExpandedTracks.Length() + RepeatEndDelta();
+ MOZ_ASSERT(numTracks >= 1, "expected at least the repeat() track");
+ if (MOZ_UNLIKELY(numTracks >= kMaxLine)) {
+ // The fixed tracks plus an entire repetition is either larger or as
+ // large as the maximum track, so we do not need to measure how many
+ // repetitions will fit. This also avoids needing to check for if
+ // kMaxLine - numTracks would underflow at the end where we clamp the
+ // result.
+ return 1;
+ }
+ nscoord maxFill = aSize != NS_UNCONSTRAINEDSIZE ? aSize : aMaxSize;
+ if (maxFill == NS_UNCONSTRAINEDSIZE && aMinSize == 0) {
+ // "Otherwise, the specified track list repeats only once."
+ return 1;
+ }
+ nscoord repeatTrackSum = 0;
+ // Note that one repeat() track size is included in |sum| in this loop.
+ nscoord sum = 0;
+ const nscoord percentBasis = aSize;
+ for (uint32_t i = 0; i < numTracks; ++i) {
+ // "treating each track as its max track sizing function if that is
+ // definite or as its minimum track sizing function otherwise"
+ // https://drafts.csswg.org/css-grid/#valdef-repeat-auto-fill
+ const auto& sizingFunction = SizingFor(i);
+ const auto& maxCoord = sizingFunction.GetMax();
+ const auto* coord = &maxCoord;
+ if (!coord->IsBreadth()) {
+ coord = &sizingFunction.GetMin();
+ if (!coord->IsBreadth()) {
+ return 1;
+ }
+ }
+ nscoord trackSize = ::ResolveToDefiniteSize(*coord, percentBasis);
+ if (i >= mRepeatAutoStart && i < mRepeatAutoEnd) {
+ // Use a minimum 1px for the repeat() track-size.
+ if (trackSize < AppUnitsPerCSSPixel()) {
+ trackSize = AppUnitsPerCSSPixel();
+ }
+ repeatTrackSum += trackSize;
+ }
+ sum += trackSize;
+ }
+ nscoord gridGap = nsLayoutUtils::ResolveGapToLength(aGridGap, aSize);
+ if (numTracks > 1) {
+ // Add grid-gaps for all the tracks including the repeat() track.
+ sum += gridGap * (numTracks - 1);
+ }
+ // Calculate the max number of tracks that fits without overflow.
+ nscoord available = maxFill != NS_UNCONSTRAINEDSIZE ? maxFill : aMinSize;
+ nscoord spaceToFill = available - sum;
+ if (spaceToFill <= 0) {
+ // "if any number of repetitions would overflow, then 1 repetition"
+ return 1;
+ }
+ // Calculate the max number of tracks that fits without overflow.
+ // Since we already have one repetition in sum, we can simply add one grid
+ // gap for each element in the repeat.
+ div_t q = div(spaceToFill, repeatTrackSum + gridGap * NumRepeatTracks());
+ // The +1 here is for the one repeat track we already accounted for above.
+ uint32_t numRepeatTracks = q.quot + 1;
+ if (q.rem != 0 && maxFill == NS_UNCONSTRAINEDSIZE) {
+ // "Otherwise, if the grid container has a definite min size in
+ // the relevant axis, the number of repetitions is the largest possible
+ // positive integer that fulfills that minimum requirement."
+ ++numRepeatTracks; // one more to ensure the grid is at least min-size
+ }
+ // Clamp the number of repeat tracks so that the last line <= kMaxLine.
+ // (note that |numTracks| already includes one repeat() track)
+ MOZ_ASSERT(numTracks >= NumRepeatTracks());
+ const uint32_t maxRepeatTrackCount = kMaxLine - numTracks;
+ const uint32_t maxRepetitions = maxRepeatTrackCount / NumRepeatTracks();
+ return std::min(numRepeatTracks, maxRepetitions);
+ }
+
+ /**
+ * Compute the explicit grid end line number (in a zero-based grid).
+ * @param aGridTemplateAreasEnd 'grid-template-areas' end line in this axis
+ */
+ uint32_t ComputeExplicitGridEnd(uint32_t aGridTemplateAreasEnd) {
+ uint32_t end = NumExplicitTracks() + 1;
+ end = std::max(end, aGridTemplateAreasEnd);
+ end = std::min(end, uint32_t(kMaxLine));
+ return end;
+ }
+ const StyleTrackSize& SizingFor(uint32_t aTrackIndex) const {
+ static const StyleTrackSize kAutoTrackSize =
+ StyleTrackSize::Breadth(StyleTrackBreadth::Auto());
+ // |aIndex| is the relative index to mAutoSizing. A negative value means it
+ // is the last Nth element.
+ auto getImplicitSize = [this](int32_t aIndex) -> const StyleTrackSize& {
+ MOZ_ASSERT(!(mAutoSizing.Length() == 1 &&
+ mAutoSizing.AsSpan()[0] == kAutoTrackSize),
+ "It's impossible to have one track with auto value because we "
+ "filter out this case during parsing");
+
+ if (mAutoSizing.IsEmpty()) {
+ return kAutoTrackSize;
+ }
+
+ // If multiple track sizes are given, the pattern is repeated as necessary
+ // to find the size of the implicit tracks.
+ int32_t i = aIndex % int32_t(mAutoSizing.Length());
+ if (i < 0) {
+ i += mAutoSizing.Length();
+ }
+ return mAutoSizing.AsSpan()[i];
+ };
+
+ if (MOZ_UNLIKELY(aTrackIndex < mExplicitGridOffset)) {
+ // The last implicit grid track before the explicit grid receives the
+ // last specified size, and so on backwards. Therefore we pass the
+ // negative relative index to imply that we should get the implicit size
+ // from the last Nth specified grid auto size.
+ return getImplicitSize(int32_t(aTrackIndex) -
+ int32_t(mExplicitGridOffset));
+ }
+ uint32_t index = aTrackIndex - mExplicitGridOffset;
+ MOZ_ASSERT(mRepeatAutoStart <= mRepeatAutoEnd);
+
+ if (index >= mRepeatAutoStart) {
+ if (index < mRepeatAutoEnd) {
+ // Expand the repeat tracks.
+ const auto& indices = mExpandedTracks[mRepeatAutoStart];
+ const TrackListValue& value = mTrackListValues[indices.first];
+
+ // We expect the default to be used for all track repeats.
+ MOZ_ASSERT(indices.second == 0);
+
+ const auto& repeatTracks = value.AsTrackRepeat().track_sizes.AsSpan();
+
+ // Find the repeat track to use, skipping over any collapsed tracks.
+ const uint32_t finalRepeatIndex = (index - mRepeatAutoStart);
+ uint32_t repeatWithCollapsed = 0;
+ // NOTE: We need SizingFor before the final collapsed tracks are known.
+ // We know that it's invalid to have empty mRemovedRepeatTracks when
+ // there are any repeat tracks, so we can detect that situation here.
+ if (mRemovedRepeatTracks.IsEmpty()) {
+ repeatWithCollapsed = finalRepeatIndex;
+ } else {
+ // Count up through the repeat tracks, until we have seen
+ // finalRepeatIndex number of non-collapsed tracks.
+ for (uint32_t repeatNoCollapsed = 0;
+ repeatNoCollapsed < finalRepeatIndex; repeatWithCollapsed++) {
+ if (!mRemovedRepeatTracks[repeatWithCollapsed]) {
+ repeatNoCollapsed++;
+ }
+ }
+ // If we stopped iterating on a collapsed track, continue to the next
+ // non-collapsed track.
+ while (mRemovedRepeatTracks[repeatWithCollapsed]) {
+ repeatWithCollapsed++;
+ }
+ }
+ return repeatTracks[repeatWithCollapsed % repeatTracks.Length()];
+ } else {
+ // The index is after the repeat auto range, adjust it to skip over the
+ // repeat value. This will have no effect if there is no auto repeat,
+ // since then RepeatEndDelta will return zero.
+ index -= RepeatEndDelta();
+ }
+ }
+ if (index >= mExpandedTracks.Length()) {
+ return getImplicitSize(index - mExpandedTracks.Length());
+ }
+ auto& indices = mExpandedTracks[index];
+ const TrackListValue& value = mTrackListValues[indices.first];
+ if (value.IsTrackSize()) {
+ MOZ_ASSERT(indices.second == 0);
+ return value.AsTrackSize();
+ }
+ return value.AsTrackRepeat().track_sizes.AsSpan()[indices.second];
+ }
+ const StyleTrackBreadth& MaxSizingFor(uint32_t aTrackIndex) const {
+ return SizingFor(aTrackIndex).GetMax();
+ }
+ const StyleTrackBreadth& MinSizingFor(uint32_t aTrackIndex) const {
+ return SizingFor(aTrackIndex).GetMin();
+ }
+ uint32_t NumExplicitTracks() const {
+ return mExpandedTracks.Length() + RepeatEndDelta();
+ }
+ uint32_t NumRepeatTracks() const { return mRepeatAutoEnd - mRepeatAutoStart; }
+ // The difference between mExplicitGridEnd and mSizingFunctions.Length().
+ int32_t RepeatEndDelta() const {
+ return mHasRepeatAuto ? int32_t(NumRepeatTracks()) - 1 : 0;
+ }
+ void SetNumRepeatTracks(uint32_t aNumRepeatTracks) {
+ MOZ_ASSERT(mHasRepeatAuto || aNumRepeatTracks == 0);
+ mRepeatAutoEnd = mRepeatAutoStart + aNumRepeatTracks;
+ }
+
+ // Store mTrackListValues into mExpandedTracks with `repeat(INTEGER, ...)`
+ // tracks expanded.
+ void ExpandNonRepeatAutoTracks() {
+ for (size_t i = 0; i < mTrackListValues.Length(); ++i) {
+ auto& value = mTrackListValues[i];
+ if (value.IsTrackSize()) {
+ mExpandedTracks.EmplaceBack(i, 0);
+ continue;
+ }
+ auto& repeat = value.AsTrackRepeat();
+ if (!repeat.count.IsNumber()) {
+ MOZ_ASSERT(i == mRepeatAutoStart);
+ mRepeatAutoStart = mExpandedTracks.Length();
+ mRepeatAutoEnd = mRepeatAutoStart + repeat.track_sizes.Length();
+ mExpandedTracks.EmplaceBack(i, 0);
+ continue;
+ }
+ for (auto j : IntegerRange(repeat.count.AsNumber())) {
+ Unused << j;
+ size_t trackSizesCount = repeat.track_sizes.Length();
+ for (auto k : IntegerRange(trackSizesCount)) {
+ mExpandedTracks.EmplaceBack(i, k);
+ }
+ }
+ }
+ if (MOZ_UNLIKELY(mExpandedTracks.Length() > kMaxLine - 1)) {
+ mExpandedTracks.TruncateLength(kMaxLine - 1);
+ if (mHasRepeatAuto && mRepeatAutoStart > kMaxLine - 1) {
+ // The `repeat(auto-fill/fit)` track is outside the clamped grid.
+ mHasRepeatAuto = false;
+ }
+ }
+ }
+
+ // Some style data references, for easy access.
+ const GridTemplate& mTemplate;
+ const Span<const TrackListValue> mTrackListValues;
+ const StyleImplicitGridTracks& mAutoSizing;
+ // An array from expanded track sizes (without expanding auto-repeat, which is
+ // included just once at `mRepeatAutoStart`).
+ //
+ // Each entry contains two indices, the first into mTrackListValues, and a
+ // second one inside mTrackListValues' repeat value, if any, or zero
+ // otherwise.
+ nsTArray<std::pair<size_t, size_t>> mExpandedTracks;
+ // Offset from the start of the implicit grid to the first explicit track.
+ uint32_t mExplicitGridOffset;
+ // The index of the repeat(auto-fill/fit) track, or zero if there is none.
+ // Relative to mExplicitGridOffset (repeat tracks are explicit by definition).
+ uint32_t mRepeatAutoStart;
+ // The (hypothetical) index of the last such repeat() track.
+ uint32_t mRepeatAutoEnd;
+ // True if there is a specified repeat(auto-fill/fit) track.
+ bool mHasRepeatAuto;
+ // True if this track (relative to mRepeatAutoStart) is a removed auto-fit.
+ // Indexed relative to mExplicitGridOffset + mRepeatAutoStart.
+ nsTArray<bool> mRemovedRepeatTracks;
+};
+
+/**
+ * Utility class to find line names. It provides an interface to lookup line
+ * names with a dynamic number of repeat(auto-fill/fit) tracks taken into
+ * account.
+ */
+class MOZ_STACK_CLASS nsGridContainerFrame::LineNameMap {
+ public:
+ /**
+ * Create a LineNameMap.
+ * @param aStylePosition the style for the grid container
+ * @param aImplicitNamedAreas the implicit areas for the grid container
+ * @param aGridTemplate is the grid-template-rows/columns data for this axis
+ * @param aParentLineNameMap the parent grid's map parallel to this map, or
+ * null if this map isn't for a subgrid
+ * @param aRange the subgrid's range in the parent grid, or null
+ * @param aIsSameDirection true if our axis progresses in the same direction
+ * in the subgrid and parent
+ */
+ LineNameMap(const nsStylePosition* aStylePosition,
+ const ImplicitNamedAreas* aImplicitNamedAreas,
+ const TrackSizingFunctions& aTracks,
+ const LineNameMap* aParentLineNameMap, const LineRange* aRange,
+ bool aIsSameDirection)
+ : mStylePosition(aStylePosition),
+ mAreas(aImplicitNamedAreas),
+ mRepeatAutoStart(aTracks.mRepeatAutoStart),
+ mRepeatAutoEnd(aTracks.mRepeatAutoEnd),
+ mRepeatEndDelta(aTracks.RepeatEndDelta()),
+ mParentLineNameMap(aParentLineNameMap),
+ mRange(aRange),
+ mIsSameDirection(aIsSameDirection),
+ mHasRepeatAuto(aTracks.mHasRepeatAuto) {
+ if (MOZ_UNLIKELY(aRange)) { // subgrid case
+ mClampMinLine = 1;
+ mClampMaxLine = 1 + aRange->Extent();
+ MOZ_ASSERT(aTracks.mTemplate.IsSubgrid(), "Should be subgrid type");
+ ExpandRepeatLineNamesForSubgrid(*aTracks.mTemplate.AsSubgrid());
+ // we've expanded all subgrid auto-fill lines in
+ // ExpandRepeatLineNamesForSubgrid()
+ mRepeatAutoStart = 0;
+ mRepeatAutoEnd = mRepeatAutoStart;
+ mHasRepeatAuto = false;
+ } else {
+ mClampMinLine = kMinLine;
+ mClampMaxLine = kMaxLine;
+ if (mHasRepeatAuto) {
+ mTrackAutoRepeatLineNames =
+ aTracks.mTemplate.GetRepeatAutoValue()->line_names.AsSpan();
+ }
+ ExpandRepeatLineNames(aTracks);
+ }
+ if (mHasRepeatAuto) {
+ // We need mTemplateLinesEnd to be after all line names.
+ // mExpandedLineNames has one repetition of the repeat(auto-fit/fill)
+ // track name lists already, so we must subtract the number of repeat
+ // track name lists to get to the number of non-repeat tracks, minus 2
+ // because the first and last line name lists are shared with the
+ // preceding and following non-repeat line name lists. We then add
+ // mRepeatEndDelta to include the interior line name lists from repeat
+ // tracks.
+ mTemplateLinesEnd = mExpandedLineNames.Length() -
+ (mTrackAutoRepeatLineNames.Length() - 2) +
+ mRepeatEndDelta;
+ } else {
+ mTemplateLinesEnd = mExpandedLineNames.Length();
+ }
+ MOZ_ASSERT(mHasRepeatAuto || mRepeatEndDelta <= 0);
+ MOZ_ASSERT(!mHasRepeatAuto || aRange ||
+ (mExpandedLineNames.Length() >= 2 &&
+ mRepeatAutoStart <= mExpandedLineNames.Length()));
+ }
+
+ // Store line names into mExpandedLineNames with `repeat(INTEGER, ...)`
+ // expanded for non-subgrid.
+ void ExpandRepeatLineNames(const TrackSizingFunctions& aTracks) {
+ auto lineNameLists = aTracks.mTemplate.LineNameLists(false);
+
+ const auto& trackListValues = aTracks.mTrackListValues;
+ const NameList* nameListToMerge = nullptr;
+ // NOTE(emilio): We rely on std::move clearing out the array.
+ SmallPointerArray<const NameList> names;
+ const uint32_t end =
+ std::min<uint32_t>(lineNameLists.Length(), mClampMaxLine + 1);
+ for (uint32_t i = 0; i < end; ++i) {
+ if (nameListToMerge) {
+ names.AppendElement(nameListToMerge);
+ nameListToMerge = nullptr;
+ }
+ names.AppendElement(&lineNameLists[i]);
+ if (i >= trackListValues.Length()) {
+ mExpandedLineNames.AppendElement(std::move(names));
+ continue;
+ }
+ const auto& value = trackListValues[i];
+ if (value.IsTrackSize()) {
+ mExpandedLineNames.AppendElement(std::move(names));
+ continue;
+ }
+ const auto& repeat = value.AsTrackRepeat();
+ if (!repeat.count.IsNumber()) {
+ const auto repeatNames = repeat.line_names.AsSpan();
+ // If the repeat was truncated due to more than kMaxLine tracks, then
+ // the repeat will no longer be set on mRepeatAutoStart).
+ MOZ_ASSERT(!mHasRepeatAuto ||
+ mRepeatAutoStart == mExpandedLineNames.Length());
+ MOZ_ASSERT(repeatNames.Length() >= 2);
+ for (const auto j : IntegerRange(repeatNames.Length() - 1)) {
+ names.AppendElement(&repeatNames[j]);
+ mExpandedLineNames.AppendElement(std::move(names));
+ }
+ nameListToMerge = &repeatNames[repeatNames.Length() - 1];
+ continue;
+ }
+ for (auto j : IntegerRange(repeat.count.AsNumber())) {
+ Unused << j;
+ if (nameListToMerge) {
+ names.AppendElement(nameListToMerge);
+ nameListToMerge = nullptr;
+ }
+ size_t trackSizesCount = repeat.track_sizes.Length();
+ auto repeatLineNames = repeat.line_names.AsSpan();
+ MOZ_ASSERT(repeatLineNames.Length() == trackSizesCount ||
+ repeatLineNames.Length() == trackSizesCount + 1);
+ for (auto k : IntegerRange(trackSizesCount)) {
+ names.AppendElement(&repeatLineNames[k]);
+ mExpandedLineNames.AppendElement(std::move(names));
+ }
+ if (repeatLineNames.Length() == trackSizesCount + 1) {
+ nameListToMerge = &repeatLineNames[trackSizesCount];
+ }
+ }
+ }
+
+ if (MOZ_UNLIKELY(mExpandedLineNames.Length() > uint32_t(mClampMaxLine))) {
+ mExpandedLineNames.TruncateLength(mClampMaxLine);
+ }
+ }
+
+ // Store line names into mExpandedLineNames with `repeat(INTEGER, ...)`
+ // expanded, and all `repeat(...)` expanded for subgrid.
+ // https://drafts.csswg.org/css-grid/#resolved-track-list-subgrid
+ void ExpandRepeatLineNamesForSubgrid(
+ const StyleGenericLineNameList<StyleInteger>& aStyleLineNameList) {
+ const auto& lineNameList = aStyleLineNameList.line_names.AsSpan();
+ const uint32_t maxCount = mClampMaxLine + 1;
+ const uint32_t end = lineNameList.Length();
+ for (uint32_t i = 0; i < end && mExpandedLineNames.Length() < maxCount;
+ ++i) {
+ const auto& item = lineNameList[i];
+ if (item.IsLineNames()) {
+ // <line-names> case. Just copy it.
+ SmallPointerArray<const NameList> names;
+ names.AppendElement(&item.AsLineNames());
+ mExpandedLineNames.AppendElement(std::move(names));
+ continue;
+ }
+
+ MOZ_ASSERT(item.IsRepeat());
+ const auto& repeat = item.AsRepeat();
+ const auto repeatLineNames = repeat.line_names.AsSpan();
+
+ if (repeat.count.IsNumber()) {
+ // Clone all <line-names>+ (repeated by N) into
+ // |mExpandedLineNames|.
+ for (uint32_t repeatCount = 0;
+ repeatCount < (uint32_t)repeat.count.AsNumber(); ++repeatCount) {
+ for (const NameList& lineNames : repeatLineNames) {
+ SmallPointerArray<const NameList> names;
+ names.AppendElement(&lineNames);
+ mExpandedLineNames.AppendElement(std::move(names));
+ if (mExpandedLineNames.Length() >= maxCount) {
+ break;
+ }
+ }
+ }
+ continue;
+ }
+
+ MOZ_ASSERT(repeat.count.IsAutoFill(),
+ "RepeatCount of subgrid is number or auto-fill");
+
+ const size_t fillLen = repeatLineNames.Length();
+ const int32_t extraAutoFillLineCount =
+ mClampMaxLine -
+ (int32_t)aStyleLineNameList.expanded_line_names_length;
+ // Maximum possible number of repeat name lists.
+ // Note: |expanded_line_names_length| doesn't include auto repeat.
+ const uint32_t possibleRepeatLength =
+ std::max<int32_t>(0, extraAutoFillLineCount);
+ const uint32_t repeatRemainder = possibleRepeatLength % fillLen;
+
+ // Note: Expand 'auto-fill' names for subgrid for now since
+ // HasNameAt() only deals with auto-repeat **tracks** currently.
+ const size_t len = possibleRepeatLength - repeatRemainder;
+ for (size_t j = 0; j < len; ++j) {
+ SmallPointerArray<const NameList> names;
+ names.AppendElement(&repeatLineNames[j % fillLen]);
+ mExpandedLineNames.AppendElement(std::move(names));
+ if (mExpandedLineNames.Length() >= maxCount) {
+ break;
+ }
+ }
+ }
+
+ if (MOZ_UNLIKELY(mExpandedLineNames.Length() > uint32_t(mClampMaxLine))) {
+ mExpandedLineNames.TruncateLength(mClampMaxLine);
+ }
+ }
+
+ /**
+ * Find the aNth occurrence of aName, searching forward if aNth is positive,
+ * and in reverse if aNth is negative (aNth == 0 is invalid), starting from
+ * aFromIndex (not inclusive), and return a 1-based line number.
+ * Also take into account there is an unconditional match at the lines in
+ * aImplicitLines.
+ * Return zero if aNth occurrences can't be found. In that case, aNth has
+ * been decremented with the number of occurrences that were found (if any).
+ *
+ * E.g. to search for "A 2" forward from the start of the grid: aName is "A"
+ * aNth is 2 and aFromIndex is zero. To search for "A -2", aNth is -2 and
+ * aFromIndex is ExplicitGridEnd + 1 (which is the line "before" the last
+ * line when we're searching in reverse). For "span A 2", aNth is 2 when
+ * used on a grid-[row|column]-end property and -2 for a *-start property,
+ * and aFromIndex is the line (which we should skip) on the opposite property.
+ */
+ uint32_t FindNamedLine(nsAtom* aName, int32_t* aNth, uint32_t aFromIndex,
+ const nsTArray<uint32_t>& aImplicitLines) const {
+ MOZ_ASSERT(aName);
+ MOZ_ASSERT(!aName->IsEmpty());
+ MOZ_ASSERT(aNth && *aNth != 0);
+ if (*aNth > 0) {
+ return FindLine(aName, aNth, aFromIndex, aImplicitLines);
+ }
+ int32_t nth = -*aNth;
+ int32_t line = RFindLine(aName, &nth, aFromIndex, aImplicitLines);
+ *aNth = -nth;
+ return line;
+ }
+
+ /**
+ * Return a set of lines in aImplicitLines which matches the area name aName
+ * on aSide. For example, for aName "a" and aSide being an end side, it
+ * returns the line numbers which would match "a-end" in the relevant axis.
+ * For subgrids it includes searching the relevant axis in all ancestor
+ * grids too (within this subgrid's spanned area). If an ancestor has
+ * opposite direction, we switch aSide to the opposite logical side so we
+ * match on the same physical side as the original subgrid we're resolving
+ * the name for.
+ */
+ void FindNamedAreas(nsAtom* aName, LogicalSide aSide,
+ nsTArray<uint32_t>& aImplicitLines) const {
+ // True if we're currently in a map that has the same direction as 'this'.
+ bool sameDirectionAsThis = true;
+ uint32_t min = !mParentLineNameMap ? 1 : mClampMinLine;
+ uint32_t max = mClampMaxLine;
+ for (auto* map = this; true;) {
+ uint32_t line = map->FindNamedArea(aName, aSide, min, max);
+ if (line > 0) {
+ if (MOZ_LIKELY(sameDirectionAsThis)) {
+ line -= min - 1;
+ } else {
+ line = max - line + 1;
+ }
+ aImplicitLines.AppendElement(line);
+ }
+ auto* parent = map->mParentLineNameMap;
+ if (!parent) {
+ if (MOZ_UNLIKELY(aImplicitLines.Length() > 1)) {
+ // Remove duplicates and sort in ascending order.
+ aImplicitLines.Sort();
+ for (size_t i = 0; i < aImplicitLines.Length(); ++i) {
+ uint32_t prev = aImplicitLines[i];
+ auto j = i + 1;
+ const auto start = j;
+ while (j < aImplicitLines.Length() && aImplicitLines[j] == prev) {
+ ++j;
+ }
+ if (j != start) {
+ aImplicitLines.RemoveElementsAt(start, j - start);
+ }
+ }
+ }
+ return;
+ }
+ if (MOZ_UNLIKELY(!map->mIsSameDirection)) {
+ aSide = GetOppositeSide(aSide);
+ sameDirectionAsThis = !sameDirectionAsThis;
+ }
+ min = map->TranslateToParentMap(min);
+ max = map->TranslateToParentMap(max);
+ if (min > max) {
+ MOZ_ASSERT(!map->mIsSameDirection);
+ std::swap(min, max);
+ }
+ map = parent;
+ }
+ }
+
+ /**
+ * Return true if any implicit named areas match aName, in this map or
+ * in any of our ancestor maps.
+ */
+ bool HasImplicitNamedArea(nsAtom* aName) const {
+ const auto* map = this;
+ do {
+ if (map->mAreas && map->mAreas->has(aName)) {
+ return true;
+ }
+ map = map->mParentLineNameMap;
+ } while (map);
+ return false;
+ }
+
+ // For generating line name data for devtools.
+ nsTArray<nsTArray<StyleCustomIdent>>
+ GetResolvedLineNamesForComputedGridTrackInfo() const {
+ nsTArray<nsTArray<StyleCustomIdent>> result;
+ for (auto& expandedLine : mExpandedLineNames) {
+ nsTArray<StyleCustomIdent> line;
+ for (auto* chunk : expandedLine) {
+ for (auto& name : chunk->AsSpan()) {
+ line.AppendElement(name);
+ }
+ }
+ result.AppendElement(std::move(line));
+ }
+ return result;
+ }
+
+ nsTArray<RefPtr<nsAtom>> GetExplicitLineNamesAtIndex(uint32_t aIndex) const {
+ nsTArray<RefPtr<nsAtom>> lineNames;
+ if (aIndex < mTemplateLinesEnd) {
+ const auto nameLists = GetLineNamesAt(aIndex);
+ for (const NameList* nameList : nameLists) {
+ for (const auto& name : nameList->AsSpan()) {
+ lineNames.AppendElement(name.AsAtom());
+ }
+ }
+ }
+ return lineNames;
+ }
+
+ const nsTArray<SmallPointerArray<const NameList>>& ExpandedLineNames() const {
+ return mExpandedLineNames;
+ }
+ const Span<const StyleOwnedSlice<StyleCustomIdent>>&
+ TrackAutoRepeatLineNames() const {
+ return mTrackAutoRepeatLineNames;
+ }
+ bool HasRepeatAuto() const { return mHasRepeatAuto; }
+ uint32_t NumRepeatTracks() const { return mRepeatAutoEnd - mRepeatAutoStart; }
+ uint32_t RepeatAutoStart() const { return mRepeatAutoStart; }
+
+ // The min/max line number (1-based) for clamping.
+ int32_t mClampMinLine;
+ int32_t mClampMaxLine;
+
+ private:
+ // Return true if this map represents a subgridded axis.
+ bool IsSubgridded() const { return mParentLineNameMap != nullptr; }
+
+ /**
+ * @see FindNamedLine, this function searches forward.
+ */
+ uint32_t FindLine(nsAtom* aName, int32_t* aNth, uint32_t aFromIndex,
+ const nsTArray<uint32_t>& aImplicitLines) const {
+ MOZ_ASSERT(aNth && *aNth > 0);
+ int32_t nth = *aNth;
+ // For a subgrid we need to search to the end of the grid rather than
+ // the end of the local name list, since ancestors might match.
+ const uint32_t end = IsSubgridded() ? mClampMaxLine : mTemplateLinesEnd;
+ uint32_t line;
+ uint32_t i = aFromIndex;
+ for (; i < end; i = line) {
+ line = i + 1;
+ if (Contains(i, aName) || aImplicitLines.Contains(line)) {
+ if (--nth == 0) {
+ return line;
+ }
+ }
+ }
+ for (auto implicitLine : aImplicitLines) {
+ if (implicitLine > i) {
+ // implicitLine is after the lines we searched above so it's last.
+ // (grid-template-areas has more tracks than
+ // grid-template-[rows|columns])
+ if (--nth == 0) {
+ return implicitLine;
+ }
+ }
+ }
+ MOZ_ASSERT(nth > 0, "should have returned a valid line above already");
+ *aNth = nth;
+ return 0;
+ }
+
+ /**
+ * @see FindNamedLine, this function searches in reverse.
+ */
+ uint32_t RFindLine(nsAtom* aName, int32_t* aNth, uint32_t aFromIndex,
+ const nsTArray<uint32_t>& aImplicitLines) const {
+ MOZ_ASSERT(aNth && *aNth > 0);
+ if (MOZ_UNLIKELY(aFromIndex == 0)) {
+ return 0; // There are no named lines beyond the start of the explicit
+ // grid.
+ }
+ --aFromIndex; // (shift aFromIndex so we can treat it as inclusive)
+ int32_t nth = *aNth;
+ // Implicit lines may be beyond the explicit grid so we match those
+ // first if it's within the mTemplateLinesEnd..aFromIndex range.
+ // aImplicitLines is presumed sorted.
+ // For a subgrid we need to search to the end of the grid rather than
+ // the end of the local name list, since ancestors might match.
+ const uint32_t end = IsSubgridded() ? mClampMaxLine : mTemplateLinesEnd;
+ for (auto implicitLine : Reversed(aImplicitLines)) {
+ if (implicitLine <= end) {
+ break;
+ }
+ if (implicitLine < aFromIndex) {
+ if (--nth == 0) {
+ return implicitLine;
+ }
+ }
+ }
+ for (uint32_t i = std::min(aFromIndex, end); i; --i) {
+ if (Contains(i - 1, aName) || aImplicitLines.Contains(i)) {
+ if (--nth == 0) {
+ return i;
+ }
+ }
+ }
+ MOZ_ASSERT(nth > 0, "should have returned a valid line above already");
+ *aNth = nth;
+ return 0;
+ }
+
+ // Return true if aName exists at aIndex in this map or any parent map.
+ bool Contains(uint32_t aIndex, nsAtom* aName) const {
+ const auto* map = this;
+ while (true) {
+ if (aIndex < map->mTemplateLinesEnd && map->HasNameAt(aIndex, aName)) {
+ return true;
+ }
+ auto* parent = map->mParentLineNameMap;
+ if (!parent) {
+ return false;
+ }
+ uint32_t line = map->TranslateToParentMap(aIndex + 1);
+ MOZ_ASSERT(line >= 1, "expected a 1-based line number");
+ aIndex = line - 1;
+ map = parent;
+ }
+ MOZ_ASSERT_UNREACHABLE("we always return from inside the loop above");
+ }
+
+ static bool Contains(Span<const StyleCustomIdent> aNames, nsAtom* aName) {
+ for (auto& name : aNames) {
+ if (name.AsAtom() == aName) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ // Return true if aName exists at aIndex in this map.
+ bool HasNameAt(const uint32_t aIndex, nsAtom* const aName) const {
+ const auto nameLists = GetLineNamesAt(aIndex);
+ for (const NameList* nameList : nameLists) {
+ if (Contains(nameList->AsSpan(), aName)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ // Get the line names at an index.
+ // This accounts for auto repeat. The results may be spread over multiple name
+ // lists returned in the array, which is done to avoid unneccessarily copying
+ // the arrays to concatenate them.
+ SmallPointerArray<const NameList> GetLineNamesAt(
+ const uint32_t aIndex) const {
+ SmallPointerArray<const NameList> names;
+ // The index into mExpandedLineNames to use, if aIndex doesn't point to a
+ // name inside of a auto repeat.
+ uint32_t repeatAdjustedIndex = aIndex;
+ // Note: For subgrid, |mHasRepeatAuto| is always false because we have
+ // expanded it in the constructor of LineNameMap.
+ if (mHasRepeatAuto) {
+ // If the index is inside of the auto repeat, use the repeat line
+ // names. Otherwise, if the index is past the end of the repeat it must
+ // be adjusted to acount for the repeat tracks.
+ // mExpandedLineNames has the first and last line name lists from the
+ // repeat in it already, so we can just ignore aIndex == mRepeatAutoStart
+ // and treat when aIndex == mRepeatAutoEnd the same as any line after the
+ // the repeat.
+ const uint32_t maxRepeatLine = mTrackAutoRepeatLineNames.Length() - 1;
+ if (aIndex > mRepeatAutoStart && aIndex < mRepeatAutoEnd) {
+ // The index is inside the auto repeat. Calculate the lines to use,
+ // including the previous repetitions final names when we roll over
+ // from one repetition to the next.
+ const uint32_t repeatIndex =
+ (aIndex - mRepeatAutoStart) % maxRepeatLine;
+ if (repeatIndex == 0) {
+ // The index is at the start of a new repetition. The start of the
+ // first repetition is intentionally ignored above, so this will
+ // consider both the end of the previous repetition and the start
+ // the one that contains aIndex.
+ names.AppendElement(&mTrackAutoRepeatLineNames[maxRepeatLine]);
+ }
+ names.AppendElement(&mTrackAutoRepeatLineNames[repeatIndex]);
+ return names;
+ }
+ if (aIndex != mRepeatAutoStart && aIndex >= mRepeatAutoEnd) {
+ // Adjust the index to account for the line names of the repeat.
+ repeatAdjustedIndex -= mRepeatEndDelta;
+ repeatAdjustedIndex += mTrackAutoRepeatLineNames.Length() - 2;
+ }
+ }
+ MOZ_ASSERT(repeatAdjustedIndex < mExpandedLineNames.Length(),
+ "Incorrect repeatedAdjustedIndex");
+ MOZ_ASSERT(names.IsEmpty());
+ // The index is not inside the repeat tracks, or no repeat tracks exist.
+ const auto& nameLists = mExpandedLineNames[repeatAdjustedIndex];
+ for (const NameList* nameList : nameLists) {
+ names.AppendElement(nameList);
+ }
+ return names;
+ }
+
+ // Translate a subgrid line (1-based) to a parent line (1-based).
+ uint32_t TranslateToParentMap(uint32_t aLine) const {
+ if (MOZ_LIKELY(mIsSameDirection)) {
+ return aLine + mRange->mStart;
+ }
+ MOZ_ASSERT(mRange->mEnd + 1 >= aLine);
+ return mRange->mEnd - (aLine - 1) + 1;
+ }
+
+ /**
+ * Return the 1-based line that match aName in 'grid-template-areas'
+ * on the side aSide. Clamp the result to aMin..aMax but require
+ * that some part of the area is inside for it to match.
+ * Return zero if there is no match.
+ */
+ uint32_t FindNamedArea(nsAtom* aName, LogicalSide aSide, int32_t aMin,
+ int32_t aMax) const {
+ if (const NamedArea* area = FindNamedArea(aName)) {
+ int32_t start = IsBlock(aSide) ? area->rows.start : area->columns.start;
+ int32_t end = IsBlock(aSide) ? area->rows.end : area->columns.end;
+ if (IsStart(aSide)) {
+ if (start >= aMin) {
+ if (start <= aMax) {
+ return start;
+ }
+ } else if (end >= aMin) {
+ return aMin;
+ }
+ } else {
+ if (end <= aMax) {
+ if (end >= aMin) {
+ return end;
+ }
+ } else if (start <= aMax) {
+ return aMax;
+ }
+ }
+ }
+ return 0; // no match
+ }
+
+ /**
+ * A convenience method to lookup a name in 'grid-template-areas'.
+ * @return null if not found
+ */
+ const NamedArea* FindNamedArea(nsAtom* aName) const {
+ if (mStylePosition->mGridTemplateAreas.IsNone()) {
+ return nullptr;
+ }
+ const auto areas = mStylePosition->mGridTemplateAreas.AsAreas();
+ for (const NamedArea& area : areas->areas.AsSpan()) {
+ if (area.name.AsAtom() == aName) {
+ return &area;
+ }
+ }
+ return nullptr;
+ }
+
+ // Some style data references, for easy access.
+ const nsStylePosition* mStylePosition;
+ const ImplicitNamedAreas* mAreas;
+ // The expanded list of line-names. Each entry is usually a single NameList,
+ // but can be multiple in the case where repeat() expands to something that
+ // has a line name list at the end.
+ nsTArray<SmallPointerArray<const NameList>> mExpandedLineNames;
+ // The repeat(auto-fill/fit) track value, if any. (always empty for subgrid)
+ Span<const StyleOwnedSlice<StyleCustomIdent>> mTrackAutoRepeatLineNames;
+ // The index of the repeat(auto-fill/fit) track, or zero if there is none.
+ uint32_t mRepeatAutoStart;
+ // The index one past the end of the repeat(auto-fill/fit) tracks. Equal to
+ // mRepeatAutoStart if there are no repeat(auto-fill/fit) tracks.
+ uint32_t mRepeatAutoEnd;
+ // The total number of repeat tracks minus 1.
+ int32_t mRepeatEndDelta;
+ // The end of the line name lists with repeat(auto-fill/fit) tracks accounted
+ // for.
+ uint32_t mTemplateLinesEnd;
+
+ // The parent line map, or null if this map isn't for a subgrid.
+ const LineNameMap* mParentLineNameMap;
+ // The subgrid's range, or null if this map isn't for a subgrid.
+ const LineRange* mRange;
+ // True if the subgrid/parent axes progresses in the same direction.
+ const bool mIsSameDirection;
+
+ // True if there is a specified repeat(auto-fill/fit) track.
+ bool mHasRepeatAuto;
+};
+
+/**
+ * State for the tracks in one dimension.
+ */
+struct nsGridContainerFrame::Tracks {
+ explicit Tracks(LogicalAxis aAxis)
+ : mContentBoxSize(NS_UNCONSTRAINEDSIZE),
+ mGridGap(NS_UNCONSTRAINEDSIZE),
+ mStateUnion(TrackSize::StateBits{0}),
+ mAxis(aAxis),
+ mCanResolveLineRangeSize(false),
+ mIsMasonry(false) {
+ mBaselineSubtreeAlign[BaselineSharingGroup::First] = StyleAlignFlags::AUTO;
+ mBaselineSubtreeAlign[BaselineSharingGroup::Last] = StyleAlignFlags::AUTO;
+ mBaseline[BaselineSharingGroup::First] = NS_INTRINSIC_ISIZE_UNKNOWN;
+ mBaseline[BaselineSharingGroup::Last] = NS_INTRINSIC_ISIZE_UNKNOWN;
+ }
+
+ void Initialize(const TrackSizingFunctions& aFunctions,
+ const NonNegativeLengthPercentageOrNormal& aGridGap,
+ uint32_t aNumTracks, nscoord aContentBoxSize);
+
+ /**
+ * Return the union of the state bits for the tracks in aRange.
+ */
+ TrackSize::StateBits StateBitsForRange(const LineRange& aRange) const;
+
+ // Some data we collect for aligning baseline-aligned items.
+ struct ItemBaselineData {
+ uint32_t mBaselineTrack;
+ nscoord mBaseline;
+ nscoord mSize;
+ GridItemInfo* mGridItem;
+ static bool IsBaselineTrackLessThan(const ItemBaselineData& a,
+ const ItemBaselineData& b) {
+ return a.mBaselineTrack < b.mBaselineTrack;
+ }
+ };
+
+ /**
+ * Calculate baseline offsets for the given set of items.
+ * Helper for InitialzeItemBaselines.
+ */
+ void CalculateItemBaselines(nsTArray<ItemBaselineData>& aBaselineItems,
+ BaselineSharingGroup aBaselineGroup);
+
+ /**
+ * Initialize grid item baseline state and offsets.
+ */
+ void InitializeItemBaselines(GridReflowInput& aState,
+ nsTArray<GridItemInfo>& aGridItems);
+
+ /**
+ * A masonry axis has four baseline alignment sets and each set can have
+ * a first- and last-baseline alignment group, for a total of eight possible
+ * baseline alignment groups, as follows:
+ * set 1: the first item in each `start` or `stretch` grid track
+ * set 2: the last item in each `start` grid track
+ * set 3: the last item in each `end` or `stretch` grid track
+ * set 4: the first item in each `end` grid track
+ * (`start`/`end`/`stretch` refers to the relevant `align/justify-tracks`
+ * value of the (grid-axis) start track for the item) Baseline-alignment for
+ * set 1 and 2 always adjusts the item's padding or margin on the start side,
+ * and set 3 and 4 on the end side, for both first- and last-baseline groups
+ * in the set. (This is similar to regular grid which always adjusts
+ * first-baseline groups on the start side and last-baseline groups on the
+ * end-side. The crux is that those groups are always aligned to the track's
+ * start/end side respectively.)
+ */
+ struct BaselineAlignmentSet {
+ bool MatchTrackAlignment(StyleAlignFlags aTrackAlignment) const {
+ if (mTrackAlignmentSet == BaselineAlignmentSet::StartStretch) {
+ return aTrackAlignment == StyleAlignFlags::START ||
+ (aTrackAlignment == StyleAlignFlags::STRETCH &&
+ mItemSet == BaselineAlignmentSet::FirstItems);
+ }
+ return aTrackAlignment == StyleAlignFlags::END ||
+ (aTrackAlignment == StyleAlignFlags::STRETCH &&
+ mItemSet == BaselineAlignmentSet::LastItems);
+ }
+
+ enum ItemSet { FirstItems, LastItems };
+ ItemSet mItemSet = FirstItems;
+ enum TrackAlignmentSet { StartStretch, EndStretch };
+ TrackAlignmentSet mTrackAlignmentSet = StartStretch;
+ };
+ void InitializeItemBaselinesInMasonryAxis(
+ GridReflowInput& aState, nsTArray<GridItemInfo>& aGridItems,
+ BaselineAlignmentSet aSet, const nsSize& aContainerSize,
+ nsTArray<nscoord>& aTrackSizes,
+ nsTArray<ItemBaselineData>& aFirstBaselineItems,
+ nsTArray<ItemBaselineData>& aLastBaselineItems);
+
+ /**
+ * Apply the additional alignment needed to align the baseline-aligned subtree
+ * the item belongs to within its baseline track.
+ */
+ void AlignBaselineSubtree(const GridItemInfo& aGridItem) const;
+
+ enum class TrackSizingPhase {
+ IntrinsicMinimums,
+ ContentBasedMinimums,
+ MaxContentMinimums,
+ IntrinsicMaximums,
+ MaxContentMaximums,
+ };
+
+ // Some data we collect on each item that spans more than one track for step 3
+ // and 4 of the Track Sizing Algorithm in ResolveIntrinsicSize below.
+ // https://w3c.github.io/csswg-drafts/css-grid-1/#algo-spanning-items
+ struct SpanningItemData final {
+ uint32_t mSpan;
+ TrackSize::StateBits mState;
+ LineRange mLineRange;
+ nscoord mMinSize;
+ nscoord mMinContentContribution;
+ nscoord mMaxContentContribution;
+ nsIFrame* mFrame;
+
+ static bool IsSpanLessThan(const SpanningItemData& a,
+ const SpanningItemData& b) {
+ return a.mSpan < b.mSpan;
+ }
+
+ template <TrackSizingPhase phase>
+ nscoord SizeContributionForPhase() const {
+ switch (phase) {
+ case TrackSizingPhase::IntrinsicMinimums:
+ return mMinSize;
+ case TrackSizingPhase::ContentBasedMinimums:
+ case TrackSizingPhase::IntrinsicMaximums:
+ return mMinContentContribution;
+ case TrackSizingPhase::MaxContentMinimums:
+ case TrackSizingPhase::MaxContentMaximums:
+ return mMaxContentContribution;
+ }
+ MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("Unexpected phase");
+ }
+
+#ifdef DEBUG
+ void Dump() const {
+ printf(
+ "SpanningItemData { mSpan: %d, mState: %d, mLineRange: (%d, %d), "
+ "mMinSize: %d, mMinContentContribution: %d, mMaxContentContribution: "
+ "%d, mFrame: %p\n",
+ mSpan, mState, mLineRange.mStart, mLineRange.mEnd, mMinSize,
+ mMinContentContribution, mMaxContentContribution, mFrame);
+ }
+#endif
+ };
+
+ using FitContentClamper =
+ std::function<bool(uint32_t aTrack, nscoord aMinSize, nscoord* aSize)>;
+
+ // Helper method for ResolveIntrinsicSize.
+ template <TrackSizingPhase phase>
+ bool GrowSizeForSpanningItems(
+ nsTArray<SpanningItemData>::iterator aIter,
+ nsTArray<SpanningItemData>::iterator aIterEnd,
+ nsTArray<uint32_t>& aTracks, nsTArray<TrackSize>& aPlan,
+ nsTArray<TrackSize>& aItemPlan, TrackSize::StateBits aSelector,
+ const FitContentClamper& aFitContentClamper = nullptr,
+ bool aNeedInfinitelyGrowableFlag = false);
+ /**
+ * Resolve Intrinsic Track Sizes.
+ * http://dev.w3.org/csswg/css-grid/#algo-content
+ */
+ void ResolveIntrinsicSize(GridReflowInput& aState,
+ nsTArray<GridItemInfo>& aGridItems,
+ const TrackSizingFunctions& aFunctions,
+ LineRange GridArea::*aRange,
+ nscoord aPercentageBasis,
+ SizingConstraint aConstraint);
+
+ /**
+ * Helper for ResolveIntrinsicSize. It implements step 1 "size tracks to fit
+ * non-spanning items" in the spec. Return true if the track has a <flex>
+ * max-sizing function, false otherwise.
+ */
+ bool ResolveIntrinsicSizeForNonSpanningItems(
+ GridReflowInput& aState, const TrackSizingFunctions& aFunctions,
+ nscoord aPercentageBasis, SizingConstraint aConstraint,
+ const LineRange& aRange, const GridItemInfo& aGridItem);
+
+ // Helper method that returns the track size to use in §11.5.1.2
+ // https://drafts.csswg.org/css-grid/#extra-space
+ template <TrackSizingPhase phase>
+ static nscoord StartSizeInDistribution(const TrackSize& aSize) {
+ switch (phase) {
+ case TrackSizingPhase::IntrinsicMinimums:
+ case TrackSizingPhase::ContentBasedMinimums:
+ case TrackSizingPhase::MaxContentMinimums:
+ return aSize.mBase;
+ case TrackSizingPhase::IntrinsicMaximums:
+ case TrackSizingPhase::MaxContentMaximums:
+ if (aSize.mLimit == NS_UNCONSTRAINEDSIZE) {
+ return aSize.mBase;
+ }
+ return aSize.mLimit;
+ }
+ MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("Unexpected phase");
+ }
+
+ /**
+ * Collect the tracks which are growable (matching aSelector) into
+ * aGrowableTracks, and return the amount of space that can be used
+ * to grow those tracks. This method implements CSS Grid §11.5.1.2.
+ * https://drafts.csswg.org/css-grid/#extra-space
+ */
+ template <TrackSizingPhase phase>
+ nscoord CollectGrowable(nscoord aAvailableSpace, const LineRange& aRange,
+ TrackSize::StateBits aSelector,
+ nsTArray<uint32_t>& aGrowableTracks) const {
+ MOZ_ASSERT(aAvailableSpace > 0, "why call me?");
+ nscoord space = aAvailableSpace - mGridGap * (aRange.Extent() - 1);
+ for (auto i : aRange.Range()) {
+ const TrackSize& sz = mSizes[i];
+ space -= StartSizeInDistribution<phase>(sz);
+ if (space <= 0) {
+ return 0;
+ }
+ if (sz.mState & aSelector) {
+ aGrowableTracks.AppendElement(i);
+ }
+ }
+ return aGrowableTracks.IsEmpty() ? 0 : space;
+ }
+
+ template <TrackSizingPhase phase>
+ void InitializeItemPlan(nsTArray<TrackSize>& aItemPlan,
+ const nsTArray<uint32_t>& aTracks) const {
+ for (uint32_t track : aTracks) {
+ auto& plan = aItemPlan[track];
+ const TrackSize& sz = mSizes[track];
+ plan.mBase = StartSizeInDistribution<phase>(sz);
+ bool unlimited = sz.mState & TrackSize::eInfinitelyGrowable;
+ plan.mLimit = unlimited ? NS_UNCONSTRAINEDSIZE : sz.mLimit;
+ plan.mState = sz.mState;
+ }
+ }
+
+ template <TrackSizingPhase phase>
+ void InitializePlan(nsTArray<TrackSize>& aPlan) const {
+ for (size_t i = 0, len = aPlan.Length(); i < len; ++i) {
+ auto& plan = aPlan[i];
+ const auto& sz = mSizes[i];
+ plan.mBase = StartSizeInDistribution<phase>(sz);
+ MOZ_ASSERT(phase == TrackSizingPhase::MaxContentMaximums ||
+ !(sz.mState & TrackSize::eInfinitelyGrowable),
+ "forgot to reset the eInfinitelyGrowable bit?");
+ plan.mState = sz.mState;
+ }
+ }
+
+ template <TrackSizingPhase phase>
+ void CopyPlanToSize(const nsTArray<TrackSize>& aPlan,
+ bool aNeedInfinitelyGrowableFlag = false) {
+ for (size_t i = 0, len = mSizes.Length(); i < len; ++i) {
+ const auto& plan = aPlan[i];
+ MOZ_ASSERT(plan.mBase >= 0);
+ auto& sz = mSizes[i];
+ switch (phase) {
+ case TrackSizingPhase::IntrinsicMinimums:
+ case TrackSizingPhase::ContentBasedMinimums:
+ case TrackSizingPhase::MaxContentMinimums:
+ sz.mBase = plan.mBase;
+ break;
+ case TrackSizingPhase::IntrinsicMaximums:
+ if (plan.mState & TrackSize::eModified) {
+ if (sz.mLimit == NS_UNCONSTRAINEDSIZE &&
+ aNeedInfinitelyGrowableFlag) {
+ sz.mState |= TrackSize::eInfinitelyGrowable;
+ }
+ sz.mLimit = plan.mBase;
+ }
+ break;
+ case TrackSizingPhase::MaxContentMaximums:
+ if (plan.mState & TrackSize::eModified) {
+ sz.mLimit = plan.mBase;
+ }
+ sz.mState &= ~TrackSize::eInfinitelyGrowable;
+ break;
+ }
+ }
+ }
+
+ /**
+ * Grow the planned size for tracks in aGrowableTracks up to their limit
+ * and then freeze them (all aGrowableTracks must be unfrozen on entry).
+ * Subtract the space added from aAvailableSpace and return that.
+ */
+ nscoord GrowTracksToLimit(nscoord aAvailableSpace, nsTArray<TrackSize>& aPlan,
+ const nsTArray<uint32_t>& aGrowableTracks,
+ const FitContentClamper& aFitContentClamper) const {
+ MOZ_ASSERT(aAvailableSpace > 0 && aGrowableTracks.Length() > 0);
+ nscoord space = aAvailableSpace;
+ uint32_t numGrowable = aGrowableTracks.Length();
+ while (true) {
+ nscoord spacePerTrack = std::max<nscoord>(space / numGrowable, 1);
+ for (uint32_t track : aGrowableTracks) {
+ TrackSize& sz = aPlan[track];
+ if (sz.IsFrozen()) {
+ continue;
+ }
+ nscoord newBase = sz.mBase + spacePerTrack;
+ nscoord limit = sz.mLimit;
+ if (MOZ_UNLIKELY((sz.mState & TrackSize::eFitContent) &&
+ aFitContentClamper)) {
+ // Clamp the limit to the fit-content() size, for §12.5.2 step 5/6.
+ aFitContentClamper(track, sz.mBase, &limit);
+ }
+ if (newBase > limit) {
+ nscoord consumed = limit - sz.mBase;
+ if (consumed > 0) {
+ space -= consumed;
+ sz.mBase = limit;
+ }
+ sz.mState |= TrackSize::eFrozen;
+ if (--numGrowable == 0) {
+ return space;
+ }
+ } else {
+ sz.mBase = newBase;
+ space -= spacePerTrack;
+ }
+ MOZ_ASSERT(space >= 0);
+ if (space == 0) {
+ return 0;
+ }
+ }
+ }
+ MOZ_ASSERT_UNREACHABLE("we don't exit the loop above except by return");
+ return 0;
+ }
+
+ /**
+ * Helper for GrowSelectedTracksUnlimited. For the set of tracks (S) that
+ * match aMinSizingSelector: if a track in S doesn't match aMaxSizingSelector
+ * then mark it with aSkipFlag. If all tracks in S were marked then unmark
+ * them. Return aNumGrowable minus the number of tracks marked. It is
+ * assumed that aPlan have no aSkipFlag set for tracks in aGrowableTracks
+ * on entry to this method.
+ */
+ static uint32_t MarkExcludedTracks(nsTArray<TrackSize>& aPlan,
+ uint32_t aNumGrowable,
+ const nsTArray<uint32_t>& aGrowableTracks,
+ TrackSize::StateBits aMinSizingSelector,
+ TrackSize::StateBits aMaxSizingSelector,
+ TrackSize::StateBits aSkipFlag) {
+ bool foundOneSelected = false;
+ bool foundOneGrowable = false;
+ uint32_t numGrowable = aNumGrowable;
+ for (uint32_t track : aGrowableTracks) {
+ TrackSize& sz = aPlan[track];
+ const auto state = sz.mState;
+ if (state & aMinSizingSelector) {
+ foundOneSelected = true;
+ if (state & aMaxSizingSelector) {
+ foundOneGrowable = true;
+ continue;
+ }
+ sz.mState |= aSkipFlag;
+ MOZ_ASSERT(numGrowable != 0);
+ --numGrowable;
+ }
+ }
+ // 12.5 "if there are no such tracks, then all affected tracks"
+ if (foundOneSelected && !foundOneGrowable) {
+ for (uint32_t track : aGrowableTracks) {
+ aPlan[track].mState &= ~aSkipFlag;
+ }
+ numGrowable = aNumGrowable;
+ }
+ return numGrowable;
+ }
+
+ /**
+ * Mark all tracks in aGrowableTracks with an eSkipGrowUnlimited bit if
+ * they *shouldn't* grow unlimited in §11.5.1.2.3 "Distribute space beyond
+ * growth limits" https://drafts.csswg.org/css-grid/#extra-space
+ * Return the number of tracks that are still growable.
+ */
+ template <TrackSizingPhase phase>
+ static uint32_t MarkExcludedTracks(nsTArray<TrackSize>& aPlan,
+ const nsTArray<uint32_t>& aGrowableTracks,
+ TrackSize::StateBits aSelector) {
+ uint32_t numGrowable = aGrowableTracks.Length();
+ if (phase == TrackSizingPhase::IntrinsicMaximums ||
+ phase == TrackSizingPhase::MaxContentMaximums) {
+ // "when handling any intrinsic growth limit: all affected tracks"
+ return numGrowable;
+ }
+ MOZ_ASSERT(aSelector == (aSelector & TrackSize::eIntrinsicMinSizing) &&
+ (aSelector & TrackSize::eMaxContentMinSizing),
+ "Should only get here for track sizing steps 2.1 to 2.3");
+ // Note that eMaxContentMinSizing is always included. We do those first:
+ numGrowable = MarkExcludedTracks(
+ aPlan, numGrowable, aGrowableTracks, TrackSize::eMaxContentMinSizing,
+ TrackSize::eMaxContentMaxSizing, TrackSize::eSkipGrowUnlimited1);
+ // Now mark min-content/auto min-sizing tracks if requested.
+ auto minOrAutoSelector = aSelector & ~TrackSize::eMaxContentMinSizing;
+ if (minOrAutoSelector) {
+ numGrowable = MarkExcludedTracks(
+ aPlan, numGrowable, aGrowableTracks, minOrAutoSelector,
+ TrackSize::eIntrinsicMaxSizing, TrackSize::eSkipGrowUnlimited2);
+ }
+ return numGrowable;
+ }
+
+ /**
+ * Increase the planned size for tracks in aGrowableTracks that aren't
+ * marked with a eSkipGrowUnlimited flag beyond their limit.
+ * This implements the "Distribute space beyond growth limits" step in
+ * https://drafts.csswg.org/css-grid/#distribute-extra-space
+ */
+ void GrowSelectedTracksUnlimited(
+ nscoord aAvailableSpace, nsTArray<TrackSize>& aPlan,
+ const nsTArray<uint32_t>& aGrowableTracks, uint32_t aNumGrowable,
+ const FitContentClamper& aFitContentClamper) const {
+ MOZ_ASSERT(aAvailableSpace > 0 && aGrowableTracks.Length() > 0 &&
+ aNumGrowable <= aGrowableTracks.Length());
+ nscoord space = aAvailableSpace;
+ DebugOnly<bool> didClamp = false;
+ while (aNumGrowable) {
+ nscoord spacePerTrack = std::max<nscoord>(space / aNumGrowable, 1);
+ for (uint32_t track : aGrowableTracks) {
+ TrackSize& sz = aPlan[track];
+ if (sz.mState & TrackSize::eSkipGrowUnlimited) {
+ continue; // an excluded track
+ }
+ nscoord delta = spacePerTrack;
+ nscoord newBase = sz.mBase + delta;
+ if (MOZ_UNLIKELY((sz.mState & TrackSize::eFitContent) &&
+ aFitContentClamper)) {
+ // Clamp newBase to the fit-content() size, for §12.5.2 step 5/6.
+ if (aFitContentClamper(track, sz.mBase, &newBase)) {
+ didClamp = true;
+ delta = newBase - sz.mBase;
+ MOZ_ASSERT(delta >= 0, "track size shouldn't shrink");
+ sz.mState |= TrackSize::eSkipGrowUnlimited1;
+ --aNumGrowable;
+ }
+ }
+ sz.mBase = newBase;
+ space -= delta;
+ MOZ_ASSERT(space >= 0);
+ if (space == 0) {
+ return;
+ }
+ }
+ }
+ MOZ_ASSERT(didClamp,
+ "we don't exit the loop above except by return, "
+ "unless we clamped some track's size");
+ }
+
+ /**
+ * Distribute aAvailableSpace to the planned base size for aGrowableTracks
+ * up to their limits, then distribute the remaining space beyond the limits.
+ */
+ template <TrackSizingPhase phase>
+ void DistributeToTrackSizes(nscoord aAvailableSpace,
+ nsTArray<TrackSize>& aPlan,
+ nsTArray<TrackSize>& aItemPlan,
+ nsTArray<uint32_t>& aGrowableTracks,
+ TrackSize::StateBits aSelector,
+ const FitContentClamper& aFitContentClamper) {
+ InitializeItemPlan<phase>(aItemPlan, aGrowableTracks);
+ nscoord space = GrowTracksToLimit(aAvailableSpace, aItemPlan,
+ aGrowableTracks, aFitContentClamper);
+ if (space > 0) {
+ uint32_t numGrowable =
+ MarkExcludedTracks<phase>(aItemPlan, aGrowableTracks, aSelector);
+ GrowSelectedTracksUnlimited(space, aItemPlan, aGrowableTracks,
+ numGrowable, aFitContentClamper);
+ }
+ for (uint32_t track : aGrowableTracks) {
+ nscoord& plannedSize = aPlan[track].mBase;
+ nscoord itemIncurredSize = aItemPlan[track].mBase;
+ if (plannedSize < itemIncurredSize) {
+ plannedSize = itemIncurredSize;
+ }
+ }
+ }
+
+ /**
+ * Distribute aAvailableSize to the tracks. This implements 12.6 at:
+ * http://dev.w3.org/csswg/css-grid/#algo-grow-tracks
+ */
+ void DistributeFreeSpace(nscoord aAvailableSize) {
+ const uint32_t numTracks = mSizes.Length();
+ if (MOZ_UNLIKELY(numTracks == 0 || aAvailableSize <= 0)) {
+ return;
+ }
+ if (aAvailableSize == NS_UNCONSTRAINEDSIZE) {
+ for (TrackSize& sz : mSizes) {
+ sz.mBase = sz.mLimit;
+ }
+ } else {
+ // Compute free space and count growable tracks.
+ nscoord space = aAvailableSize;
+ uint32_t numGrowable = numTracks;
+ for (const TrackSize& sz : mSizes) {
+ space -= sz.mBase;
+ MOZ_ASSERT(sz.mBase <= sz.mLimit);
+ if (sz.mBase == sz.mLimit) {
+ --numGrowable;
+ }
+ }
+ // Distribute the free space evenly to the growable tracks. If not exactly
+ // divisable the remainder is added to the leading tracks.
+ while (space > 0 && numGrowable) {
+ nscoord spacePerTrack = std::max<nscoord>(space / numGrowable, 1);
+ for (uint32_t i = 0; i < numTracks && space > 0; ++i) {
+ TrackSize& sz = mSizes[i];
+ if (sz.mBase == sz.mLimit) {
+ continue;
+ }
+ nscoord newBase = sz.mBase + spacePerTrack;
+ if (newBase >= sz.mLimit) {
+ space -= sz.mLimit - sz.mBase;
+ sz.mBase = sz.mLimit;
+ --numGrowable;
+ } else {
+ space -= spacePerTrack;
+ sz.mBase = newBase;
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Implements "12.7.1. Find the Size of an 'fr'".
+ * http://dev.w3.org/csswg/css-grid/#algo-find-fr-size
+ * (The returned value is a 'nscoord' divided by a factor - a floating type
+ * is used to avoid intermediary rounding errors.)
+ */
+ float FindFrUnitSize(const LineRange& aRange,
+ const nsTArray<uint32_t>& aFlexTracks,
+ const TrackSizingFunctions& aFunctions,
+ nscoord aSpaceToFill) const;
+
+ /**
+ * Implements the "find the used flex fraction" part of StretchFlexibleTracks.
+ * (The returned value is a 'nscoord' divided by a factor - a floating type
+ * is used to avoid intermediary rounding errors.)
+ */
+ float FindUsedFlexFraction(GridReflowInput& aState,
+ nsTArray<GridItemInfo>& aGridItems,
+ const nsTArray<uint32_t>& aFlexTracks,
+ const TrackSizingFunctions& aFunctions,
+ nscoord aAvailableSize) const;
+
+ /**
+ * Implements "12.7. Stretch Flexible Tracks"
+ * http://dev.w3.org/csswg/css-grid/#algo-flex-tracks
+ */
+ void StretchFlexibleTracks(GridReflowInput& aState,
+ nsTArray<GridItemInfo>& aGridItems,
+ const TrackSizingFunctions& aFunctions,
+ nscoord aAvailableSize);
+
+ /**
+ * Implements "12.3. Track Sizing Algorithm"
+ * http://dev.w3.org/csswg/css-grid/#algo-track-sizing
+ */
+ void CalculateSizes(GridReflowInput& aState,
+ nsTArray<GridItemInfo>& aGridItems,
+ const TrackSizingFunctions& aFunctions,
+ nscoord aContentBoxSize, LineRange GridArea::*aRange,
+ SizingConstraint aConstraint);
+
+ /**
+ * Apply 'align/justify-content', whichever is relevant for this axis.
+ * https://drafts.csswg.org/css-align-3/#propdef-align-content
+ */
+ void AlignJustifyContent(const nsStylePosition* aStyle,
+ StyleContentDistribution aAligmentStyleValue,
+ WritingMode aWM, nscoord aContentBoxSize,
+ bool aIsSubgridded);
+
+ nscoord GridLineEdge(uint32_t aLine, GridLineSide aSide) const {
+ if (MOZ_UNLIKELY(mSizes.IsEmpty())) {
+ // https://drafts.csswg.org/css-grid/#grid-definition
+ // "... the explicit grid still contains one grid line in each axis."
+ MOZ_ASSERT(aLine == 0, "We should only resolve line 1 in an empty grid");
+ return nscoord(0);
+ }
+ MOZ_ASSERT(aLine <= mSizes.Length(), "mSizes is too small");
+ if (aSide == GridLineSide::BeforeGridGap) {
+ if (aLine == 0) {
+ return nscoord(0);
+ }
+ const TrackSize& sz = mSizes[aLine - 1];
+ return sz.mPosition + sz.mBase;
+ }
+ if (aLine == mSizes.Length()) {
+ return mContentBoxSize;
+ }
+ return mSizes[aLine].mPosition;
+ }
+
+ nscoord SumOfGridTracksAndGaps() {
+ return SumOfGridTracks() + SumOfGridGaps();
+ }
+
+ nscoord SumOfGridTracks() const {
+ nscoord result = 0;
+ for (const TrackSize& size : mSizes) {
+ result += size.mBase;
+ }
+ return result;
+ }
+
+ nscoord SumOfGridGaps() const {
+ auto len = mSizes.Length();
+ return MOZ_LIKELY(len > 1) ? (len - 1) * mGridGap : 0;
+ }
+
+ /**
+ * Break before aRow, i.e. set the eBreakBefore flag on aRow and set the grid
+ * gap before aRow to zero (and shift all rows after it by the removed gap).
+ */
+ void BreakBeforeRow(uint32_t aRow) {
+ MOZ_ASSERT(mAxis == eLogicalAxisBlock,
+ "Should only be fragmenting in the block axis (between rows)");
+ nscoord prevRowEndPos = 0;
+ if (aRow != 0) {
+ auto& prevSz = mSizes[aRow - 1];
+ prevRowEndPos = prevSz.mPosition + prevSz.mBase;
+ }
+ auto& sz = mSizes[aRow];
+ const nscoord gap = sz.mPosition - prevRowEndPos;
+ sz.mState |= TrackSize::eBreakBefore;
+ if (gap != 0) {
+ for (uint32_t i = aRow, len = mSizes.Length(); i < len; ++i) {
+ mSizes[i].mPosition -= gap;
+ }
+ }
+ }
+
+ /**
+ * Set the size of aRow to aSize and adjust the position of all rows after it.
+ */
+ void ResizeRow(uint32_t aRow, nscoord aNewSize) {
+ MOZ_ASSERT(mAxis == eLogicalAxisBlock,
+ "Should only be fragmenting in the block axis (between rows)");
+ MOZ_ASSERT(aNewSize >= 0);
+ auto& sz = mSizes[aRow];
+ nscoord delta = aNewSize - sz.mBase;
+ NS_WARNING_ASSERTION(delta != nscoord(0), "Useless call to ResizeRow");
+ sz.mBase = aNewSize;
+ const uint32_t numRows = mSizes.Length();
+ for (uint32_t r = aRow + 1; r < numRows; ++r) {
+ mSizes[r].mPosition += delta;
+ }
+ }
+
+ nscoord ResolveSize(const LineRange& aRange) const {
+ MOZ_ASSERT(mCanResolveLineRangeSize);
+ MOZ_ASSERT(aRange.Extent() > 0, "grid items cover at least one track");
+ nscoord pos, size;
+ aRange.ToPositionAndLength(mSizes, &pos, &size);
+ return size;
+ }
+
+#ifdef DEBUG
+ void Dump() const;
+#endif
+
+ CopyableAutoTArray<TrackSize, 32> mSizes;
+ nscoord mContentBoxSize;
+ nscoord mGridGap;
+ // The first(last)-baseline for the first(last) track in this axis.
+ PerBaseline<nscoord> mBaseline;
+ // The union of the track min/max-sizing state bits in this axis.
+ TrackSize::StateBits mStateUnion;
+ LogicalAxis mAxis;
+ // Used for aligning a baseline-aligned subtree of items. The only possible
+ // values are StyleAlignFlags::{START,END,CENTER,AUTO}. AUTO means there are
+ // no baseline-aligned items in any track in that axis.
+ // There is one alignment value for each BaselineSharingGroup.
+ PerBaseline<StyleAlignFlags> mBaselineSubtreeAlign;
+ // True if track positions and sizes are final in this axis.
+ bool mCanResolveLineRangeSize;
+ // True if this axis has masonry layout.
+ bool mIsMasonry;
+};
+
+#ifdef DEBUG
+void nsGridContainerFrame::Tracks::Dump() const {
+ printf("%zu %s %s ", mSizes.Length(), mIsMasonry ? "masonry" : "grid",
+ mAxis == eLogicalAxisBlock ? "rows" : "columns");
+ TrackSize::DumpStateBits(mStateUnion);
+ printf("\n");
+ for (uint32_t i = 0, len = mSizes.Length(); i < len; ++i) {
+ printf(" %d: ", i);
+ mSizes[i].Dump();
+ printf("\n");
+ }
+ double px = AppUnitsPerCSSPixel();
+ printf("Baselines: %.2fpx %2fpx\n",
+ mBaseline[BaselineSharingGroup::First] / px,
+ mBaseline[BaselineSharingGroup::Last] / px);
+ printf("Gap: %.2fpx\n", mGridGap / px);
+ printf("ContentBoxSize: %.2fpx\n", mContentBoxSize / px);
+}
+#endif
+
+/**
+ * Grid data shared by all continuations, owned by the first-in-flow.
+ * The data is initialized from the first-in-flow's GridReflowInput at
+ * the end of its reflow. Fragmentation will modify mRows.mSizes -
+ * the mPosition to remove the row gap at the break boundary, the mState
+ * by setting the eBreakBefore flag, and mBase is modified when we decide
+ * to grow a row. mOriginalRowData is setup by the first-in-flow and
+ * not modified after that. It's used for undoing the changes to mRows.
+ * mCols, mGridItems, mAbsPosItems are used for initializing the grid
+ * reflow input for continuations, see GridReflowInput::Initialize below.
+ */
+struct nsGridContainerFrame::SharedGridData {
+ SharedGridData()
+ : mCols(eLogicalAxisInline),
+ mRows(eLogicalAxisBlock),
+ mGenerateComputedGridInfo(false) {}
+ Tracks mCols;
+ Tracks mRows;
+ struct RowData {
+ nscoord mBase; // the original track size
+ nscoord mGap; // the original gap before a track
+ };
+ nsTArray<RowData> mOriginalRowData;
+ nsTArray<GridItemInfo> mGridItems;
+ nsTArray<GridItemInfo> mAbsPosItems;
+ bool mGenerateComputedGridInfo;
+
+ /**
+ * Only set on the first-in-flow. Continuations will Initialize() their
+ * GridReflowInput from it.
+ */
+ NS_DECLARE_FRAME_PROPERTY_DELETABLE(Prop, SharedGridData)
+};
+
+struct MOZ_STACK_CLASS nsGridContainerFrame::GridReflowInput {
+ GridReflowInput(nsGridContainerFrame* aFrame, const ReflowInput& aRI)
+ : GridReflowInput(aFrame, *aRI.mRenderingContext, &aRI,
+ aRI.mStylePosition, aRI.GetWritingMode()) {}
+ GridReflowInput(nsGridContainerFrame* aFrame, gfxContext& aRC)
+ : GridReflowInput(aFrame, aRC, nullptr, aFrame->StylePosition(),
+ aFrame->GetWritingMode()) {}
+
+ /**
+ * Initialize our track sizes and grid item info using the shared
+ * state from aGridContainerFrame first-in-flow.
+ */
+ void InitializeForContinuation(nsGridContainerFrame* aGridContainerFrame,
+ nscoord aConsumedBSize) {
+ MOZ_ASSERT(aGridContainerFrame->GetPrevInFlow(),
+ "don't call this on the first-in-flow");
+ MOZ_ASSERT(mGridItems.IsEmpty() && mAbsPosItems.IsEmpty(),
+ "shouldn't have any item data yet");
+
+ // Get the SharedGridData from the first-in-flow. Also calculate the number
+ // of fragments before this so that we can figure out our start row below.
+ uint32_t fragment = 0;
+ nsIFrame* firstInFlow = aGridContainerFrame;
+ for (auto pif = aGridContainerFrame->GetPrevInFlow(); pif;
+ pif = pif->GetPrevInFlow()) {
+ ++fragment;
+ firstInFlow = pif;
+ }
+ mSharedGridData = firstInFlow->GetProperty(SharedGridData::Prop());
+ MOZ_ASSERT(mSharedGridData, "first-in-flow must have SharedGridData");
+
+ // Find the start row for this fragment and undo breaks after that row
+ // since the breaks might be different from the last reflow.
+ auto& rowSizes = mSharedGridData->mRows.mSizes;
+ const uint32_t numRows = rowSizes.Length();
+ mStartRow = numRows;
+ for (uint32_t row = 0, breakCount = 0; row < numRows; ++row) {
+ if (rowSizes[row].mState & TrackSize::eBreakBefore) {
+ if (fragment == ++breakCount) {
+ mStartRow = row;
+ mFragBStart = rowSizes[row].mPosition;
+ // Restore the original size for |row| and grid gaps / state after it.
+ const auto& origRowData = mSharedGridData->mOriginalRowData;
+ rowSizes[row].mBase = origRowData[row].mBase;
+ nscoord prevEndPos = rowSizes[row].mPosition + rowSizes[row].mBase;
+ while (++row < numRows) {
+ auto& sz = rowSizes[row];
+ const auto& orig = origRowData[row];
+ sz.mPosition = prevEndPos + orig.mGap;
+ sz.mBase = orig.mBase;
+ sz.mState &= ~TrackSize::eBreakBefore;
+ prevEndPos = sz.mPosition + sz.mBase;
+ }
+ break;
+ }
+ }
+ }
+ if (mStartRow == numRows ||
+ aGridContainerFrame->IsMasonry(eLogicalAxisBlock)) {
+ // All of the grid's rows fit inside of previous grid-container fragments,
+ // or it's a masonry axis.
+ mFragBStart = aConsumedBSize;
+ }
+
+ // Copy the shared track state.
+ // XXX consider temporarily swapping the array elements instead and swapping
+ // XXX them back after we're done reflowing, for better performance.
+ // XXX (bug 1252002)
+ mCols = mSharedGridData->mCols;
+ mRows = mSharedGridData->mRows;
+
+ if (firstInFlow->GetProperty(UsedTrackSizes::Prop())) {
+ auto* prop = aGridContainerFrame->GetProperty(UsedTrackSizes::Prop());
+ if (!prop) {
+ prop = new UsedTrackSizes();
+ aGridContainerFrame->SetProperty(UsedTrackSizes::Prop(), prop);
+ }
+ prop->mCanResolveLineRangeSize = {true, true};
+ prop->mSizes[eLogicalAxisInline].Assign(mCols.mSizes);
+ prop->mSizes[eLogicalAxisBlock].Assign(mRows.mSizes);
+ }
+
+ // Copy item data from each child's first-in-flow data in mSharedGridData.
+ // XXX NOTE: This is O(n^2) in the number of items. (bug 1252186)
+ mIter.Reset();
+ for (; !mIter.AtEnd(); mIter.Next()) {
+ nsIFrame* child = *mIter;
+ nsIFrame* childFirstInFlow = child->FirstInFlow();
+ DebugOnly<size_t> len = mGridItems.Length();
+ for (auto& itemInfo : mSharedGridData->mGridItems) {
+ if (itemInfo.mFrame == childFirstInFlow) {
+ auto item =
+ mGridItems.AppendElement(GridItemInfo(child, itemInfo.mArea));
+ // Copy the item's baseline data so that the item's last fragment can
+ // do 'last baseline' alignment if necessary.
+ item->mState[eLogicalAxisBlock] |=
+ itemInfo.mState[eLogicalAxisBlock] & ItemState::eAllBaselineBits;
+ item->mState[eLogicalAxisInline] |=
+ itemInfo.mState[eLogicalAxisInline] & ItemState::eAllBaselineBits;
+ item->mBaselineOffset[eLogicalAxisBlock] =
+ itemInfo.mBaselineOffset[eLogicalAxisBlock];
+ item->mBaselineOffset[eLogicalAxisInline] =
+ itemInfo.mBaselineOffset[eLogicalAxisInline];
+ item->mState[eLogicalAxisBlock] |=
+ itemInfo.mState[eLogicalAxisBlock] & ItemState::eAutoPlacement;
+ item->mState[eLogicalAxisInline] |=
+ itemInfo.mState[eLogicalAxisInline] & ItemState::eAutoPlacement;
+ break;
+ }
+ }
+ MOZ_ASSERT(mGridItems.Length() == len + 1, "can't find GridItemInfo");
+ }
+
+ // XXX NOTE: This is O(n^2) in the number of abs.pos. items. (bug 1252186)
+ const nsFrameList& absPosChildren = aGridContainerFrame->GetChildList(
+ aGridContainerFrame->GetAbsoluteListID());
+ for (auto f : absPosChildren) {
+ nsIFrame* childFirstInFlow = f->FirstInFlow();
+ DebugOnly<size_t> len = mAbsPosItems.Length();
+ for (auto& itemInfo : mSharedGridData->mAbsPosItems) {
+ if (itemInfo.mFrame == childFirstInFlow) {
+ mAbsPosItems.AppendElement(GridItemInfo(f, itemInfo.mArea));
+ break;
+ }
+ }
+ MOZ_ASSERT(mAbsPosItems.Length() == len + 1, "can't find GridItemInfo");
+ }
+
+ // Copy in the computed grid info state bit
+ if (mSharedGridData->mGenerateComputedGridInfo) {
+ aGridContainerFrame->AddStateBits(NS_STATE_GRID_COMPUTED_INFO);
+ }
+ }
+
+ /**
+ * Calculate our track sizes in the given axis.
+ */
+ void CalculateTrackSizesForAxis(LogicalAxis aAxis, const Grid& aGrid,
+ nscoord aCBSize,
+ SizingConstraint aConstraint);
+
+ /**
+ * Calculate our track sizes.
+ */
+ void CalculateTrackSizes(const Grid& aGrid, const LogicalSize& aContentBox,
+ SizingConstraint aConstraint);
+
+ /**
+ * Return the percentage basis for a grid item in its writing-mode.
+ * If aAxis is eLogicalAxisInline then we return NS_UNCONSTRAINEDSIZE in
+ * both axes since we know all track sizes are indefinite at this point
+ * (we calculate column sizes before row sizes). Otherwise, assert that
+ * column sizes are known and calculate the size for aGridItem.mArea.mCols
+ * and use NS_UNCONSTRAINEDSIZE in the other axis.
+ * @param aAxis the axis we're currently calculating track sizes for
+ */
+ LogicalSize PercentageBasisFor(LogicalAxis aAxis,
+ const GridItemInfo& aGridItem) const;
+
+ /**
+ * Return the containing block for a grid item occupying aArea.
+ */
+ LogicalRect ContainingBlockFor(const GridArea& aArea) const;
+
+ /**
+ * Return the containing block for an abs.pos. grid item occupying aArea.
+ * Any 'auto' lines in the grid area will be aligned with grid container
+ * containing block on that side.
+ * @param aGridOrigin the origin of the grid
+ * @param aGridCB the grid container containing block (its padding area)
+ */
+ LogicalRect ContainingBlockForAbsPos(const GridArea& aArea,
+ const LogicalPoint& aGridOrigin,
+ const LogicalRect& aGridCB) const;
+
+ /**
+ * Apply `align/justify-content` alignment in our masonry axis.
+ * This aligns the "masonry box" within our content box size.
+ */
+ void AlignJustifyContentInMasonryAxis(nscoord aMasonryBoxSize,
+ nscoord aContentBoxSize);
+ /**
+ * Apply `align/justify-tracks` alignment in our masonry axis.
+ */
+ void AlignJustifyTracksInMasonryAxis(const LogicalSize& aContentSize,
+ const nsSize& aContainerSize);
+
+ // Recursive helper for CollectSubgridItemsForAxis().
+ static void CollectSubgridItemsForAxisHelper(
+ LogicalAxis aAxis, WritingMode aContainerWM,
+ const LineRange& aRangeInAxis, const LineRange& aRangeInOppositeAxis,
+ const GridItemInfo& aItem, const nsTArray<GridItemInfo>& aItems,
+ nsTArray<GridItemInfo>& aResult) {
+ const auto oppositeAxis = GetOrthogonalAxis(aAxis);
+ bool itemIsSubgridInOppositeAxis = aItem.IsSubgrid(oppositeAxis);
+ auto subgridWM = aItem.mFrame->GetWritingMode();
+ bool isOrthogonal = subgridWM.IsOrthogonalTo(aContainerWM);
+ bool isSameDirInAxis =
+ subgridWM.ParallelAxisStartsOnSameSide(aAxis, aContainerWM);
+ bool isSameDirInOppositeAxis =
+ subgridWM.ParallelAxisStartsOnSameSide(oppositeAxis, aContainerWM);
+ if (isOrthogonal) {
+ // We'll Transpose the area below so these needs to be transposed as well.
+ std::swap(isSameDirInAxis, isSameDirInOppositeAxis);
+ }
+ uint32_t offsetInAxis = aRangeInAxis.mStart;
+ uint32_t gridEndInAxis = aRangeInAxis.Extent();
+ uint32_t offsetInOppositeAxis = aRangeInOppositeAxis.mStart;
+ uint32_t gridEndInOppositeAxis = aRangeInOppositeAxis.Extent();
+ for (const auto& subgridItem : aItems) {
+ auto newItem = aResult.AppendElement(
+ isOrthogonal ? subgridItem.Transpose() : subgridItem);
+ if (MOZ_UNLIKELY(!isSameDirInAxis)) {
+ newItem->ReverseDirection(aAxis, gridEndInAxis);
+ }
+ newItem->mArea.LineRangeForAxis(aAxis).Translate(offsetInAxis);
+ if (itemIsSubgridInOppositeAxis) {
+ if (MOZ_UNLIKELY(!isSameDirInOppositeAxis)) {
+ newItem->ReverseDirection(oppositeAxis, gridEndInOppositeAxis);
+ }
+ LineRange& range = newItem->mArea.LineRangeForAxis(oppositeAxis);
+ range.Translate(offsetInOppositeAxis);
+ }
+ if (newItem->IsSubgrid(aAxis)) {
+ auto* subgrid =
+ subgridItem.SubgridFrame()->GetProperty(Subgrid::Prop());
+ CollectSubgridItemsForAxisHelper(
+ aAxis, aContainerWM, newItem->mArea.LineRangeForAxis(aAxis),
+ newItem->mArea.LineRangeForAxis(oppositeAxis), *newItem,
+ subgrid->mGridItems, aResult);
+ }
+ }
+ }
+
+ // Copy all descendant items from all our subgrid children that are subgridded
+ // in aAxis recursively into aResult. All item grid area's and state are
+ // translated to our coordinates.
+ void CollectSubgridItemsForAxis(LogicalAxis aAxis,
+ nsTArray<GridItemInfo>& aResult) const {
+ for (const auto& item : mGridItems) {
+ if (item.IsSubgrid(aAxis)) {
+ const auto oppositeAxis = GetOrthogonalAxis(aAxis);
+ auto* subgrid = item.SubgridFrame()->GetProperty(Subgrid::Prop());
+ CollectSubgridItemsForAxisHelper(
+ aAxis, mWM, item.mArea.LineRangeForAxis(aAxis),
+ item.mArea.LineRangeForAxis(oppositeAxis), item,
+ subgrid->mGridItems, aResult);
+ }
+ }
+ }
+
+ /**
+ * Recursive helper for CopyBaselineMetricsToSubgridItems().
+ *
+ * @param aAxis The LogicalAxis for the axis whose baseline metrics we're
+ * copying here (with respect to the outermost parent grid's
+ * writing mode).
+ * @param aContainerWM The writing mode of that outermost parent grid.
+ * @param aSubgridFrame The subgrid whose subgrid-items we're considering
+ * in this recursive traversal (whose items we're copying over
+ * baseline-alignment metrics for).
+ * @param aContainerGridItems The outermost parent grid's array of
+ * GridItemInfo objects. (The final portion of this array is
+ * all for subgrid items, and that's the portion that we're
+ * recursively iterating over.)
+ * @param aContainerGridItemsIdx [in/out] The index for the item that we're
+ * currently considering in aContainerGridItemsIdx. When
+ * this function returns, this will be the index just beyond the
+ * last item that we handled here, i.e. the index of the next
+ * item to be handled.
+ */
+ static void CopyBaselineMetricsToSubgridItemsHelper(
+ LogicalAxis aAxis, WritingMode aContainerWM, nsIFrame* aSubgridFrame,
+ const nsTArray<GridItemInfo>& aContainerGridItems,
+ size_t& aContainerGridItemsIdx) {
+ // Get the canonical GridItemInfo structs for the grid items that live
+ // inside of aSubgridFrame:
+ Subgrid* subgridProp = aSubgridFrame->GetProperty(Subgrid::Prop());
+ nsTArray<GridItemInfo>& subgridItems = subgridProp->mGridItems;
+
+ // Use aSubgridFrame's writing-mode to determine subgridAxis.
+ // Grids & subgrids store various data on a per-LogicalAxis basis, with
+ // respect to their own WritingMode. Here, subgridAxis is aSubgridFrame's
+ // axis that maps to the same physical axis that aAxis does for the
+ // outermost parent grid.
+ auto subgridWM = aSubgridFrame->GetWritingMode();
+ bool isOrthogonal = subgridWM.IsOrthogonalTo(aContainerWM);
+ LogicalAxis subgridAxis = isOrthogonal ? GetOrthogonalAxis(aAxis) : aAxis;
+
+ // Do a parallel walk through (1) subgridItems and (2) the portion of
+ // aContainerGridItems that starts at offset aContainerGridItems,
+ // descending to traverse child subgrids own items as we encounter them in
+ // subgridItems. We expect to have an exact correspondence, because this
+ // is precisely how we built up this portion of aContainerGridItems in
+ // CollectSubgridItemsForAxis. (But if we happen to overstep the end of an
+ // array, or find a GridItemInfo for a frame that we don't expect, we
+ // gracefully bail out.)
+ for (auto& subgridItem : subgridItems) {
+ if (MOZ_UNLIKELY(aContainerGridItemsIdx >=
+ aContainerGridItems.Length())) {
+ // We failed to make the same traversal as CollectSubgridItemsForAxis;
+ // whoops! This shouldn't happen; but if it does, we gracefully bail
+ // out, instead of crashing.
+ MOZ_ASSERT_UNREACHABLE("Out-of-bounds aContainerGridItemsIdx");
+ return;
+ }
+ const auto& itemFromContainer =
+ aContainerGridItems[aContainerGridItemsIdx];
+ aContainerGridItemsIdx++;
+
+ if (MOZ_UNLIKELY(subgridItem.mFrame != itemFromContainer.mFrame)) {
+ // We failed to make the same traversal as CollectSubgridItemsForAxis;
+ // whoops! This shouldn't happen; but if it does, we gracefully bail
+ // out, instead of copying baseline-alignment data for the wrong frame.
+ MOZ_ASSERT_UNREACHABLE("Found unexpected frame during traversal");
+ return;
+ }
+
+ // This pattern of bits will be truthy if the item is baseline-aligned in
+ // this axis (in which case the exact pattern of bits will have some
+ // additional significance that doesn't matter here, but we do need to
+ // copy it over).
+ const auto baselineStateBits =
+ itemFromContainer.mState[aAxis] & ItemState::eAllBaselineBits;
+
+ if (subgridItem.IsSubgrid(subgridAxis)) {
+ // This item is in fact a nested subgrid. It shouldn't itself be
+ // baseline-aligned, but we need to make a recursive call to copy
+ // baseline metrics to its items.
+ MOZ_ASSERT(!baselineStateBits,
+ "subgrids themselves can't be baseline-aligned "
+ "(or self-aligned in any way) in their subgrid axis");
+ CopyBaselineMetricsToSubgridItemsHelper(
+ aAxis, aContainerWM, subgridItem.SubgridFrame(),
+ aContainerGridItems, aContainerGridItemsIdx);
+ } else if (baselineStateBits) {
+ // This item is a baseline-aligned grid item (in the subgrid that we're
+ // traversing). Copy over its baseline metrics.
+ subgridItem.mState[subgridAxis] |= baselineStateBits;
+ subgridItem.mBaselineOffset[subgridAxis] =
+ itemFromContainer.mBaselineOffset[aAxis];
+ }
+ }
+ }
+
+ /**
+ * This function here is responsible for propagating baseline-alignment
+ * metrics for subgrid-items from mGridItems over to the "canonical"
+ * GridItemInfo structs for those grid items (which live on the subgrid that
+ * owns them). The outermost parent grid *computes* those metrics as part of
+ * doing track sizing, but it does this using *temporary* GridItemInfo
+ * objects for any grid items that live in subgrids (aka subgrid items). So
+ * that's why we need to rescue this baseline-alignment information before
+ * those temporary objects are discarded.
+ *
+ * (The temporary subgrid-items all live at the end of mGridItems; they were
+ * appended there by CollectSubgridItemsForAxis(). So, it's important that
+ * we perform the exact same traversal that CollectSubgridItemsForAxis() did,
+ * in order to properly match up the temporary & canonical GridItemInfo
+ * objects for these subgrid items.)
+ */
+ // traversal that CollectSubgridItemsForAxis (and its recursive helper) does.
+ void CopyBaselineMetricsToSubgridItems(LogicalAxis aAxis,
+ size_t aOriginalLength) {
+ MOZ_ASSERT(aOriginalLength <= mGridItems.Length(),
+ "aOriginalLength is the length that mGridItems had *before* we "
+ "appended temporary copies of subgrid items to it, so it's not "
+ "possible for it to be more than the current length");
+
+ // This index 'subgridItemIdx' traverses the final portion of mGridItems,
+ // the portion that currently has temporary GridItemInfo structs that we
+ // built for the items that live in our subgrids. (Our caller is about to
+ // discard this temporary portion of mGridItems, and we're trying to
+ // transfer some baseline-alignment data to the canonical GridItemInfo
+ // structs before that happens.)
+ //
+ // Our recursive helper updates subgridItemIdx internally. When this index
+ // reaches mGridItems.Length(), we can stop looping; that means we've
+ // finished copying out all the data from these temporary structs.
+ size_t subgridItemIdx = aOriginalLength;
+
+ for (size_t i = 0;
+ (i < aOriginalLength && subgridItemIdx < mGridItems.Length()); i++) {
+ const auto& item = mGridItems[i];
+ if (item.IsSubgrid(aAxis)) {
+ CopyBaselineMetricsToSubgridItemsHelper(aAxis, mWM, item.SubgridFrame(),
+ mGridItems, subgridItemIdx);
+ }
+ }
+ }
+
+ Tracks& TracksFor(LogicalAxis aAxis) {
+ return aAxis == eLogicalAxisBlock ? mRows : mCols;
+ }
+ const Tracks& TracksFor(LogicalAxis aAxis) const {
+ return aAxis == eLogicalAxisBlock ? mRows : mCols;
+ }
+
+ CSSOrderAwareFrameIterator mIter;
+ const nsStylePosition* const mGridStyle;
+ Tracks mCols;
+ Tracks mRows;
+ TrackSizingFunctions mColFunctions;
+ TrackSizingFunctions mRowFunctions;
+ /**
+ * Info about each (normal flow) grid item.
+ */
+ nsTArray<GridItemInfo> mGridItems;
+ /**
+ * Info about each grid-aligned abs.pos. child.
+ */
+ nsTArray<GridItemInfo> mAbsPosItems;
+
+ /**
+ * @note mReflowInput may be null when using the 2nd ctor above. In this case
+ * we'll construct a dummy parent reflow input if we need it to calculate
+ * min/max-content contributions when sizing tracks.
+ */
+ const ReflowInput* const mReflowInput;
+ gfxContext& mRenderingContext;
+ nsGridContainerFrame* const mFrame;
+ SharedGridData* mSharedGridData; // [weak] owned by mFrame's first-in-flow.
+ /** Computed border+padding with mSkipSides applied. */
+ LogicalMargin mBorderPadding;
+ /**
+ * BStart of this fragment in "grid space" (i.e. the concatenation of content
+ * areas of all fragments). Equal to mRows.mSizes[mStartRow].mPosition,
+ * or, if this fragment starts after the last row, the ConsumedBSize().
+ */
+ nscoord mFragBStart;
+ /** The start row for this fragment. */
+ uint32_t mStartRow;
+ /**
+ * The start row for the next fragment, if any. If mNextFragmentStartRow ==
+ * mStartRow then there are no rows in this fragment.
+ */
+ uint32_t mNextFragmentStartRow;
+ /** Our tentative ApplySkipSides bits. */
+ LogicalSides mSkipSides;
+ const WritingMode mWM;
+ /** Initialized lazily, when we find the fragmentainer. */
+ bool mInFragmentainer;
+
+ private:
+ GridReflowInput(nsGridContainerFrame* aFrame, gfxContext& aRenderingContext,
+ const ReflowInput* aReflowInput,
+ const nsStylePosition* aGridStyle, const WritingMode& aWM)
+ : mIter(aFrame, FrameChildListID::Principal),
+ mGridStyle(aGridStyle),
+ mCols(eLogicalAxisInline),
+ mRows(eLogicalAxisBlock),
+ mColFunctions(mGridStyle->mGridTemplateColumns,
+ mGridStyle->mGridAutoColumns,
+ aFrame->IsSubgrid(eLogicalAxisInline)),
+ mRowFunctions(mGridStyle->mGridTemplateRows, mGridStyle->mGridAutoRows,
+ aFrame->IsSubgrid(eLogicalAxisBlock)),
+ mReflowInput(aReflowInput),
+ mRenderingContext(aRenderingContext),
+ mFrame(aFrame),
+ mSharedGridData(nullptr),
+ mBorderPadding(aWM),
+ mFragBStart(0),
+ mStartRow(0),
+ mNextFragmentStartRow(0),
+ mSkipSides(aFrame->GetWritingMode()),
+ mWM(aWM),
+ mInFragmentainer(false) {
+ MOZ_ASSERT(!aReflowInput || aReflowInput->mFrame == mFrame);
+ if (aReflowInput) {
+ mBorderPadding = aReflowInput->ComputedLogicalBorderPadding(mWM);
+ mSkipSides = aFrame->PreReflowBlockLevelLogicalSkipSides();
+ mBorderPadding.ApplySkipSides(mSkipSides);
+ }
+ mCols.mIsMasonry = aFrame->IsMasonry(eLogicalAxisInline);
+ mRows.mIsMasonry = aFrame->IsMasonry(eLogicalAxisBlock);
+ MOZ_ASSERT(!(mCols.mIsMasonry && mRows.mIsMasonry),
+ "can't have masonry layout in both axes");
+ }
+};
+
+using GridReflowInput = nsGridContainerFrame::GridReflowInput;
+
+/**
+ * The Grid implements grid item placement and the state of the grid -
+ * the size of the explicit/implicit grid, which cells are occupied etc.
+ */
+struct MOZ_STACK_CLASS nsGridContainerFrame::Grid {
+ explicit Grid(const Grid* aParentGrid = nullptr) : mParentGrid(aParentGrid) {}
+
+ /**
+ * Place all child frames into the grid and expand the (implicit) grid as
+ * needed. The allocated GridAreas are stored in the GridAreaProperty
+ * frame property on the child frame.
+ * @param aRepeatSizing the container's [min-|max-]*size - used to determine
+ * the number of repeat(auto-fill/fit) tracks.
+ */
+ void PlaceGridItems(GridReflowInput& aState,
+ const RepeatTrackSizingInput& aRepeatSizing);
+
+ void SubgridPlaceGridItems(GridReflowInput& aParentState, Grid* aParentGrid,
+ const GridItemInfo& aGridItem);
+
+ /**
+ * As above but for an abs.pos. child. Any 'auto' lines will be represented
+ * by kAutoLine in the LineRange result.
+ * @param aGridStart the first line in the final, but untranslated grid
+ * @param aGridEnd the last line in the final, but untranslated grid
+ */
+ LineRange ResolveAbsPosLineRange(const StyleGridLine& aStart,
+ const StyleGridLine& aEnd,
+ const LineNameMap& aNameMap,
+ LogicalAxis aAxis, uint32_t aExplicitGridEnd,
+ int32_t aGridStart, int32_t aGridEnd,
+ const nsStylePosition* aStyle);
+
+ /**
+ * Return a GridArea for abs.pos. item with non-auto lines placed at
+ * a definite line (1-based) with placement errors resolved. One or both
+ * positions may still be 'auto'.
+ * @param aChild the abs.pos. grid item to place
+ * @param aStyle the StylePosition() for the grid container
+ */
+ GridArea PlaceAbsPos(nsIFrame* aChild, const LineNameMap& aColLineNameMap,
+ const LineNameMap& aRowLineNameMap,
+ const nsStylePosition* aStyle);
+
+ /**
+ * Find the first column in row aLockedRow starting at aStartCol where aArea
+ * could be placed without overlapping other items. The returned column may
+ * cause aArea to overflow the current implicit grid bounds if placed there.
+ */
+ uint32_t FindAutoCol(uint32_t aStartCol, uint32_t aLockedRow,
+ const GridArea* aArea) const;
+
+ /**
+ * Place aArea in the first column (in row aArea->mRows.mStart) starting at
+ * aStartCol without overlapping other items. The resulting aArea may
+ * overflow the current implicit grid bounds.
+ * @param aClampMaxColLine the maximum allowed column line number (zero-based)
+ * Pre-condition: aArea->mRows.IsDefinite() is true.
+ * Post-condition: aArea->IsDefinite() is true.
+ */
+ void PlaceAutoCol(uint32_t aStartCol, GridArea* aArea,
+ uint32_t aClampMaxColLine) const;
+
+ /**
+ * Find the first row in column aLockedCol starting at aStartRow where aArea
+ * could be placed without overlapping other items. The returned row may
+ * cause aArea to overflow the current implicit grid bounds if placed there.
+ */
+ uint32_t FindAutoRow(uint32_t aLockedCol, uint32_t aStartRow,
+ const GridArea* aArea) const;
+
+ /**
+ * Place aArea in the first row (in column aArea->mCols.mStart) starting at
+ * aStartRow without overlapping other items. The resulting aArea may
+ * overflow the current implicit grid bounds.
+ * @param aClampMaxRowLine the maximum allowed row line number (zero-based)
+ * Pre-condition: aArea->mCols.IsDefinite() is true.
+ * Post-condition: aArea->IsDefinite() is true.
+ */
+ void PlaceAutoRow(uint32_t aStartRow, GridArea* aArea,
+ uint32_t aClampMaxRowLine) const;
+
+ /**
+ * Place aArea in the first column starting at aStartCol,aStartRow without
+ * causing it to overlap other items or overflow mGridColEnd.
+ * If there's no such column in aStartRow, continue in position 1,aStartRow+1.
+ * @param aClampMaxColLine the maximum allowed column line number (zero-based)
+ * @param aClampMaxRowLine the maximum allowed row line number (zero-based)
+ * Pre-condition: aArea->mCols.IsAuto() && aArea->mRows.IsAuto() is true.
+ * Post-condition: aArea->IsDefinite() is true.
+ */
+ void PlaceAutoAutoInRowOrder(uint32_t aStartCol, uint32_t aStartRow,
+ GridArea* aArea, uint32_t aClampMaxColLine,
+ uint32_t aClampMaxRowLine) const;
+
+ /**
+ * Place aArea in the first row starting at aStartCol,aStartRow without
+ * causing it to overlap other items or overflow mGridRowEnd.
+ * If there's no such row in aStartCol, continue in position aStartCol+1,1.
+ * @param aClampMaxColLine the maximum allowed column line number (zero-based)
+ * @param aClampMaxRowLine the maximum allowed row line number (zero-based)
+ * Pre-condition: aArea->mCols.IsAuto() && aArea->mRows.IsAuto() is true.
+ * Post-condition: aArea->IsDefinite() is true.
+ */
+ void PlaceAutoAutoInColOrder(uint32_t aStartCol, uint32_t aStartRow,
+ GridArea* aArea, uint32_t aClampMaxColLine,
+ uint32_t aClampMaxRowLine) const;
+
+ /**
+ * Return aLine if it's inside the aMin..aMax range (inclusive),
+ * otherwise return kAutoLine.
+ */
+ static int32_t AutoIfOutside(int32_t aLine, int32_t aMin, int32_t aMax) {
+ MOZ_ASSERT(aMin <= aMax);
+ if (aLine < aMin || aLine > aMax) {
+ return kAutoLine;
+ }
+ return aLine;
+ }
+
+ /**
+ * Inflate the implicit grid to include aArea.
+ * @param aArea may be definite or auto
+ */
+ void InflateGridFor(const GridArea& aArea) {
+ mGridColEnd = std::max(mGridColEnd, aArea.mCols.HypotheticalEnd());
+ mGridRowEnd = std::max(mGridRowEnd, aArea.mRows.HypotheticalEnd());
+ MOZ_ASSERT(mGridColEnd <= kTranslatedMaxLine &&
+ mGridRowEnd <= kTranslatedMaxLine);
+ }
+
+ /**
+ * Calculates the empty tracks in a repeat(auto-fit).
+ * @param aOutNumEmptyLines Outputs the number of tracks which are empty.
+ * @param aSizingFunctions Sizing functions for the relevant axis.
+ * @param aNumGridLines Number of grid lines for the relevant axis.
+ * @param aIsEmptyFunc Functor to check if a cell is empty. This should be
+ * mCellMap.IsColEmpty or mCellMap.IsRowEmpty, depending on the axis.
+ */
+ template <typename IsEmptyFuncT>
+ static Maybe<nsTArray<uint32_t>> CalculateAdjustForAutoFitElements(
+ uint32_t* aOutNumEmptyTracks, TrackSizingFunctions& aSizingFunctions,
+ uint32_t aNumGridLines, IsEmptyFuncT aIsEmptyFunc);
+
+ /**
+ * Return a line number for (non-auto) aLine, per:
+ * http://dev.w3.org/csswg/css-grid/#line-placement
+ * @param aLine style data for the line (must be non-auto)
+ * @param aNth a number of lines to find from aFromIndex, negative if the
+ * search should be in reverse order. In the case aLine has
+ * a specified line name, it's permitted to pass in zero which
+ * will be treated as one.
+ * @param aFromIndex the zero-based index to start counting from
+ * @param aLineNameList the explicit named lines
+ * @param aSide the axis+edge we're resolving names for (e.g. if we're
+ resolving a grid-row-start line, pass eLogicalSideBStart)
+ * @param aExplicitGridEnd the last line in the explicit grid
+ * @param aStyle the StylePosition() for the grid container
+ * @return a definite line (1-based), clamped to
+ * the mClampMinLine..mClampMaxLine range
+ */
+ int32_t ResolveLine(const StyleGridLine& aLine, int32_t aNth,
+ uint32_t aFromIndex, const LineNameMap& aNameMap,
+ LogicalSide aSide, uint32_t aExplicitGridEnd,
+ const nsStylePosition* aStyle);
+
+ /**
+ * Helper method for ResolveLineRange.
+ * @see ResolveLineRange
+ * @return a pair (start,end) of lines
+ */
+ typedef std::pair<int32_t, int32_t> LinePair;
+ LinePair ResolveLineRangeHelper(const StyleGridLine& aStart,
+ const StyleGridLine& aEnd,
+ const LineNameMap& aNameMap,
+ LogicalAxis aAxis, uint32_t aExplicitGridEnd,
+ const nsStylePosition* aStyle);
+
+ /**
+ * Return a LineRange based on the given style data. Non-auto lines
+ * are resolved to a definite line number (1-based) per:
+ * http://dev.w3.org/csswg/css-grid/#line-placement
+ * with placement errors corrected per:
+ * http://dev.w3.org/csswg/css-grid/#grid-placement-errors
+ * @param aStyle the StylePosition() for the grid container
+ * @param aStart style data for the start line
+ * @param aEnd style data for the end line
+ * @param aLineNameList the explicit named lines
+ * @param aAxis the axis we're resolving names in
+ * @param aExplicitGridEnd the last line in the explicit grid
+ * @param aStyle the StylePosition() for the grid container
+ */
+ LineRange ResolveLineRange(const StyleGridLine& aStart,
+ const StyleGridLine& aEnd,
+ const LineNameMap& aNameMap, LogicalAxis aAxis,
+ uint32_t aExplicitGridEnd,
+ const nsStylePosition* aStyle);
+
+ /**
+ * Return a GridArea with non-auto lines placed at a definite line (1-based)
+ * with placement errors resolved. One or both positions may still
+ * be 'auto'.
+ * @param aChild the grid item
+ * @param aStyle the StylePosition() for the grid container
+ */
+ GridArea PlaceDefinite(nsIFrame* aChild, const LineNameMap& aColLineNameMap,
+ const LineNameMap& aRowLineNameMap,
+ const nsStylePosition* aStyle);
+
+ bool HasImplicitNamedArea(nsAtom* aName) const {
+ return mAreas && mAreas->has(aName);
+ }
+
+ // Return true if aString ends in aSuffix and has at least one character
+ // before the suffix. Assign aIndex to where the suffix starts.
+ static bool IsNameWithSuffix(nsAtom* aString, const nsString& aSuffix,
+ uint32_t* aIndex) {
+ if (StringEndsWith(nsDependentAtomString(aString), aSuffix)) {
+ *aIndex = aString->GetLength() - aSuffix.Length();
+ return *aIndex != 0;
+ }
+ return false;
+ }
+
+ static bool IsNameWithEndSuffix(nsAtom* aString, uint32_t* aIndex) {
+ return IsNameWithSuffix(aString, u"-end"_ns, aIndex);
+ }
+
+ static bool IsNameWithStartSuffix(nsAtom* aString, uint32_t* aIndex) {
+ return IsNameWithSuffix(aString, u"-start"_ns, aIndex);
+ }
+
+ // Return the relevant parent LineNameMap for the given subgrid axis aAxis.
+ const LineNameMap* ParentLineMapForAxis(bool aIsOrthogonal,
+ LogicalAxis aAxis) const {
+ if (!mParentGrid) {
+ return nullptr;
+ }
+ bool isRows = aIsOrthogonal == (aAxis == eLogicalAxisInline);
+ return isRows ? mParentGrid->mRowNameMap : mParentGrid->mColNameMap;
+ }
+
+ void SetLineMaps(const LineNameMap* aColNameMap,
+ const LineNameMap* aRowNameMap) {
+ mColNameMap = aColNameMap;
+ mRowNameMap = aRowNameMap;
+ }
+
+ /**
+ * A CellMap holds state for each cell in the grid.
+ * It's row major. It's sparse in the sense that it only has enough rows to
+ * cover the last row that has a grid item. Each row only has enough entries
+ * to cover columns that are occupied *on that row*, i.e. it's not a full
+ * matrix covering the entire implicit grid. An absent Cell means that it's
+ * unoccupied by any grid item.
+ */
+ struct CellMap {
+ struct Cell {
+ constexpr Cell() : mIsOccupied(false) {}
+ bool mIsOccupied : 1;
+ };
+
+ void Fill(const GridArea& aGridArea) {
+ MOZ_ASSERT(aGridArea.IsDefinite());
+ MOZ_ASSERT(aGridArea.mRows.mStart < aGridArea.mRows.mEnd);
+ MOZ_ASSERT(aGridArea.mCols.mStart < aGridArea.mCols.mEnd);
+ const auto numRows = aGridArea.mRows.mEnd;
+ const auto numCols = aGridArea.mCols.mEnd;
+ mCells.EnsureLengthAtLeast(numRows);
+ for (auto i = aGridArea.mRows.mStart; i < numRows; ++i) {
+ nsTArray<Cell>& cellsInRow = mCells[i];
+ cellsInRow.EnsureLengthAtLeast(numCols);
+ for (auto j = aGridArea.mCols.mStart; j < numCols; ++j) {
+ cellsInRow[j].mIsOccupied = true;
+ }
+ }
+ }
+
+ uint32_t IsEmptyCol(uint32_t aCol) const {
+ for (auto& row : mCells) {
+ if (aCol < row.Length() && row[aCol].mIsOccupied) {
+ return false;
+ }
+ }
+ return true;
+ }
+ uint32_t IsEmptyRow(uint32_t aRow) const {
+ if (aRow >= mCells.Length()) {
+ return true;
+ }
+ for (const Cell& cell : mCells[aRow]) {
+ if (cell.mIsOccupied) {
+ return false;
+ }
+ }
+ return true;
+ }
+#ifdef DEBUG
+ void Dump() const {
+ const size_t numRows = mCells.Length();
+ for (size_t i = 0; i < numRows; ++i) {
+ const nsTArray<Cell>& cellsInRow = mCells[i];
+ const size_t numCols = cellsInRow.Length();
+ printf("%lu:\t", (unsigned long)i + 1);
+ for (size_t j = 0; j < numCols; ++j) {
+ printf(cellsInRow[j].mIsOccupied ? "X " : ". ");
+ }
+ printf("\n");
+ }
+ }
+#endif
+
+ nsTArray<nsTArray<Cell>> mCells;
+ };
+
+ /**
+ * State for each cell in the grid.
+ */
+ CellMap mCellMap;
+ /**
+ * @see HasImplicitNamedArea.
+ */
+ ImplicitNamedAreas* mAreas;
+ /**
+ * The last column grid line (1-based) in the explicit grid.
+ * (i.e. the number of explicit columns + 1)
+ */
+ uint32_t mExplicitGridColEnd;
+ /**
+ * The last row grid line (1-based) in the explicit grid.
+ * (i.e. the number of explicit rows + 1)
+ */
+ uint32_t mExplicitGridRowEnd;
+ // Same for the implicit grid, except these become zero-based after
+ // resolving definite lines.
+ uint32_t mGridColEnd;
+ uint32_t mGridRowEnd;
+
+ /**
+ * Offsets from the start of the implicit grid to the start of the translated
+ * explicit grid. They are zero if there are no implicit lines before 1,1.
+ * e.g. "grid-column: span 3 / 1" makes mExplicitGridOffsetCol = 3 and the
+ * corresponding GridArea::mCols will be 0 / 3 in the zero-based translated
+ * grid.
+ */
+ uint32_t mExplicitGridOffsetCol;
+ uint32_t mExplicitGridOffsetRow;
+
+ /**
+ * Our parent grid if any.
+ */
+ const Grid* mParentGrid;
+
+ /**
+ * Our LineNameMaps.
+ */
+ const LineNameMap* mColNameMap;
+ const LineNameMap* mRowNameMap;
+};
+
+/**
+ * Compute margin+border+padding for aGridItem.mFrame (a subgrid) and store it
+ * on its Subgrid property (and return that property).
+ * aPercentageBasis is in the grid item's writing-mode.
+ */
+static Subgrid* SubgridComputeMarginBorderPadding(
+ const GridItemInfo& aGridItem, const LogicalSize& aPercentageBasis) {
+ auto* subgridFrame = aGridItem.SubgridFrame();
+ auto cbWM = aGridItem.mFrame->GetParent()->GetWritingMode();
+ auto* subgrid = subgridFrame->GetProperty(Subgrid::Prop());
+ auto wm = subgridFrame->GetWritingMode();
+ auto pmPercentageBasis = cbWM.IsOrthogonalTo(wm) ? aPercentageBasis.BSize(wm)
+ : aPercentageBasis.ISize(wm);
+ SizeComputationInput sz(subgridFrame, nullptr, cbWM, pmPercentageBasis);
+ subgrid->mMarginBorderPadding =
+ sz.ComputedLogicalMargin(cbWM) + sz.ComputedLogicalBorderPadding(cbWM);
+
+ if (aGridItem.mFrame != subgridFrame) {
+ nsIScrollableFrame* scrollFrame = aGridItem.mFrame->GetScrollTargetFrame();
+ if (scrollFrame) {
+ MOZ_ASSERT(
+ sz.ComputedLogicalMargin(cbWM) == LogicalMargin(cbWM) &&
+ sz.ComputedLogicalBorder(cbWM) == LogicalMargin(cbWM),
+ "A scrolled inner frame should not have any margin or border!");
+
+ // Add the margin and border from the (outer) scroll frame.
+ SizeComputationInput szScrollFrame(aGridItem.mFrame, nullptr, cbWM,
+ pmPercentageBasis);
+ subgrid->mMarginBorderPadding +=
+ szScrollFrame.ComputedLogicalMargin(cbWM) +
+ szScrollFrame.ComputedLogicalBorder(cbWM);
+
+ nsMargin ssz = scrollFrame->GetActualScrollbarSizes();
+ subgrid->mMarginBorderPadding += LogicalMargin(cbWM, ssz);
+ }
+
+ if (aGridItem.mFrame->IsFieldSetFrame()) {
+ const auto* f = static_cast<nsFieldSetFrame*>(aGridItem.mFrame);
+ const auto* inner = f->GetInner();
+ auto wm = inner->GetWritingMode();
+ LogicalPoint pos = inner->GetLogicalPosition(aGridItem.mFrame->GetSize());
+ // The legend is always on the BStart side and it inflates the fieldset's
+ // "border area" size. The inner frame's b-start pos equals that size.
+ LogicalMargin offsets(wm, pos.B(wm), 0, 0, 0);
+ subgrid->mMarginBorderPadding += offsets.ConvertTo(cbWM, wm);
+ }
+ }
+ return subgrid;
+}
+
+static void CopyUsedTrackSizes(nsTArray<TrackSize>& aResult,
+ const nsGridContainerFrame* aUsedTrackSizesFrame,
+ const UsedTrackSizes* aUsedTrackSizes,
+ const nsGridContainerFrame* aSubgridFrame,
+ const Subgrid* aSubgrid,
+ LogicalAxis aSubgridAxis) {
+ MOZ_ASSERT(aSubgridFrame->ParentGridContainerForSubgrid() ==
+ aUsedTrackSizesFrame);
+ aResult.SetLength(aSubgridAxis == eLogicalAxisInline ? aSubgrid->mGridColEnd
+ : aSubgrid->mGridRowEnd);
+ auto parentAxis =
+ aSubgrid->mIsOrthogonal ? GetOrthogonalAxis(aSubgridAxis) : aSubgridAxis;
+ const auto& parentSizes = aUsedTrackSizes->mSizes[parentAxis];
+ MOZ_ASSERT(aUsedTrackSizes->mCanResolveLineRangeSize[parentAxis]);
+ if (parentSizes.IsEmpty()) {
+ return;
+ }
+ const auto& range = aSubgrid->mArea.LineRangeForAxis(parentAxis);
+ const auto cbwm = aUsedTrackSizesFrame->GetWritingMode();
+ const auto wm = aSubgridFrame->GetWritingMode();
+ // Recompute the MBP to resolve percentages against the resolved track sizes.
+ if (parentAxis == eLogicalAxisInline) {
+ // Find the subgrid's grid item frame in its parent grid container. This
+ // is usually the same as aSubgridFrame but it may also have a ScrollFrame,
+ // FieldSetFrame etc. We just loop until we see the first ancestor
+ // GridContainerFrame and pick the last frame we saw before that.
+ // Note that all subgrids are inside a parent (sub)grid container.
+ const nsIFrame* outerGridItemFrame = aSubgridFrame;
+ for (nsIFrame* parent = aSubgridFrame->GetParent();
+ parent != aUsedTrackSizesFrame; parent = parent->GetParent()) {
+ MOZ_ASSERT(!parent->IsGridContainerFrame());
+ outerGridItemFrame = parent;
+ }
+ auto sizeInAxis = range.ToLength(aUsedTrackSizes->mSizes[parentAxis]);
+ LogicalSize pmPercentageBasis =
+ aSubgrid->mIsOrthogonal ? LogicalSize(wm, nscoord(0), sizeInAxis)
+ : LogicalSize(wm, sizeInAxis, nscoord(0));
+ GridItemInfo info(const_cast<nsIFrame*>(outerGridItemFrame),
+ aSubgrid->mArea);
+ SubgridComputeMarginBorderPadding(info, pmPercentageBasis);
+ }
+ const LogicalMargin& mbp = aSubgrid->mMarginBorderPadding;
+ nscoord startMBP;
+ nscoord endMBP;
+ if (MOZ_LIKELY(cbwm.ParallelAxisStartsOnSameSide(parentAxis, wm))) {
+ startMBP = mbp.Start(parentAxis, cbwm);
+ endMBP = mbp.End(parentAxis, cbwm);
+ uint32_t i = range.mStart;
+ nscoord startPos = parentSizes[i].mPosition + startMBP;
+ for (auto& sz : aResult) {
+ sz = parentSizes[i++];
+ sz.mPosition -= startPos;
+ }
+ } else {
+ startMBP = mbp.End(parentAxis, cbwm);
+ endMBP = mbp.Start(parentAxis, cbwm);
+ uint32_t i = range.mEnd - 1;
+ const auto& parentEnd = parentSizes[i];
+ nscoord parentEndPos = parentEnd.mPosition + parentEnd.mBase - startMBP;
+ for (auto& sz : aResult) {
+ sz = parentSizes[i--];
+ sz.mPosition = parentEndPos - (sz.mPosition + sz.mBase);
+ }
+ }
+ auto& startTrack = aResult[0];
+ startTrack.mPosition = 0;
+ startTrack.mBase -= startMBP;
+ if (MOZ_UNLIKELY(startTrack.mBase < nscoord(0))) {
+ // Our MBP doesn't fit in the start track. Adjust the track position
+ // to maintain track alignment with our parent.
+ startTrack.mPosition = startTrack.mBase;
+ startTrack.mBase = nscoord(0);
+ }
+ auto& endTrack = aResult.LastElement();
+ endTrack.mBase -= endMBP;
+ if (MOZ_UNLIKELY(endTrack.mBase < nscoord(0))) {
+ endTrack.mBase = nscoord(0);
+ }
+}
+
+void nsGridContainerFrame::UsedTrackSizes::ResolveTrackSizesForAxis(
+ nsGridContainerFrame* aFrame, LogicalAxis aAxis, gfxContext& aRC) {
+ if (mCanResolveLineRangeSize[aAxis]) {
+ return;
+ }
+ if (!aFrame->IsSubgrid()) {
+ // We can't resolve sizes in this axis at this point. aFrame is the top grid
+ // container, which will store its final track sizes later once they're
+ // resolved in this axis (in GridReflowInput::CalculateTrackSizesForAxis).
+ // The single caller of this method only needs track sizes for
+ // calculating a CB size and it will treat it as indefinite when
+ // this happens.
+ return;
+ }
+ auto* parent = aFrame->ParentGridContainerForSubgrid();
+ auto* parentSizes = parent->GetUsedTrackSizes();
+ if (!parentSizes) {
+ parentSizes = new UsedTrackSizes();
+ parent->SetProperty(UsedTrackSizes::Prop(), parentSizes);
+ }
+ auto* subgrid = aFrame->GetProperty(Subgrid::Prop());
+ const auto parentAxis =
+ subgrid->mIsOrthogonal ? GetOrthogonalAxis(aAxis) : aAxis;
+ parentSizes->ResolveTrackSizesForAxis(parent, parentAxis, aRC);
+ if (!parentSizes->mCanResolveLineRangeSize[parentAxis]) {
+ if (aFrame->IsSubgrid(aAxis)) {
+ ResolveSubgridTrackSizesForAxis(aFrame, aAxis, subgrid, aRC,
+ NS_UNCONSTRAINEDSIZE);
+ }
+ return;
+ }
+ if (aFrame->IsSubgrid(aAxis)) {
+ CopyUsedTrackSizes(mSizes[aAxis], parent, parentSizes, aFrame, subgrid,
+ aAxis);
+ mCanResolveLineRangeSize[aAxis] = true;
+ } else {
+ const auto& range = subgrid->mArea.LineRangeForAxis(parentAxis);
+ nscoord contentBoxSize = range.ToLength(parentSizes->mSizes[parentAxis]);
+ auto parentWM = aFrame->GetParent()->GetWritingMode();
+ contentBoxSize -=
+ subgrid->mMarginBorderPadding.StartEnd(parentAxis, parentWM);
+ contentBoxSize = std::max(nscoord(0), contentBoxSize);
+ ResolveSubgridTrackSizesForAxis(aFrame, aAxis, subgrid, aRC,
+ contentBoxSize);
+ }
+}
+
+void nsGridContainerFrame::UsedTrackSizes::ResolveSubgridTrackSizesForAxis(
+ nsGridContainerFrame* aFrame, LogicalAxis aAxis, Subgrid* aSubgrid,
+ gfxContext& aRC, nscoord aContentBoxSize) {
+ GridReflowInput state(aFrame, aRC);
+ state.mGridItems = aSubgrid->mGridItems.Clone();
+ Grid grid;
+ grid.mGridColEnd = aSubgrid->mGridColEnd;
+ grid.mGridRowEnd = aSubgrid->mGridRowEnd;
+ state.CalculateTrackSizesForAxis(aAxis, grid, aContentBoxSize,
+ SizingConstraint::NoConstraint);
+ const auto& tracks = aAxis == eLogicalAxisInline ? state.mCols : state.mRows;
+ mSizes[aAxis].Assign(tracks.mSizes);
+ mCanResolveLineRangeSize[aAxis] = tracks.mCanResolveLineRangeSize;
+ MOZ_ASSERT(mCanResolveLineRangeSize[aAxis]);
+}
+
+void nsGridContainerFrame::GridReflowInput::CalculateTrackSizesForAxis(
+ LogicalAxis aAxis, const Grid& aGrid, nscoord aContentBoxSize,
+ SizingConstraint aConstraint) {
+ auto& tracks = aAxis == eLogicalAxisInline ? mCols : mRows;
+ const auto& sizingFunctions =
+ aAxis == eLogicalAxisInline ? mColFunctions : mRowFunctions;
+ const auto& gapStyle = aAxis == eLogicalAxisInline ? mGridStyle->mColumnGap
+ : mGridStyle->mRowGap;
+ if (tracks.mIsMasonry) {
+ // See comment on nsGridContainerFrame::MasonryLayout().
+ tracks.Initialize(sizingFunctions, gapStyle, 2, aContentBoxSize);
+ tracks.mCanResolveLineRangeSize = true;
+ return;
+ }
+ uint32_t gridEnd =
+ aAxis == eLogicalAxisInline ? aGrid.mGridColEnd : aGrid.mGridRowEnd;
+ Maybe<TrackSizingFunctions> fallbackTrackSizing;
+
+ bool useParentGaps = false;
+ const bool isSubgriddedAxis = mFrame->IsSubgrid(aAxis);
+ if (MOZ_LIKELY(!isSubgriddedAxis)) {
+ tracks.Initialize(sizingFunctions, gapStyle, gridEnd, aContentBoxSize);
+ } else {
+ tracks.mGridGap =
+ nsLayoutUtils::ResolveGapToLength(gapStyle, aContentBoxSize);
+ tracks.mContentBoxSize = aContentBoxSize;
+ const auto* subgrid = mFrame->GetProperty(Subgrid::Prop());
+ tracks.mSizes.SetLength(gridEnd);
+ auto* parent = mFrame->ParentGridContainerForSubgrid();
+ auto parentAxis = subgrid->mIsOrthogonal ? GetOrthogonalAxis(aAxis) : aAxis;
+ const auto* parentSizes = parent->GetUsedTrackSizes();
+ if (parentSizes && parentSizes->mCanResolveLineRangeSize[parentAxis]) {
+ CopyUsedTrackSizes(tracks.mSizes, parent, parentSizes, mFrame, subgrid,
+ aAxis);
+ useParentGaps = gapStyle.IsNormal();
+ } else {
+ fallbackTrackSizing.emplace(TrackSizingFunctions::ForSubgridFallback(
+ mFrame, subgrid, parent, parentAxis));
+ tracks.Initialize(*fallbackTrackSizing, gapStyle, gridEnd,
+ aContentBoxSize);
+ }
+ }
+
+ // We run the Track Sizing Algorithm in non-subgridded axes, and in some
+ // cases in a subgridded axis when our parent track sizes aren't resolved yet.
+ if (MOZ_LIKELY(!isSubgriddedAxis) || fallbackTrackSizing.isSome()) {
+ const size_t origGridItemCount = mGridItems.Length();
+ const bool hasSubgridItems = mFrame->HasSubgridItems(aAxis);
+ if (hasSubgridItems) {
+ AutoTArray<GridItemInfo, 8> collectedItems;
+ CollectSubgridItemsForAxis(aAxis, collectedItems);
+ mGridItems.AppendElements(collectedItems);
+ }
+ tracks.CalculateSizes(
+ *this, mGridItems,
+ fallbackTrackSizing ? *fallbackTrackSizing : sizingFunctions,
+ aContentBoxSize,
+ aAxis == eLogicalAxisInline ? &GridArea::mCols : &GridArea::mRows,
+ aConstraint);
+
+ if (hasSubgridItems &&
+ StaticPrefs::layout_css_grid_subgrid_baselines_enabled()) {
+ // If any of the subgrid items are baseline-aligned, we've just recorded
+ // their baseline-alignment offsets in our own copy of their GridItemInfo
+ // structs. Before we get rid of those copies (via TruncateLength), we
+ // have to copy these offsets back to the subgrids' versions of the
+ // GridItemInfo structs.
+ //
+ // XXXdholbert This new behavior is behind a pref due to bug 1871719.
+ CopyBaselineMetricsToSubgridItems(aAxis, origGridItemCount);
+ }
+ mGridItems.TruncateLength(origGridItemCount);
+ }
+ if (isSubgriddedAxis) {
+ // XXXdholbert This is a bit hacky, but this is something that
+ // tracks.CalculateSizes does internally (unconditionally, if there are
+ // baseline-aligned items), and it seems like subgrids need to do it too,
+ // or else they hit the "unexpected baseline subtree alignment"
+ // fatal-assert when aligning their children with the baseline-alignment
+ // information that they received from the outer grid.
+ // (This might be entirely unnecessary? Aside from the default ::AUTO
+ // value, it looks like the ::First entry is always set to ::START and
+ // the ::Last entry is always set to ::END...)
+ tracks.mBaselineSubtreeAlign[BaselineSharingGroup::First] =
+ StyleAlignFlags::START;
+ tracks.mBaselineSubtreeAlign[BaselineSharingGroup::Last] =
+ StyleAlignFlags::END;
+ }
+
+ if (aContentBoxSize != NS_UNCONSTRAINEDSIZE) {
+ auto alignment = mGridStyle->UsedContentAlignment(tracks.mAxis);
+ tracks.AlignJustifyContent(mGridStyle, alignment, mWM, aContentBoxSize,
+ isSubgriddedAxis);
+ } else if (!useParentGaps) {
+ const nscoord gridGap = tracks.mGridGap;
+ nscoord pos = 0;
+ for (TrackSize& sz : tracks.mSizes) {
+ sz.mPosition = pos;
+ pos += sz.mBase + gridGap;
+ }
+ }
+
+ if (aConstraint == SizingConstraint::NoConstraint &&
+ (mFrame->HasSubgridItems() || mFrame->IsSubgrid())) {
+ mFrame->StoreUsedTrackSizes(aAxis, tracks.mSizes);
+ }
+
+ // positions and sizes are now final
+ tracks.mCanResolveLineRangeSize = true;
+}
+
+void nsGridContainerFrame::GridReflowInput::CalculateTrackSizes(
+ const Grid& aGrid, const LogicalSize& aContentBox,
+ SizingConstraint aConstraint) {
+ CalculateTrackSizesForAxis(eLogicalAxisInline, aGrid, aContentBox.ISize(mWM),
+ aConstraint);
+ CalculateTrackSizesForAxis(eLogicalAxisBlock, aGrid, aContentBox.BSize(mWM),
+ aConstraint);
+}
+
+// Align an item's margin box in its aAxis inside aCBSize.
+static void AlignJustifySelf(StyleAlignFlags aAlignment, LogicalAxis aAxis,
+ AlignJustifyFlags aFlags, nscoord aBaselineAdjust,
+ nscoord aCBSize, const ReflowInput& aRI,
+ const LogicalSize& aChildSize,
+ LogicalPoint* aPos) {
+ MOZ_ASSERT(aAlignment != StyleAlignFlags::AUTO,
+ "unexpected 'auto' "
+ "computed value for normal flow grid item");
+
+ // NOTE: this is the resulting frame offset (border box).
+ nscoord offset = CSSAlignUtils::AlignJustifySelf(
+ aAlignment, aAxis, aFlags, aBaselineAdjust, aCBSize, aRI, aChildSize);
+
+ // Set the position (aPos) for the requested alignment.
+ if (offset != 0) {
+ WritingMode wm = aRI.GetWritingMode();
+ nscoord& pos = aAxis == eLogicalAxisBlock ? aPos->B(wm) : aPos->I(wm);
+ pos += MOZ_LIKELY(aFlags & AlignJustifyFlags::SameSide) ? offset : -offset;
+ }
+}
+
+static void AlignSelf(const nsGridContainerFrame::GridItemInfo& aGridItem,
+ StyleAlignFlags aAlignSelf, nscoord aCBSize,
+ const WritingMode aCBWM, const ReflowInput& aRI,
+ const LogicalSize& aSize, AlignJustifyFlags aFlags,
+ LogicalPoint* aPos) {
+ AlignJustifyFlags flags = aFlags;
+ if (aAlignSelf & StyleAlignFlags::SAFE) {
+ flags |= AlignJustifyFlags::OverflowSafe;
+ }
+ aAlignSelf &= ~StyleAlignFlags::FLAG_BITS;
+
+ WritingMode childWM = aRI.GetWritingMode();
+ if (aCBWM.ParallelAxisStartsOnSameSide(eLogicalAxisBlock, childWM)) {
+ flags |= AlignJustifyFlags::SameSide;
+ }
+
+ // Grid's 'align-self' axis is never parallel to the container's inline axis.
+ if (aAlignSelf == StyleAlignFlags::LEFT ||
+ aAlignSelf == StyleAlignFlags::RIGHT) {
+ aAlignSelf = StyleAlignFlags::START;
+ }
+ if (MOZ_LIKELY(aAlignSelf == StyleAlignFlags::NORMAL)) {
+ aAlignSelf = StyleAlignFlags::STRETCH;
+ }
+
+ nscoord baselineAdjust = 0;
+ if (aAlignSelf == StyleAlignFlags::BASELINE ||
+ aAlignSelf == StyleAlignFlags::LAST_BASELINE) {
+ aAlignSelf = aGridItem.GetSelfBaseline(aAlignSelf, eLogicalAxisBlock,
+ &baselineAdjust);
+ // Adjust the baseline alignment value if the baseline affects the opposite
+ // side of what AlignJustifySelf expects.
+ auto state = aGridItem.mState[eLogicalAxisBlock];
+ if (aAlignSelf == StyleAlignFlags::LAST_BASELINE &&
+ !GridItemInfo::BaselineAlignmentAffectsEndSide(state)) {
+ aAlignSelf = StyleAlignFlags::BASELINE;
+ } else if (aAlignSelf == StyleAlignFlags::BASELINE &&
+ GridItemInfo::BaselineAlignmentAffectsEndSide(state)) {
+ aAlignSelf = StyleAlignFlags::LAST_BASELINE;
+ }
+ }
+
+ bool isOrthogonal = aCBWM.IsOrthogonalTo(childWM);
+ LogicalAxis axis = isOrthogonal ? eLogicalAxisInline : eLogicalAxisBlock;
+ AlignJustifySelf(aAlignSelf, axis, flags, baselineAdjust, aCBSize, aRI, aSize,
+ aPos);
+}
+
+static void JustifySelf(const nsGridContainerFrame::GridItemInfo& aGridItem,
+ StyleAlignFlags aJustifySelf, nscoord aCBSize,
+ const WritingMode aCBWM, const ReflowInput& aRI,
+ const LogicalSize& aSize, AlignJustifyFlags aFlags,
+ LogicalPoint* aPos) {
+ AlignJustifyFlags flags = aFlags;
+ if (aJustifySelf & StyleAlignFlags::SAFE) {
+ flags |= AlignJustifyFlags::OverflowSafe;
+ }
+ aJustifySelf &= ~StyleAlignFlags::FLAG_BITS;
+
+ WritingMode childWM = aRI.GetWritingMode();
+ if (aCBWM.ParallelAxisStartsOnSameSide(eLogicalAxisInline, childWM)) {
+ flags |= AlignJustifyFlags::SameSide;
+ }
+
+ if (MOZ_LIKELY(aJustifySelf == StyleAlignFlags::NORMAL)) {
+ aJustifySelf = StyleAlignFlags::STRETCH;
+ }
+
+ nscoord baselineAdjust = 0;
+ // Grid's 'justify-self' axis is always parallel to the container's inline
+ // axis, so justify-self:left|right always applies.
+ if (aJustifySelf == StyleAlignFlags::LEFT) {
+ aJustifySelf =
+ aCBWM.IsBidiLTR() ? StyleAlignFlags::START : StyleAlignFlags::END;
+ } else if (aJustifySelf == StyleAlignFlags::RIGHT) {
+ aJustifySelf =
+ aCBWM.IsBidiLTR() ? StyleAlignFlags::END : StyleAlignFlags::START;
+ } else if (aJustifySelf == StyleAlignFlags::BASELINE ||
+ aJustifySelf == StyleAlignFlags::LAST_BASELINE) {
+ aJustifySelf = aGridItem.GetSelfBaseline(aJustifySelf, eLogicalAxisInline,
+ &baselineAdjust);
+ // Adjust the baseline alignment value if the baseline affects the opposite
+ // side of what AlignJustifySelf expects.
+ auto state = aGridItem.mState[eLogicalAxisInline];
+ if (aJustifySelf == StyleAlignFlags::LAST_BASELINE &&
+ !GridItemInfo::BaselineAlignmentAffectsEndSide(state)) {
+ aJustifySelf = StyleAlignFlags::BASELINE;
+ } else if (aJustifySelf == StyleAlignFlags::BASELINE &&
+ GridItemInfo::BaselineAlignmentAffectsEndSide(state)) {
+ aJustifySelf = StyleAlignFlags::LAST_BASELINE;
+ }
+ }
+
+ bool isOrthogonal = aCBWM.IsOrthogonalTo(childWM);
+ LogicalAxis axis = isOrthogonal ? eLogicalAxisBlock : eLogicalAxisInline;
+ AlignJustifySelf(aJustifySelf, axis, flags, baselineAdjust, aCBSize, aRI,
+ aSize, aPos);
+}
+
+static StyleAlignFlags GetAlignJustifyValue(StyleAlignFlags aAlignment,
+ const WritingMode aWM,
+ const bool aIsAlign,
+ bool* aOverflowSafe) {
+ *aOverflowSafe = bool(aAlignment & StyleAlignFlags::SAFE);
+ aAlignment &= ~StyleAlignFlags::FLAG_BITS;
+
+ // Map some alignment values to 'start' / 'end'.
+ if (aAlignment == StyleAlignFlags::LEFT ||
+ aAlignment == StyleAlignFlags::RIGHT) {
+ if (aIsAlign) {
+ // Grid's 'align-content' axis is never parallel to the inline axis.
+ return StyleAlignFlags::START;
+ }
+ bool isStart = aWM.IsBidiLTR() == (aAlignment == StyleAlignFlags::LEFT);
+ return isStart ? StyleAlignFlags::START : StyleAlignFlags::END;
+ }
+ if (aAlignment == StyleAlignFlags::FLEX_START) {
+ return StyleAlignFlags::START; // same as 'start' for Grid
+ }
+ if (aAlignment == StyleAlignFlags::FLEX_END) {
+ return StyleAlignFlags::END; // same as 'end' for Grid
+ }
+ return aAlignment;
+}
+
+static Maybe<StyleAlignFlags> GetAlignJustifyFallbackIfAny(
+ const StyleContentDistribution& aDistribution, const WritingMode aWM,
+ const bool aIsAlign, bool* aOverflowSafe) {
+ // TODO: Eventually this should look at aDistribution's fallback alignment,
+ // see https://github.com/w3c/csswg-drafts/issues/1002.
+ if (aDistribution.primary == StyleAlignFlags::STRETCH ||
+ aDistribution.primary == StyleAlignFlags::SPACE_BETWEEN) {
+ return Some(StyleAlignFlags::START);
+ }
+ if (aDistribution.primary == StyleAlignFlags::SPACE_AROUND ||
+ aDistribution.primary == StyleAlignFlags::SPACE_EVENLY) {
+ return Some(StyleAlignFlags::CENTER);
+ }
+ return Nothing();
+}
+
+//----------------------------------------------------------------------
+
+// Frame class boilerplate
+// =======================
+
+NS_QUERYFRAME_HEAD(nsGridContainerFrame)
+ NS_QUERYFRAME_ENTRY(nsGridContainerFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
+
+NS_IMPL_FRAMEARENA_HELPERS(nsGridContainerFrame)
+
+nsContainerFrame* NS_NewGridContainerFrame(PresShell* aPresShell,
+ ComputedStyle* aStyle) {
+ return new (aPresShell)
+ nsGridContainerFrame(aStyle, aPresShell->GetPresContext());
+}
+
+//----------------------------------------------------------------------
+
+// nsGridContainerFrame Method Implementations
+// ===========================================
+
+/*static*/ const nsRect& nsGridContainerFrame::GridItemCB(nsIFrame* aChild) {
+ MOZ_ASSERT(aChild->IsAbsolutelyPositioned());
+ nsRect* cb = aChild->GetProperty(GridItemContainingBlockRect());
+ MOZ_ASSERT(cb,
+ "this method must only be called on grid items, and the grid "
+ "container should've reflowed this item by now and set up cb");
+ return *cb;
+}
+
+void nsGridContainerFrame::AddImplicitNamedAreasInternal(
+ LineNameList& aNameList,
+ nsGridContainerFrame::ImplicitNamedAreas*& aAreas) {
+ for (const auto& nameIdent : aNameList.AsSpan()) {
+ nsAtom* name = nameIdent.AsAtom();
+ uint32_t indexOfSuffix;
+ if (Grid::IsNameWithStartSuffix(name, &indexOfSuffix) ||
+ Grid::IsNameWithEndSuffix(name, &indexOfSuffix)) {
+ // Extract the name that was found earlier.
+ nsDependentSubstring areaName(nsDependentAtomString(name), 0,
+ indexOfSuffix);
+
+ // Lazily create the ImplicitNamedAreas.
+ if (!aAreas) {
+ aAreas = new nsGridContainerFrame::ImplicitNamedAreas;
+ SetProperty(nsGridContainerFrame::ImplicitNamedAreasProperty(), aAreas);
+ }
+
+ RefPtr<nsAtom> name = NS_Atomize(areaName);
+ auto addPtr = aAreas->lookupForAdd(name);
+ if (!addPtr) {
+ if (!aAreas->add(addPtr, name,
+ nsGridContainerFrame::NamedArea{
+ StyleAtom(do_AddRef(name)), {0, 0}, {0, 0}})) {
+ MOZ_CRASH("OOM while adding grid name lists");
+ }
+ }
+ }
+ }
+}
+
+void nsGridContainerFrame::AddImplicitNamedAreas(
+ Span<LineNameList> aLineNameLists) {
+ // http://dev.w3.org/csswg/css-grid/#implicit-named-areas
+ // Note: recording these names for fast lookup later is just an optimization.
+ ImplicitNamedAreas* areas = GetImplicitNamedAreas();
+ const uint32_t len = std::min(aLineNameLists.Length(), size_t(kMaxLine));
+ for (uint32_t i = 0; i < len; ++i) {
+ AddImplicitNamedAreasInternal(aLineNameLists[i], areas);
+ }
+}
+
+void nsGridContainerFrame::AddImplicitNamedAreas(
+ Span<StyleLineNameListValue> aLineNameList) {
+ // http://dev.w3.org/csswg/css-grid/#implicit-named-areas
+ // Note: recording these names for fast lookup later is just an optimization.
+ uint32_t count = 0;
+ ImplicitNamedAreas* areas = GetImplicitNamedAreas();
+ for (const auto& nameList : aLineNameList) {
+ if (nameList.IsRepeat()) {
+ for (const auto& repeatNameList :
+ nameList.AsRepeat().line_names.AsSpan()) {
+ AddImplicitNamedAreasInternal(repeatNameList, areas);
+ ++count;
+ }
+ } else {
+ MOZ_ASSERT(nameList.IsLineNames());
+ AddImplicitNamedAreasInternal(nameList.AsLineNames(), areas);
+ ++count;
+ }
+
+ if (count >= size_t(kMaxLine)) {
+ break;
+ }
+ }
+}
+
+void nsGridContainerFrame::InitImplicitNamedAreas(
+ const nsStylePosition* aStyle) {
+ ImplicitNamedAreas* areas = GetImplicitNamedAreas();
+ if (areas) {
+ // Clear it, but reuse the hashtable itself for now. We'll remove it
+ // below if it isn't needed anymore.
+ areas->clear();
+ }
+ auto Add = [&](const GridTemplate& aTemplate, bool aIsSubgrid) {
+ AddImplicitNamedAreas(aTemplate.LineNameLists(aIsSubgrid));
+ for (auto& value : aTemplate.TrackListValues()) {
+ if (value.IsTrackRepeat()) {
+ AddImplicitNamedAreas(value.AsTrackRepeat().line_names.AsSpan());
+ }
+ }
+
+ if (aIsSubgrid && aTemplate.IsSubgrid()) {
+ // For subgrid, |aTemplate.LineNameLists(aIsSubgrid)| returns an empty
+ // list so we have to manually add each item.
+ AddImplicitNamedAreas(aTemplate.AsSubgrid()->line_names.AsSpan());
+ }
+ };
+ Add(aStyle->mGridTemplateColumns, IsSubgrid(eLogicalAxisInline));
+ Add(aStyle->mGridTemplateRows, IsSubgrid(eLogicalAxisBlock));
+ if (areas && areas->count() == 0) {
+ RemoveProperty(ImplicitNamedAreasProperty());
+ }
+}
+
+int32_t nsGridContainerFrame::Grid::ResolveLine(
+ const StyleGridLine& aLine, int32_t aNth, uint32_t aFromIndex,
+ const LineNameMap& aNameMap, LogicalSide aSide, uint32_t aExplicitGridEnd,
+ const nsStylePosition* aStyle) {
+ MOZ_ASSERT(!aLine.IsAuto());
+ int32_t line = 0;
+ if (aLine.LineName()->IsEmpty()) {
+ MOZ_ASSERT(aNth != 0, "css-grid 9.2: <integer> must not be zero.");
+ line = int32_t(aFromIndex) + aNth;
+ } else {
+ if (aNth == 0) {
+ // <integer> was omitted; treat it as 1.
+ aNth = 1;
+ }
+ bool isNameOnly = !aLine.is_span && aLine.line_num == 0;
+ if (isNameOnly) {
+ AutoTArray<uint32_t, 16> implicitLines;
+ aNameMap.FindNamedAreas(aLine.ident.AsAtom(), aSide, implicitLines);
+ if (!implicitLines.IsEmpty() ||
+ aNameMap.HasImplicitNamedArea(aLine.LineName())) {
+ // aName is a named area - look for explicit lines named
+ // <name>-start/-end depending on which side we're resolving.
+ // http://dev.w3.org/csswg/css-grid/#grid-placement-slot
+ nsAutoString lineName(nsDependentAtomString(aLine.LineName()));
+ if (IsStart(aSide)) {
+ lineName.AppendLiteral("-start");
+ } else {
+ lineName.AppendLiteral("-end");
+ }
+ RefPtr<nsAtom> name = NS_Atomize(lineName);
+ line = aNameMap.FindNamedLine(name, &aNth, aFromIndex, implicitLines);
+ }
+ }
+
+ if (line == 0) {
+ // If LineName() ends in -start/-end, try the prefix as a named area.
+ AutoTArray<uint32_t, 16> implicitLines;
+ uint32_t index;
+ bool useStart = IsNameWithStartSuffix(aLine.LineName(), &index);
+ if (useStart || IsNameWithEndSuffix(aLine.LineName(), &index)) {
+ auto side = MakeLogicalSide(
+ GetAxis(aSide), useStart ? eLogicalEdgeStart : eLogicalEdgeEnd);
+ RefPtr<nsAtom> name = NS_Atomize(nsDependentSubstring(
+ nsDependentAtomString(aLine.LineName()), 0, index));
+ aNameMap.FindNamedAreas(name, side, implicitLines);
+ }
+ line = aNameMap.FindNamedLine(aLine.LineName(), &aNth, aFromIndex,
+ implicitLines);
+ }
+
+ if (line == 0) {
+ MOZ_ASSERT(aNth != 0, "we found all N named lines but 'line' is zero!");
+ int32_t edgeLine;
+ if (aLine.is_span) {
+ // http://dev.w3.org/csswg/css-grid/#grid-placement-span-int
+ // 'span <custom-ident> N'
+ edgeLine = IsStart(aSide) ? 1 : aExplicitGridEnd;
+ } else {
+ // http://dev.w3.org/csswg/css-grid/#grid-placement-int
+ // '<custom-ident> N'
+ edgeLine = aNth < 0 ? 1 : aExplicitGridEnd;
+ }
+ // "If not enough lines with that name exist, all lines in the implicit
+ // grid are assumed to have that name..."
+ line = edgeLine + aNth;
+ }
+ }
+ // Note: at this point, 'line' might be outside of aNameMap's allowed range,
+ // [mClampMinLin, mClampMaxLine]. This is fine; we'll clamp once we've
+ // resolved *both* the start and end line -- in particular, we clamp in
+ // ResolveLineRange(). If we clamped here, it'd be premature -- if one line
+ // is definite and the other is specified as a span to some named line
+ // (i.e. we need to perform a name-search that starts from the definite
+ // line), then it matters whether we clamp the definite line before or after
+ // that search. See https://bugzilla.mozilla.org/show_bug.cgi?id=1800566#c6
+ // for more.
+ return line;
+}
+
+nsGridContainerFrame::Grid::LinePair
+nsGridContainerFrame::Grid::ResolveLineRangeHelper(
+ const StyleGridLine& aStart, const StyleGridLine& aEnd,
+ const LineNameMap& aNameMap, LogicalAxis aAxis, uint32_t aExplicitGridEnd,
+ const nsStylePosition* aStyle) {
+ MOZ_ASSERT(int32_t(kAutoLine) > kMaxLine);
+
+ if (aStart.is_span) {
+ if (aEnd.is_span || aEnd.IsAuto()) {
+ // http://dev.w3.org/csswg/css-grid/#grid-placement-errors
+ if (aStart.LineName()->IsEmpty()) {
+ // span <integer> / span *
+ // span <integer> / auto
+ return LinePair(kAutoLine, aStart.line_num);
+ }
+ // span <custom-ident> / span *
+ // span <custom-ident> / auto
+ return LinePair(kAutoLine, 1); // XXX subgrid explicit size instead of 1?
+ }
+
+ uint32_t from = aEnd.line_num < 0 ? aExplicitGridEnd + 1 : 0;
+ auto end = ResolveLine(aEnd, aEnd.line_num, from, aNameMap,
+ MakeLogicalSide(aAxis, eLogicalEdgeEnd),
+ aExplicitGridEnd, aStyle);
+ int32_t span = aStart.line_num == 0 ? 1 : aStart.line_num;
+ if (end <= 1) {
+ // The end is at or before the first explicit line, thus all lines before
+ // it match <custom-ident> since they're implicit.
+ int32_t start = std::max(end - span, aNameMap.mClampMinLine);
+ return LinePair(start, end);
+ }
+ auto start = ResolveLine(aStart, -span, end, aNameMap,
+ MakeLogicalSide(aAxis, eLogicalEdgeStart),
+ aExplicitGridEnd, aStyle);
+ return LinePair(start, end);
+ }
+
+ int32_t start = kAutoLine;
+ if (aStart.IsAuto()) {
+ if (aEnd.IsAuto()) {
+ // auto / auto
+ return LinePair(start, 1); // XXX subgrid explicit size instead of 1?
+ }
+ if (aEnd.is_span) {
+ if (aEnd.LineName()->IsEmpty()) {
+ // auto / span <integer>
+ MOZ_ASSERT(aEnd.line_num != 0);
+ return LinePair(start, aEnd.line_num);
+ }
+ // http://dev.w3.org/csswg/css-grid/#grid-placement-errors
+ // auto / span <custom-ident>
+ return LinePair(start, 1); // XXX subgrid explicit size instead of 1?
+ }
+ } else {
+ uint32_t from = aStart.line_num < 0 ? aExplicitGridEnd + 1 : 0;
+ start = ResolveLine(aStart, aStart.line_num, from, aNameMap,
+ MakeLogicalSide(aAxis, eLogicalEdgeStart),
+ aExplicitGridEnd, aStyle);
+ if (aEnd.IsAuto()) {
+ // A "definite line / auto" should resolve the auto to 'span 1'.
+ // The error handling in ResolveLineRange will make that happen and also
+ // clamp the end line correctly if we return "start / start".
+ return LinePair(start, start);
+ }
+ }
+
+ uint32_t from;
+ int32_t nth = aEnd.line_num == 0 ? 1 : aEnd.line_num;
+ if (aEnd.is_span) {
+ if (MOZ_UNLIKELY(start < 0)) {
+ if (aEnd.LineName()->IsEmpty()) {
+ return LinePair(start, start + nth);
+ }
+ from = 0;
+ } else {
+ if (start >= int32_t(aExplicitGridEnd)) {
+ // The start is at or after the last explicit line, thus all lines
+ // after it match <custom-ident> since they're implicit.
+ return LinePair(start, std::min(start + nth, aNameMap.mClampMaxLine));
+ }
+ from = start;
+ }
+ } else {
+ from = aEnd.line_num < 0 ? aExplicitGridEnd + 1 : 0;
+ }
+ auto end = ResolveLine(aEnd, nth, from, aNameMap,
+ MakeLogicalSide(aAxis, eLogicalEdgeEnd),
+ aExplicitGridEnd, aStyle);
+ if (start == int32_t(kAutoLine)) {
+ // auto / definite line
+ start = std::max(aNameMap.mClampMinLine, end - 1);
+ }
+ return LinePair(start, end);
+}
+
+nsGridContainerFrame::LineRange nsGridContainerFrame::Grid::ResolveLineRange(
+ const StyleGridLine& aStart, const StyleGridLine& aEnd,
+ const LineNameMap& aNameMap, LogicalAxis aAxis, uint32_t aExplicitGridEnd,
+ const nsStylePosition* aStyle) {
+ LinePair r = ResolveLineRangeHelper(aStart, aEnd, aNameMap, aAxis,
+ aExplicitGridEnd, aStyle);
+ MOZ_ASSERT(r.second != int32_t(kAutoLine));
+
+ if (r.first == int32_t(kAutoLine)) {
+ // r.second is a span, clamp it to aNameMap.mClampMaxLine - 1 so that
+ // the returned range has a HypotheticalEnd <= aNameMap.mClampMaxLine.
+ // http://dev.w3.org/csswg/css-grid/#overlarge-grids
+ r.second = std::min(r.second, aNameMap.mClampMaxLine - 1);
+ } else {
+ // Clamp the lines to be within our limits, per
+ // https://www.w3.org/TR/css-grid-2/#overlarge-grids
+ // Note that our limits here might come from the [kMinLine, kMaxLine]
+ // extremes; or, they might just be the bounds of a subgrid's explicit
+ // grid. We use the same clamping approach either way, per
+ // https://www.w3.org/TR/css-grid-2/#subgrid-implicit ("using the same
+ // procedure as for clamping placement in an overly-large grid").
+ //
+ // Note that these two clamped() assignments might collapse our range to
+ // have both edges pointing at the same line (spanning 0 tracks); this
+ // might happen here if e.g. r.first were mClampMaxLine, and r.second gets
+ // clamped from some higher number down to mClampMaxLine. We'll handle this
+ // by shifting the inner line (r.first in this hypothetical) inwards by 1,
+ // in the #grid-placement-errors section; that achieves the outcome of
+ // the #overlarge-grids clamping spec text that says "its span must be
+ // truncated to 1" when clamping an item that was completely outside the
+ // limits.
+ r.first = clamped(r.first, aNameMap.mClampMinLine, aNameMap.mClampMaxLine);
+ r.second =
+ clamped(r.second, aNameMap.mClampMinLine, aNameMap.mClampMaxLine);
+
+ // Handle grid placement errors.
+ // http://dev.w3.org/csswg/css-grid/#grid-placement-errors
+ if (r.first > r.second) {
+ std::swap(r.first, r.second);
+ } else if (r.first == r.second) {
+ // (This is #grid-placement-errors fixup, but it's also where we ensure
+ // that any #overlarge-grids fixup that we did above will end up
+ // truncating the range to a span of 1 rather than 0 -- i.e. sliding
+ // inwards if needed.)
+ if (MOZ_UNLIKELY(r.first == aNameMap.mClampMaxLine)) {
+ r.first = aNameMap.mClampMaxLine - 1;
+ }
+ r.second = r.first + 1;
+ }
+ }
+ return LineRange(r.first, r.second);
+}
+
+nsGridContainerFrame::GridArea nsGridContainerFrame::Grid::PlaceDefinite(
+ nsIFrame* aChild, const LineNameMap& aColLineNameMap,
+ const LineNameMap& aRowLineNameMap, const nsStylePosition* aStyle) {
+ const nsStylePosition* itemStyle = aChild->StylePosition();
+ return GridArea(
+ ResolveLineRange(itemStyle->mGridColumnStart, itemStyle->mGridColumnEnd,
+ aColLineNameMap, eLogicalAxisInline, mExplicitGridColEnd,
+ aStyle),
+ ResolveLineRange(itemStyle->mGridRowStart, itemStyle->mGridRowEnd,
+ aRowLineNameMap, eLogicalAxisBlock, mExplicitGridRowEnd,
+ aStyle));
+}
+
+nsGridContainerFrame::LineRange
+nsGridContainerFrame::Grid::ResolveAbsPosLineRange(
+ const StyleGridLine& aStart, const StyleGridLine& aEnd,
+ const LineNameMap& aNameMap, LogicalAxis aAxis, uint32_t aExplicitGridEnd,
+ int32_t aGridStart, int32_t aGridEnd, const nsStylePosition* aStyle) {
+ if (aStart.IsAuto()) {
+ if (aEnd.IsAuto()) {
+ return LineRange(kAutoLine, kAutoLine);
+ }
+ uint32_t from = aEnd.line_num < 0 ? aExplicitGridEnd + 1 : 0;
+ int32_t end = ResolveLine(aEnd, aEnd.line_num, from, aNameMap,
+ MakeLogicalSide(aAxis, eLogicalEdgeEnd),
+ aExplicitGridEnd, aStyle);
+ if (aEnd.is_span) {
+ ++end;
+ }
+ // A line outside the existing grid is treated as 'auto' for abs.pos (10.1).
+ end = AutoIfOutside(end, aGridStart, aGridEnd);
+ return LineRange(kAutoLine, end);
+ }
+
+ if (aEnd.IsAuto()) {
+ uint32_t from = aStart.line_num < 0 ? aExplicitGridEnd + 1 : 0;
+ int32_t start = ResolveLine(aStart, aStart.line_num, from, aNameMap,
+ MakeLogicalSide(aAxis, eLogicalEdgeStart),
+ aExplicitGridEnd, aStyle);
+ if (aStart.is_span) {
+ start = std::max(aGridEnd - start, aGridStart);
+ }
+ start = AutoIfOutside(start, aGridStart, aGridEnd);
+ return LineRange(start, kAutoLine);
+ }
+
+ LineRange r =
+ ResolveLineRange(aStart, aEnd, aNameMap, aAxis, aExplicitGridEnd, aStyle);
+ if (r.IsAuto()) {
+ MOZ_ASSERT(aStart.is_span && aEnd.is_span,
+ "span / span is the only case "
+ "leading to IsAuto here -- we dealt with the other cases above");
+ // The second span was ignored per 9.2.1. For abs.pos., 10.1 says that this
+ // case should result in "auto / auto" unlike normal flow grid items.
+ return LineRange(kAutoLine, kAutoLine);
+ }
+
+ return LineRange(AutoIfOutside(r.mUntranslatedStart, aGridStart, aGridEnd),
+ AutoIfOutside(r.mUntranslatedEnd, aGridStart, aGridEnd));
+}
+
+nsGridContainerFrame::GridArea nsGridContainerFrame::Grid::PlaceAbsPos(
+ nsIFrame* aChild, const LineNameMap& aColLineNameMap,
+ const LineNameMap& aRowLineNameMap, const nsStylePosition* aStyle) {
+ const nsStylePosition* itemStyle = aChild->StylePosition();
+ int32_t gridColStart = 1 - mExplicitGridOffsetCol;
+ int32_t gridRowStart = 1 - mExplicitGridOffsetRow;
+ return GridArea(ResolveAbsPosLineRange(
+ itemStyle->mGridColumnStart, itemStyle->mGridColumnEnd,
+ aColLineNameMap, eLogicalAxisInline, mExplicitGridColEnd,
+ gridColStart, mGridColEnd, aStyle),
+ ResolveAbsPosLineRange(
+ itemStyle->mGridRowStart, itemStyle->mGridRowEnd,
+ aRowLineNameMap, eLogicalAxisBlock, mExplicitGridRowEnd,
+ gridRowStart, mGridRowEnd, aStyle));
+}
+
+uint32_t nsGridContainerFrame::Grid::FindAutoCol(uint32_t aStartCol,
+ uint32_t aLockedRow,
+ const GridArea* aArea) const {
+ const uint32_t extent = aArea->mCols.Extent();
+ const uint32_t iStart = aLockedRow;
+ const uint32_t iEnd = iStart + aArea->mRows.Extent();
+ uint32_t candidate = aStartCol;
+ for (uint32_t i = iStart; i < iEnd;) {
+ if (i >= mCellMap.mCells.Length()) {
+ break;
+ }
+ const nsTArray<CellMap::Cell>& cellsInRow = mCellMap.mCells[i];
+ const uint32_t len = cellsInRow.Length();
+ const uint32_t lastCandidate = candidate;
+ // Find the first gap in the current row that's at least 'extent' wide.
+ // ('gap' tracks how wide the current column gap is.)
+ for (uint32_t j = candidate, gap = 0; j < len && gap < extent; ++j) {
+ if (!cellsInRow[j].mIsOccupied) {
+ ++gap;
+ continue;
+ }
+ candidate = j + 1;
+ gap = 0;
+ }
+ if (lastCandidate < candidate && i != iStart) {
+ // Couldn't fit 'extent' tracks at 'lastCandidate' here so we must
+ // restart from the beginning with the new 'candidate'.
+ i = iStart;
+ } else {
+ ++i;
+ }
+ }
+ return candidate;
+}
+
+void nsGridContainerFrame::Grid::PlaceAutoCol(uint32_t aStartCol,
+ GridArea* aArea,
+ uint32_t aClampMaxColLine) const {
+ MOZ_ASSERT(aArea->mRows.IsDefinite() && aArea->mCols.IsAuto());
+ uint32_t col = FindAutoCol(aStartCol, aArea->mRows.mStart, aArea);
+ aArea->mCols.ResolveAutoPosition(col, aClampMaxColLine);
+ MOZ_ASSERT(aArea->IsDefinite());
+}
+
+uint32_t nsGridContainerFrame::Grid::FindAutoRow(uint32_t aLockedCol,
+ uint32_t aStartRow,
+ const GridArea* aArea) const {
+ const uint32_t extent = aArea->mRows.Extent();
+ const uint32_t jStart = aLockedCol;
+ const uint32_t jEnd = jStart + aArea->mCols.Extent();
+ const uint32_t iEnd = mCellMap.mCells.Length();
+ uint32_t candidate = aStartRow;
+ // Find the first gap in the rows that's at least 'extent' tall.
+ // ('gap' tracks how tall the current row gap is.)
+ for (uint32_t i = candidate, gap = 0; i < iEnd && gap < extent; ++i) {
+ ++gap; // tentative, but we may reset it below if a column is occupied
+ const nsTArray<CellMap::Cell>& cellsInRow = mCellMap.mCells[i];
+ const uint32_t clampedJEnd = std::min<uint32_t>(jEnd, cellsInRow.Length());
+ // Check if the current row is unoccupied from jStart to jEnd.
+ for (uint32_t j = jStart; j < clampedJEnd; ++j) {
+ if (cellsInRow[j].mIsOccupied) {
+ // Couldn't fit 'extent' rows at 'candidate' here; we hit something
+ // at row 'i'. So, try the row after 'i' as our next candidate.
+ candidate = i + 1;
+ gap = 0;
+ break;
+ }
+ }
+ }
+ return candidate;
+}
+
+void nsGridContainerFrame::Grid::PlaceAutoRow(uint32_t aStartRow,
+ GridArea* aArea,
+ uint32_t aClampMaxRowLine) const {
+ MOZ_ASSERT(aArea->mCols.IsDefinite() && aArea->mRows.IsAuto());
+ uint32_t row = FindAutoRow(aArea->mCols.mStart, aStartRow, aArea);
+ aArea->mRows.ResolveAutoPosition(row, aClampMaxRowLine);
+ MOZ_ASSERT(aArea->IsDefinite());
+}
+
+void nsGridContainerFrame::Grid::PlaceAutoAutoInRowOrder(
+ uint32_t aStartCol, uint32_t aStartRow, GridArea* aArea,
+ uint32_t aClampMaxColLine, uint32_t aClampMaxRowLine) const {
+ MOZ_ASSERT(aArea->mCols.IsAuto() && aArea->mRows.IsAuto());
+ const uint32_t colExtent = aArea->mCols.Extent();
+ const uint32_t gridRowEnd = mGridRowEnd;
+ const uint32_t gridColEnd = mGridColEnd;
+ uint32_t col = aStartCol;
+ uint32_t row = aStartRow;
+ for (; row < gridRowEnd; ++row) {
+ col = FindAutoCol(col, row, aArea);
+ if (col + colExtent <= gridColEnd) {
+ break;
+ }
+ col = 0;
+ }
+ MOZ_ASSERT(row < gridRowEnd || col == 0,
+ "expected column 0 for placing in a new row");
+ aArea->mCols.ResolveAutoPosition(col, aClampMaxColLine);
+ aArea->mRows.ResolveAutoPosition(row, aClampMaxRowLine);
+ MOZ_ASSERT(aArea->IsDefinite());
+}
+
+void nsGridContainerFrame::Grid::PlaceAutoAutoInColOrder(
+ uint32_t aStartCol, uint32_t aStartRow, GridArea* aArea,
+ uint32_t aClampMaxColLine, uint32_t aClampMaxRowLine) const {
+ MOZ_ASSERT(aArea->mCols.IsAuto() && aArea->mRows.IsAuto());
+ const uint32_t rowExtent = aArea->mRows.Extent();
+ const uint32_t gridRowEnd = mGridRowEnd;
+ const uint32_t gridColEnd = mGridColEnd;
+ uint32_t col = aStartCol;
+ uint32_t row = aStartRow;
+ for (; col < gridColEnd; ++col) {
+ row = FindAutoRow(col, row, aArea);
+ if (row + rowExtent <= gridRowEnd) {
+ break;
+ }
+ row = 0;
+ }
+ MOZ_ASSERT(col < gridColEnd || row == 0,
+ "expected row 0 for placing in a new column");
+ aArea->mCols.ResolveAutoPosition(col, aClampMaxColLine);
+ aArea->mRows.ResolveAutoPosition(row, aClampMaxRowLine);
+ MOZ_ASSERT(aArea->IsDefinite());
+}
+
+template <typename IsEmptyFuncT>
+Maybe<nsTArray<uint32_t>>
+nsGridContainerFrame::Grid::CalculateAdjustForAutoFitElements(
+ uint32_t* const aOutNumEmptyLines, TrackSizingFunctions& aSizingFunctions,
+ uint32_t aNumGridLines, IsEmptyFuncT aIsEmptyFunc) {
+ Maybe<nsTArray<uint32_t>> trackAdjust;
+ uint32_t& numEmptyLines = *aOutNumEmptyLines;
+ numEmptyLines = 0;
+ if (aSizingFunctions.NumRepeatTracks() > 0) {
+ MOZ_ASSERT(aSizingFunctions.mHasRepeatAuto);
+ // Since this loop is concerned with just the repeat tracks, we
+ // iterate from 0..NumRepeatTracks() which is the natural range of
+ // mRemoveRepeatTracks. This means we have to add
+ // (mExplicitGridOffset + mRepeatAutoStart) to get a zero-based
+ // index for arrays like mCellMap/aIsEmptyFunc and trackAdjust. We'll then
+ // fill out the trackAdjust array for all the remaining lines.
+ const uint32_t repeatStart = (aSizingFunctions.mExplicitGridOffset +
+ aSizingFunctions.mRepeatAutoStart);
+ const uint32_t numRepeats = aSizingFunctions.NumRepeatTracks();
+ for (uint32_t i = 0; i < numRepeats; ++i) {
+ if (numEmptyLines) {
+ MOZ_ASSERT(trackAdjust.isSome());
+ (*trackAdjust)[repeatStart + i] = numEmptyLines;
+ }
+ if (aIsEmptyFunc(repeatStart + i)) {
+ ++numEmptyLines;
+ if (trackAdjust.isNothing()) {
+ trackAdjust.emplace(aNumGridLines);
+ trackAdjust->SetLength(aNumGridLines);
+ PodZero(trackAdjust->Elements(), trackAdjust->Length());
+ }
+
+ aSizingFunctions.mRemovedRepeatTracks[i] = true;
+ }
+ }
+ // Fill out the trackAdjust array for all the tracks after the repeats.
+ if (numEmptyLines) {
+ for (uint32_t line = repeatStart + numRepeats; line < aNumGridLines;
+ ++line) {
+ (*trackAdjust)[line] = numEmptyLines;
+ }
+ }
+ }
+
+ return trackAdjust;
+}
+
+void nsGridContainerFrame::Grid::SubgridPlaceGridItems(
+ GridReflowInput& aParentState, Grid* aParentGrid,
+ const GridItemInfo& aGridItem) {
+ MOZ_ASSERT(aGridItem.mArea.IsDefinite() ||
+ aGridItem.mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW),
+ "the subgrid's lines should be resolved by now");
+ if (aGridItem.IsSubgrid(eLogicalAxisInline)) {
+ aParentState.mFrame->AddStateBits(NS_STATE_GRID_HAS_COL_SUBGRID_ITEM);
+ }
+ if (aGridItem.IsSubgrid(eLogicalAxisBlock)) {
+ aParentState.mFrame->AddStateBits(NS_STATE_GRID_HAS_ROW_SUBGRID_ITEM);
+ }
+ auto* childGrid = aGridItem.SubgridFrame();
+ const auto* pos = childGrid->StylePosition();
+ childGrid->NormalizeChildLists();
+ GridReflowInput state(childGrid, aParentState.mRenderingContext);
+ childGrid->InitImplicitNamedAreas(pos);
+
+ const bool isOrthogonal = aParentState.mWM.IsOrthogonalTo(state.mWM);
+ // Record the subgrid's GridArea in a frame property.
+ auto* subgrid = childGrid->GetProperty(Subgrid::Prop());
+ if (!subgrid) {
+ subgrid = new Subgrid(aGridItem.mArea, isOrthogonal, aParentState.mWM);
+ childGrid->SetProperty(Subgrid::Prop(), subgrid);
+ } else {
+ subgrid->mArea = aGridItem.mArea;
+ subgrid->mIsOrthogonal = isOrthogonal;
+ subgrid->mGridItems.Clear();
+ subgrid->mAbsPosItems.Clear();
+ }
+
+ // Abs.pos. subgrids may have kAutoLine in their area. Map those to the edge
+ // line in the parent's grid (zero-based line numbers).
+ if (MOZ_UNLIKELY(subgrid->mArea.mCols.mStart == kAutoLine)) {
+ subgrid->mArea.mCols.mStart = 0;
+ }
+ if (MOZ_UNLIKELY(subgrid->mArea.mCols.mEnd == kAutoLine)) {
+ subgrid->mArea.mCols.mEnd = aParentGrid->mGridColEnd - 1;
+ }
+ if (MOZ_UNLIKELY(subgrid->mArea.mRows.mStart == kAutoLine)) {
+ subgrid->mArea.mRows.mStart = 0;
+ }
+ if (MOZ_UNLIKELY(subgrid->mArea.mRows.mEnd == kAutoLine)) {
+ subgrid->mArea.mRows.mEnd = aParentGrid->mGridRowEnd - 1;
+ }
+
+ MOZ_ASSERT((subgrid->mArea.mCols.Extent() > 0 &&
+ subgrid->mArea.mRows.Extent() > 0) ||
+ state.mGridItems.IsEmpty(),
+ "subgrid needs at least one track for its items");
+
+ // The min/sz/max sizes are the input to the "repeat-to-fill" algorithm:
+ // https://drafts.csswg.org/css-grid/#auto-repeat
+ // They're only used for auto-repeat in a non-subgridded axis so we skip
+ // computing them otherwise.
+ RepeatTrackSizingInput repeatSizing(state.mWM);
+ if (!childGrid->IsColSubgrid() && state.mColFunctions.mHasRepeatAuto) {
+ repeatSizing.InitFromStyle(eLogicalAxisInline, state.mWM,
+ state.mFrame->Style());
+ }
+ if (!childGrid->IsRowSubgrid() && state.mRowFunctions.mHasRepeatAuto) {
+ repeatSizing.InitFromStyle(eLogicalAxisBlock, state.mWM,
+ state.mFrame->Style());
+ }
+
+ PlaceGridItems(state, repeatSizing);
+
+ subgrid->mGridItems = std::move(state.mGridItems);
+ subgrid->mAbsPosItems = std::move(state.mAbsPosItems);
+ subgrid->mGridColEnd = mGridColEnd;
+ subgrid->mGridRowEnd = mGridRowEnd;
+}
+
+void nsGridContainerFrame::Grid::PlaceGridItems(
+ GridReflowInput& aState, const RepeatTrackSizingInput& aSizes) {
+ MOZ_ASSERT(mCellMap.mCells.IsEmpty(), "unexpected entries in cell map");
+
+ mAreas = aState.mFrame->GetImplicitNamedAreas();
+
+ if (aState.mFrame->HasSubgridItems() || aState.mFrame->IsSubgrid()) {
+ if (auto* uts = aState.mFrame->GetUsedTrackSizes()) {
+ uts->mCanResolveLineRangeSize = {false, false};
+ uts->mSizes[eLogicalAxisInline].ClearAndRetainStorage();
+ uts->mSizes[eLogicalAxisBlock].ClearAndRetainStorage();
+ }
+ }
+
+ // SubgridPlaceGridItems will set these if we find any subgrid items.
+ aState.mFrame->RemoveStateBits(NS_STATE_GRID_HAS_COL_SUBGRID_ITEM |
+ NS_STATE_GRID_HAS_ROW_SUBGRID_ITEM);
+
+ // http://dev.w3.org/csswg/css-grid/#grid-definition
+ // Initialize the end lines of the Explicit Grid (mExplicitGridCol[Row]End).
+ // This is determined by the larger of the number of rows/columns defined
+ // by 'grid-template-areas' and the 'grid-template-rows'/'-columns', plus one.
+ // Also initialize the Implicit Grid (mGridCol[Row]End) to the same values.
+ // Note that this is for a grid with a 1,1 origin. We'll change that
+ // to a 0,0 based grid after placing definite lines.
+ const nsStylePosition* const gridStyle = aState.mGridStyle;
+ const auto* areas = gridStyle->mGridTemplateAreas.IsNone()
+ ? nullptr
+ : &*gridStyle->mGridTemplateAreas.AsAreas();
+ const LineNameMap* parentLineNameMap = nullptr;
+ const LineRange* subgridRange = nullptr;
+ bool subgridAxisIsSameDirection = true;
+ if (!aState.mFrame->IsColSubgrid()) {
+ aState.mColFunctions.InitRepeatTracks(
+ gridStyle->mColumnGap, aSizes.mMin.ISize(aState.mWM),
+ aSizes.mSize.ISize(aState.mWM), aSizes.mMax.ISize(aState.mWM));
+ uint32_t areaCols = areas ? areas->width + 1 : 1;
+ mExplicitGridColEnd = aState.mColFunctions.ComputeExplicitGridEnd(areaCols);
+ } else {
+ const auto* subgrid = aState.mFrame->GetProperty(Subgrid::Prop());
+ subgridRange = &subgrid->SubgridCols();
+ uint32_t extent = subgridRange->Extent();
+ mExplicitGridColEnd = extent + 1; // the grid is 1-based at this point
+ parentLineNameMap =
+ ParentLineMapForAxis(subgrid->mIsOrthogonal, eLogicalAxisInline);
+ auto parentWM =
+ aState.mFrame->ParentGridContainerForSubgrid()->GetWritingMode();
+ subgridAxisIsSameDirection =
+ aState.mWM.ParallelAxisStartsOnSameSide(eLogicalAxisInline, parentWM);
+ }
+ mGridColEnd = mExplicitGridColEnd;
+ LineNameMap colLineNameMap(gridStyle, mAreas, aState.mColFunctions,
+ parentLineNameMap, subgridRange,
+ subgridAxisIsSameDirection);
+
+ if (!aState.mFrame->IsRowSubgrid()) {
+ const Maybe<nscoord> containBSize = aState.mFrame->ContainIntrinsicBSize();
+ const nscoord repeatTrackSizingBSize = [&] {
+ // This clamping only applies to auto sizes.
+ if (containBSize &&
+ aSizes.mSize.BSize(aState.mWM) == NS_UNCONSTRAINEDSIZE) {
+ return NS_CSS_MINMAX(*containBSize, aSizes.mMin.BSize(aState.mWM),
+ aSizes.mMax.BSize(aState.mWM));
+ }
+ return aSizes.mSize.BSize(aState.mWM);
+ }();
+ aState.mRowFunctions.InitRepeatTracks(
+ gridStyle->mRowGap, aSizes.mMin.BSize(aState.mWM),
+ repeatTrackSizingBSize, aSizes.mMax.BSize(aState.mWM));
+ uint32_t areaRows = areas ? areas->strings.Length() + 1 : 1;
+ mExplicitGridRowEnd = aState.mRowFunctions.ComputeExplicitGridEnd(areaRows);
+ parentLineNameMap = nullptr;
+ subgridRange = nullptr;
+ } else {
+ const auto* subgrid = aState.mFrame->GetProperty(Subgrid::Prop());
+ subgridRange = &subgrid->SubgridRows();
+ uint32_t extent = subgridRange->Extent();
+ mExplicitGridRowEnd = extent + 1; // the grid is 1-based at this point
+ parentLineNameMap =
+ ParentLineMapForAxis(subgrid->mIsOrthogonal, eLogicalAxisBlock);
+ auto parentWM =
+ aState.mFrame->ParentGridContainerForSubgrid()->GetWritingMode();
+ subgridAxisIsSameDirection =
+ aState.mWM.ParallelAxisStartsOnSameSide(eLogicalAxisBlock, parentWM);
+ }
+ mGridRowEnd = mExplicitGridRowEnd;
+ LineNameMap rowLineNameMap(gridStyle, mAreas, aState.mRowFunctions,
+ parentLineNameMap, subgridRange,
+ subgridAxisIsSameDirection);
+
+ const bool isSubgridOrItemInSubgrid =
+ aState.mFrame->IsSubgrid() || !!mParentGrid;
+ auto SetSubgridChildEdgeBits =
+ [this, isSubgridOrItemInSubgrid](GridItemInfo& aItem) -> void {
+ if (isSubgridOrItemInSubgrid) {
+ const auto& area = aItem.mArea;
+ if (area.mCols.mStart == 0) {
+ aItem.mState[eLogicalAxisInline] |= ItemState::eStartEdge;
+ }
+ if (area.mCols.mEnd == mGridColEnd) {
+ aItem.mState[eLogicalAxisInline] |= ItemState::eEndEdge;
+ }
+ if (area.mRows.mStart == 0) {
+ aItem.mState[eLogicalAxisBlock] |= ItemState::eStartEdge;
+ }
+ if (area.mRows.mEnd == mGridRowEnd) {
+ aItem.mState[eLogicalAxisBlock] |= ItemState::eEndEdge;
+ }
+ }
+ };
+
+ SetLineMaps(&colLineNameMap, &rowLineNameMap);
+
+ // http://dev.w3.org/csswg/css-grid/#line-placement
+ // Resolve definite positions per spec chap 9.2.
+ int32_t minCol = 1;
+ int32_t minRow = 1;
+ aState.mGridItems.ClearAndRetainStorage();
+ aState.mIter.Reset();
+ for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
+ nsIFrame* child = *aState.mIter;
+ GridItemInfo* info = aState.mGridItems.AppendElement(GridItemInfo(
+ child,
+ PlaceDefinite(child, colLineNameMap, rowLineNameMap, gridStyle)));
+ MOZ_ASSERT(aState.mIter.ItemIndex() == aState.mGridItems.Length() - 1,
+ "ItemIndex() is broken");
+ GridArea& area = info->mArea;
+ if (area.mCols.IsDefinite()) {
+ minCol = std::min(minCol, area.mCols.mUntranslatedStart);
+ }
+ if (area.mRows.IsDefinite()) {
+ minRow = std::min(minRow, area.mRows.mUntranslatedStart);
+ }
+ }
+
+ // Translate the whole grid so that the top-/left-most area is at 0,0.
+ mExplicitGridOffsetCol = 1 - minCol; // minCol/Row is always <= 1, see above
+ mExplicitGridOffsetRow = 1 - minRow;
+ aState.mColFunctions.mExplicitGridOffset = mExplicitGridOffsetCol;
+ aState.mRowFunctions.mExplicitGridOffset = mExplicitGridOffsetRow;
+ const int32_t offsetToColZero = int32_t(mExplicitGridOffsetCol) - 1;
+ const int32_t offsetToRowZero = int32_t(mExplicitGridOffsetRow) - 1;
+ const bool isRowMasonry = aState.mFrame->IsMasonry(eLogicalAxisBlock);
+ const bool isColMasonry = aState.mFrame->IsMasonry(eLogicalAxisInline);
+ const bool isMasonry = isColMasonry || isRowMasonry;
+ mGridColEnd += offsetToColZero;
+ mGridRowEnd += offsetToRowZero;
+ const uint32_t gridAxisTrackCount = isRowMasonry ? mGridColEnd : mGridRowEnd;
+ aState.mIter.Reset();
+ for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
+ auto& item = aState.mGridItems[aState.mIter.ItemIndex()];
+ GridArea& area = item.mArea;
+ if (area.mCols.IsDefinite()) {
+ area.mCols.mStart = area.mCols.mUntranslatedStart + offsetToColZero;
+ area.mCols.mEnd = area.mCols.mUntranslatedEnd + offsetToColZero;
+ }
+ if (area.mRows.IsDefinite()) {
+ area.mRows.mStart = area.mRows.mUntranslatedStart + offsetToRowZero;
+ area.mRows.mEnd = area.mRows.mUntranslatedEnd + offsetToRowZero;
+ }
+ if (area.IsDefinite()) {
+ if (isMasonry) {
+ item.MaybeInhibitSubgridInMasonry(aState.mFrame, gridAxisTrackCount);
+ }
+ if (item.IsSubgrid()) {
+ Grid grid(this);
+ grid.SubgridPlaceGridItems(aState, this, item);
+ }
+ mCellMap.Fill(area);
+ InflateGridFor(area);
+ SetSubgridChildEdgeBits(item);
+ }
+ }
+
+ // http://dev.w3.org/csswg/css-grid/#auto-placement-algo
+ // Step 1, place 'auto' items that have one definite position -
+ // definite row (column) for grid-auto-flow:row (column).
+ auto flowStyle = gridStyle->mGridAutoFlow;
+ const bool isRowOrder =
+ isMasonry ? isRowMasonry : !!(flowStyle & StyleGridAutoFlow::ROW);
+ const bool isSparse = !(flowStyle & StyleGridAutoFlow::DENSE);
+ uint32_t clampMaxColLine = colLineNameMap.mClampMaxLine + offsetToColZero;
+ uint32_t clampMaxRowLine = rowLineNameMap.mClampMaxLine + offsetToRowZero;
+ // We need 1 cursor per row (or column) if placement is sparse.
+ {
+ Maybe<nsTHashMap<nsUint32HashKey, uint32_t>> cursors;
+ if (isSparse) {
+ cursors.emplace();
+ }
+ auto placeAutoMinorFunc =
+ isRowOrder ? &Grid::PlaceAutoCol : &Grid::PlaceAutoRow;
+ uint32_t clampMaxLine = isRowOrder ? clampMaxColLine : clampMaxRowLine;
+ aState.mIter.Reset();
+ for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
+ auto& item = aState.mGridItems[aState.mIter.ItemIndex()];
+ GridArea& area = item.mArea;
+ LineRange& major = isRowOrder ? area.mRows : area.mCols;
+ LineRange& minor = isRowOrder ? area.mCols : area.mRows;
+ if (major.IsDefinite() && minor.IsAuto()) {
+ // Items with 'auto' in the minor dimension only.
+ const uint32_t cursor = isSparse ? cursors->Get(major.mStart) : 0;
+ (this->*placeAutoMinorFunc)(cursor, &area, clampMaxLine);
+ if (isMasonry) {
+ item.MaybeInhibitSubgridInMasonry(aState.mFrame, gridAxisTrackCount);
+ }
+ if (item.IsSubgrid()) {
+ Grid grid(this);
+ grid.SubgridPlaceGridItems(aState, this, item);
+ }
+ mCellMap.Fill(area);
+ SetSubgridChildEdgeBits(item);
+ if (isSparse) {
+ cursors->InsertOrUpdate(major.mStart, minor.mEnd);
+ }
+ }
+ InflateGridFor(area); // Step 2, inflating for auto items too
+ }
+ }
+
+ // XXX NOTE possible spec issue.
+ // XXX It's unclear if the remaining major-dimension auto and
+ // XXX auto in both dimensions should use the same cursor or not,
+ // XXX https://www.w3.org/Bugs/Public/show_bug.cgi?id=16044
+ // XXX seems to indicate it shouldn't.
+ // XXX http://dev.w3.org/csswg/css-grid/#auto-placement-cursor
+ // XXX now says it should (but didn't in earlier versions)
+
+ // Step 3, place the remaining grid items
+ uint32_t cursorMajor = 0; // for 'dense' these two cursors will stay at 0,0
+ uint32_t cursorMinor = 0;
+ auto placeAutoMajorFunc =
+ isRowOrder ? &Grid::PlaceAutoRow : &Grid::PlaceAutoCol;
+ uint32_t clampMaxMajorLine = isRowOrder ? clampMaxRowLine : clampMaxColLine;
+ aState.mIter.Reset();
+ for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
+ auto& item = aState.mGridItems[aState.mIter.ItemIndex()];
+ GridArea& area = item.mArea;
+ MOZ_ASSERT(*aState.mIter == item.mFrame,
+ "iterator out of sync with aState.mGridItems");
+ LineRange& major = isRowOrder ? area.mRows : area.mCols;
+ LineRange& minor = isRowOrder ? area.mCols : area.mRows;
+ if (major.IsAuto()) {
+ if (minor.IsDefinite()) {
+ // Items with 'auto' in the major dimension only.
+ if (isSparse) {
+ if (minor.mStart < cursorMinor) {
+ ++cursorMajor;
+ }
+ cursorMinor = minor.mStart;
+ }
+ (this->*placeAutoMajorFunc)(cursorMajor, &area, clampMaxMajorLine);
+ if (isSparse) {
+ cursorMajor = major.mStart;
+ }
+ } else {
+ // Items with 'auto' in both dimensions.
+ if (isRowOrder) {
+ PlaceAutoAutoInRowOrder(cursorMinor, cursorMajor, &area,
+ clampMaxColLine, clampMaxRowLine);
+ } else {
+ PlaceAutoAutoInColOrder(cursorMajor, cursorMinor, &area,
+ clampMaxColLine, clampMaxRowLine);
+ }
+ if (isSparse) {
+ cursorMajor = major.mStart;
+ cursorMinor = minor.mEnd;
+#ifdef DEBUG
+ uint32_t gridMajorEnd = isRowOrder ? mGridRowEnd : mGridColEnd;
+ uint32_t gridMinorEnd = isRowOrder ? mGridColEnd : mGridRowEnd;
+ MOZ_ASSERT(cursorMajor <= gridMajorEnd,
+ "we shouldn't need to place items further than 1 track "
+ "past the current end of the grid, in major dimension");
+ MOZ_ASSERT(cursorMinor <= gridMinorEnd,
+ "we shouldn't add implicit minor tracks for auto/auto");
+#endif
+ }
+ }
+ if (isMasonry) {
+ item.MaybeInhibitSubgridInMasonry(aState.mFrame, gridAxisTrackCount);
+ }
+ if (item.IsSubgrid()) {
+ Grid grid(this);
+ grid.SubgridPlaceGridItems(aState, this, item);
+ }
+ mCellMap.Fill(area);
+ InflateGridFor(area);
+ SetSubgridChildEdgeBits(item);
+ // XXXmats it might be possible to optimize this a bit for masonry layout
+ // if this item was placed in the 2nd row && !isSparse, or the 1st row
+ // is full. Still gotta inflate the grid for all items though to make
+ // the grid large enough...
+ }
+ }
+
+ // Force all items into the 1st/2nd track and have span 1 in the masonry axis.
+ // (See comment on nsGridContainerFrame::MasonryLayout().)
+ if (isMasonry) {
+ auto masonryAxis = isRowMasonry ? eLogicalAxisBlock : eLogicalAxisInline;
+ aState.mIter.Reset();
+ for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
+ auto& item = aState.mGridItems[aState.mIter.ItemIndex()];
+ auto& masonryRange = item.mArea.LineRangeForAxis(masonryAxis);
+ masonryRange.mStart = std::min(masonryRange.mStart, 1U);
+ masonryRange.mEnd = masonryRange.mStart + 1U;
+ }
+ }
+
+ if (aState.mFrame->IsAbsoluteContainer()) {
+ // 9.4 Absolutely-positioned Grid Items
+ // http://dev.w3.org/csswg/css-grid/#abspos-items
+ // We only resolve definite lines here; we'll align auto positions to the
+ // grid container later during reflow.
+ const nsFrameList& children =
+ aState.mFrame->GetChildList(aState.mFrame->GetAbsoluteListID());
+ const int32_t offsetToColZero = int32_t(mExplicitGridOffsetCol) - 1;
+ const int32_t offsetToRowZero = int32_t(mExplicitGridOffsetRow) - 1;
+ // Untranslate the grid again temporarily while resolving abs.pos. lines.
+ AutoRestore<uint32_t> zeroOffsetGridColEnd(mGridColEnd);
+ AutoRestore<uint32_t> zeroOffsetGridRowEnd(mGridRowEnd);
+ mGridColEnd -= offsetToColZero;
+ mGridRowEnd -= offsetToRowZero;
+ aState.mAbsPosItems.ClearAndRetainStorage();
+ for (nsIFrame* child : children) {
+ GridItemInfo* info = aState.mAbsPosItems.AppendElement(GridItemInfo(
+ child,
+ PlaceAbsPos(child, colLineNameMap, rowLineNameMap, gridStyle)));
+ GridArea& area = info->mArea;
+ if (area.mCols.mUntranslatedStart != int32_t(kAutoLine)) {
+ area.mCols.mStart = area.mCols.mUntranslatedStart + offsetToColZero;
+ if (isColMasonry) {
+ // XXXmats clamp any non-auto line to 0 or 1. This is intended to
+ // allow authors to address the start/end of the masonry box.
+ // This is experimental at this point though and needs author feedback
+ // and spec work to sort out what is desired and how it should work.
+ // See https://github.com/w3c/csswg-drafts/issues/4650
+ area.mCols.mStart = std::min(area.mCols.mStart, 1U);
+ }
+ }
+ if (area.mCols.mUntranslatedEnd != int32_t(kAutoLine)) {
+ area.mCols.mEnd = area.mCols.mUntranslatedEnd + offsetToColZero;
+ if (isColMasonry) {
+ // ditto
+ area.mCols.mEnd = std::min(area.mCols.mEnd, 1U);
+ }
+ }
+ if (area.mRows.mUntranslatedStart != int32_t(kAutoLine)) {
+ area.mRows.mStart = area.mRows.mUntranslatedStart + offsetToRowZero;
+ if (isRowMasonry) {
+ // ditto
+ area.mRows.mStart = std::min(area.mRows.mStart, 1U);
+ }
+ }
+ if (area.mRows.mUntranslatedEnd != int32_t(kAutoLine)) {
+ area.mRows.mEnd = area.mRows.mUntranslatedEnd + offsetToRowZero;
+ if (isRowMasonry) {
+ // ditto
+ area.mRows.mEnd = std::min(area.mRows.mEnd, 1U);
+ }
+ }
+ if (isMasonry) {
+ info->MaybeInhibitSubgridInMasonry(aState.mFrame, gridAxisTrackCount);
+ }
+
+ // An abs.pos. subgrid with placement auto/1 or -1/auto technically
+ // doesn't span any parent tracks. Inhibit subgridding in this case.
+ if (info->IsSubgrid(eLogicalAxisInline)) {
+ if (info->mArea.mCols.mStart == zeroOffsetGridColEnd.SavedValue() ||
+ info->mArea.mCols.mEnd == 0) {
+ info->InhibitSubgrid(aState.mFrame, eLogicalAxisInline);
+ }
+ }
+ if (info->IsSubgrid(eLogicalAxisBlock)) {
+ if (info->mArea.mRows.mStart == zeroOffsetGridRowEnd.SavedValue() ||
+ info->mArea.mRows.mEnd == 0) {
+ info->InhibitSubgrid(aState.mFrame, eLogicalAxisBlock);
+ }
+ }
+
+ if (info->IsSubgrid()) {
+ Grid grid(this);
+ grid.SubgridPlaceGridItems(aState, this, *info);
+ }
+ }
+ }
+
+ // Count empty 'auto-fit' tracks in the repeat() range.
+ // |colAdjust| will have a count for each line in the grid of how many
+ // tracks were empty between the start of the grid and that line.
+
+ Maybe<nsTArray<uint32_t>> colAdjust;
+ uint32_t numEmptyCols = 0;
+ if (aState.mColFunctions.mHasRepeatAuto &&
+ gridStyle->mGridTemplateColumns.GetRepeatAutoValue()->count.IsAutoFit()) {
+ const auto& cellMap = mCellMap;
+ colAdjust = CalculateAdjustForAutoFitElements(
+ &numEmptyCols, aState.mColFunctions, mGridColEnd + 1,
+ [&cellMap](uint32_t i) -> bool { return cellMap.IsEmptyCol(i); });
+ }
+
+ // Do similar work for the row tracks, with the same logic.
+ Maybe<nsTArray<uint32_t>> rowAdjust;
+ uint32_t numEmptyRows = 0;
+ if (aState.mRowFunctions.mHasRepeatAuto &&
+ gridStyle->mGridTemplateRows.GetRepeatAutoValue()->count.IsAutoFit()) {
+ const auto& cellMap = mCellMap;
+ rowAdjust = CalculateAdjustForAutoFitElements(
+ &numEmptyRows, aState.mRowFunctions, mGridRowEnd + 1,
+ [&cellMap](uint32_t i) -> bool { return cellMap.IsEmptyRow(i); });
+ }
+ MOZ_ASSERT((numEmptyCols > 0) == colAdjust.isSome());
+ MOZ_ASSERT((numEmptyRows > 0) == rowAdjust.isSome());
+ // Remove the empty 'auto-fit' tracks we found above, if any.
+ if (numEmptyCols || numEmptyRows) {
+ // Adjust the line numbers in the grid areas.
+ for (auto& item : aState.mGridItems) {
+ if (numEmptyCols) {
+ item.AdjustForRemovedTracks(eLogicalAxisInline, *colAdjust);
+ }
+ if (numEmptyRows) {
+ item.AdjustForRemovedTracks(eLogicalAxisBlock, *rowAdjust);
+ }
+ }
+ for (auto& item : aState.mAbsPosItems) {
+ if (numEmptyCols) {
+ item.AdjustForRemovedTracks(eLogicalAxisInline, *colAdjust);
+ }
+ if (numEmptyRows) {
+ item.AdjustForRemovedTracks(eLogicalAxisBlock, *rowAdjust);
+ }
+ }
+ // Adjust the grid size.
+ mGridColEnd -= numEmptyCols;
+ mExplicitGridColEnd -= numEmptyCols;
+ mGridRowEnd -= numEmptyRows;
+ mExplicitGridRowEnd -= numEmptyRows;
+ // Adjust the track mapping to unmap the removed tracks.
+ auto colRepeatCount = aState.mColFunctions.NumRepeatTracks();
+ aState.mColFunctions.SetNumRepeatTracks(colRepeatCount - numEmptyCols);
+ auto rowRepeatCount = aState.mRowFunctions.NumRepeatTracks();
+ aState.mRowFunctions.SetNumRepeatTracks(rowRepeatCount - numEmptyRows);
+ }
+
+ // Update the line boundaries of the implicit grid areas, if needed.
+ if (mAreas && aState.mFrame->HasAnyStateBits(NS_STATE_GRID_COMPUTED_INFO)) {
+ for (auto iter = mAreas->iter(); !iter.done(); iter.next()) {
+ auto& areaInfo = iter.get().value();
+
+ // Resolve the lines for the area. We use the name of the area as the
+ // name of the lines, knowing that the line placement algorithm will
+ // add the -start and -end suffixes as appropriate for layout.
+ StyleGridLine lineStartAndEnd;
+ lineStartAndEnd.ident._0 = areaInfo.name;
+
+ LineRange columnLines =
+ ResolveLineRange(lineStartAndEnd, lineStartAndEnd, colLineNameMap,
+ eLogicalAxisInline, mExplicitGridColEnd, gridStyle);
+
+ LineRange rowLines =
+ ResolveLineRange(lineStartAndEnd, lineStartAndEnd, rowLineNameMap,
+ eLogicalAxisBlock, mExplicitGridRowEnd, gridStyle);
+
+ // Put the resolved line indices back into the area structure.
+ areaInfo.columns.start = columnLines.mStart + mExplicitGridOffsetCol;
+ areaInfo.columns.end = columnLines.mEnd + mExplicitGridOffsetCol;
+ areaInfo.rows.start = rowLines.mStart + mExplicitGridOffsetRow;
+ areaInfo.rows.end = rowLines.mEnd + mExplicitGridOffsetRow;
+ }
+ }
+}
+
+void nsGridContainerFrame::Tracks::Initialize(
+ const TrackSizingFunctions& aFunctions,
+ const NonNegativeLengthPercentageOrNormal& aGridGap, uint32_t aNumTracks,
+ nscoord aContentBoxSize) {
+ mSizes.SetLength(aNumTracks);
+ PodZero(mSizes.Elements(), mSizes.Length());
+ for (uint32_t i = 0, len = mSizes.Length(); i < len; ++i) {
+ auto& sz = mSizes[i];
+ mStateUnion |= sz.Initialize(aContentBoxSize, aFunctions.SizingFor(i));
+ if (mIsMasonry) {
+ sz.mBase = aContentBoxSize;
+ sz.mLimit = aContentBoxSize;
+ }
+ }
+ mGridGap = nsLayoutUtils::ResolveGapToLength(aGridGap, aContentBoxSize);
+ mContentBoxSize = aContentBoxSize;
+}
+
+/**
+ * Reflow aChild in the given aAvailableSize.
+ */
+static nscoord MeasuringReflow(nsIFrame* aChild,
+ const ReflowInput* aReflowInput, gfxContext* aRC,
+ const LogicalSize& aAvailableSize,
+ const LogicalSize& aCBSize,
+ nscoord aIMinSizeClamp = NS_MAXSIZE,
+ nscoord aBMinSizeClamp = NS_MAXSIZE) {
+ MOZ_ASSERT(aChild->IsGridItem(), "aChild should be a grid item!");
+ auto* parent = static_cast<nsGridContainerFrame*>(aChild->GetParent());
+ nsPresContext* pc = aChild->PresContext();
+ Maybe<ReflowInput> dummyParentState;
+ const ReflowInput* rs = aReflowInput;
+ if (!aReflowInput) {
+ MOZ_ASSERT(!parent->HasAnyStateBits(NS_FRAME_IN_REFLOW));
+ dummyParentState.emplace(
+ pc, parent, aRC,
+ LogicalSize(parent->GetWritingMode(), 0, NS_UNCONSTRAINEDSIZE),
+ ReflowInput::InitFlag::DummyParentReflowInput);
+ rs = dummyParentState.ptr();
+ }
+#ifdef DEBUG
+ // This will suppress various ABSURD_SIZE warnings for this reflow.
+ parent->SetProperty(nsContainerFrame::DebugReflowingWithInfiniteISize(),
+ true);
+#endif
+ auto wm = aChild->GetWritingMode();
+ ComputeSizeFlags csFlags = ComputeSizeFlag::IsGridMeasuringReflow;
+ // Shrink-wrap grid items that will be aligned (rather than stretched) in
+ // their own inline axis.
+ if (!parent->GridItemShouldStretch(aChild, eLogicalAxisInline)) {
+ csFlags += ComputeSizeFlag::ShrinkWrap;
+ }
+ if (aAvailableSize.ISize(wm) == INFINITE_ISIZE_COORD) {
+ csFlags += ComputeSizeFlag::ShrinkWrap;
+ }
+ if (aIMinSizeClamp != NS_MAXSIZE) {
+ csFlags += ComputeSizeFlag::IClampMarginBoxMinSize;
+ }
+ if (aBMinSizeClamp != NS_MAXSIZE) {
+ csFlags += ComputeSizeFlag::BClampMarginBoxMinSize;
+ aChild->SetProperty(nsIFrame::BClampMarginBoxMinSizeProperty(),
+ aBMinSizeClamp);
+ } else {
+ aChild->RemoveProperty(nsIFrame::BClampMarginBoxMinSizeProperty());
+ }
+ ReflowInput childRI(pc, *rs, aChild, aAvailableSize, Some(aCBSize), {}, {},
+ csFlags);
+
+ // FIXME (perf): It would be faster to do this only if the previous reflow of
+ // the child was not a measuring reflow, and only if the child does some of
+ // the things that are affected by ComputeSizeFlag::IsGridMeasuringReflow.
+ childRI.SetBResize(true);
+ // Not 100% sure this is needed, but be conservative for now:
+ childRI.mFlags.mIsBResizeForPercentages = true;
+
+ ReflowOutput childSize(childRI);
+ nsReflowStatus childStatus;
+ const nsIFrame::ReflowChildFlags flags =
+ nsIFrame::ReflowChildFlags::NoMoveFrame |
+ nsIFrame::ReflowChildFlags::NoSizeView |
+ nsIFrame::ReflowChildFlags::NoDeleteNextInFlowChild;
+
+ bool found;
+ GridItemCachedBAxisMeasurement cachedMeasurement =
+ aChild->GetProperty(GridItemCachedBAxisMeasurement::Prop(), &found);
+ if (found && cachedMeasurement.IsValidFor(aChild, aCBSize)) {
+ childSize.BSize(wm) = cachedMeasurement.BSize();
+ childSize.ISize(wm) = aChild->ISize(wm);
+ nsContainerFrame::FinishReflowChild(aChild, pc, childSize, &childRI, wm,
+ LogicalPoint(wm), nsSize(), flags);
+ GRID_LOG(
+ "[perf] MeasuringReflow accepted cached value=%d, child=%p, "
+ "aCBSize.ISize=%d",
+ cachedMeasurement.BSize(), aChild,
+ aCBSize.ISize(aChild->GetWritingMode()));
+ return cachedMeasurement.BSize();
+ }
+
+ parent->ReflowChild(aChild, pc, childSize, childRI, wm, LogicalPoint(wm),
+ nsSize(), flags, childStatus);
+ nsContainerFrame::FinishReflowChild(aChild, pc, childSize, &childRI, wm,
+ LogicalPoint(wm), nsSize(), flags);
+#ifdef DEBUG
+ parent->RemoveProperty(nsContainerFrame::DebugReflowingWithInfiniteISize());
+#endif
+ if (!found &&
+ GridItemCachedBAxisMeasurement::CanCacheMeasurement(aChild, aCBSize)) {
+ GridItemCachedBAxisMeasurement cachedMeasurement(aChild, aCBSize,
+ childSize.BSize(wm));
+ aChild->SetProperty(GridItemCachedBAxisMeasurement::Prop(),
+ cachedMeasurement);
+ GRID_LOG(
+ "[perf] MeasuringReflow created new cached value=%d, child=%p, "
+ "aCBSize.ISize=%d",
+ cachedMeasurement.BSize(), aChild,
+ aCBSize.ISize(aChild->GetWritingMode()));
+ } else if (found) {
+ if (GridItemCachedBAxisMeasurement::CanCacheMeasurement(aChild, aCBSize)) {
+ cachedMeasurement.Update(aChild, aCBSize, childSize.BSize(wm));
+ GRID_LOG(
+ "[perf] MeasuringReflow rejected but updated cached value=%d, "
+ "child=%p, aCBSize.ISize=%d",
+ cachedMeasurement.BSize(), aChild,
+ aCBSize.ISize(aChild->GetWritingMode()));
+ aChild->SetProperty(GridItemCachedBAxisMeasurement::Prop(),
+ cachedMeasurement);
+ } else {
+ aChild->RemoveProperty(GridItemCachedBAxisMeasurement::Prop());
+ GRID_LOG(
+ "[perf] MeasuringReflow rejected and removed cached value, "
+ "child=%p",
+ aChild);
+ }
+ }
+
+ return childSize.BSize(wm);
+}
+
+/**
+ * Reflow aChild in the given aAvailableSize, using aNewContentBoxSize as its
+ * computed size in aChildAxis.
+ */
+static void PostReflowStretchChild(
+ nsIFrame* aChild, const ReflowInput& aReflowInput,
+ const LogicalSize& aAvailableSize, const LogicalSize& aCBSize,
+ LogicalAxis aChildAxis, const nscoord aNewContentBoxSize,
+ nscoord aIMinSizeClamp = NS_MAXSIZE, nscoord aBMinSizeClamp = NS_MAXSIZE) {
+ nsPresContext* pc = aChild->PresContext();
+ ComputeSizeFlags csFlags;
+ if (aIMinSizeClamp != NS_MAXSIZE) {
+ csFlags += ComputeSizeFlag::IClampMarginBoxMinSize;
+ }
+ if (aBMinSizeClamp != NS_MAXSIZE) {
+ csFlags += ComputeSizeFlag::BClampMarginBoxMinSize;
+ aChild->SetProperty(nsIFrame::BClampMarginBoxMinSizeProperty(),
+ aBMinSizeClamp);
+ } else {
+ aChild->RemoveProperty(nsIFrame::BClampMarginBoxMinSizeProperty());
+ }
+ ReflowInput ri(pc, aReflowInput, aChild, aAvailableSize, Some(aCBSize), {},
+ {}, csFlags);
+ if (aChildAxis == eLogicalAxisBlock) {
+ ri.SetComputedBSize(ri.ApplyMinMaxBSize(aNewContentBoxSize));
+ } else {
+ ri.SetComputedISize(ri.ApplyMinMaxISize(aNewContentBoxSize));
+ }
+ ReflowOutput childSize(ri);
+ nsReflowStatus childStatus;
+ const nsIFrame::ReflowChildFlags flags =
+ nsIFrame::ReflowChildFlags::NoMoveFrame |
+ nsIFrame::ReflowChildFlags::NoDeleteNextInFlowChild;
+ auto wm = aChild->GetWritingMode();
+ nsContainerFrame* parent = aChild->GetParent();
+ parent->ReflowChild(aChild, pc, childSize, ri, wm, LogicalPoint(wm), nsSize(),
+ flags, childStatus);
+ nsContainerFrame::FinishReflowChild(aChild, pc, childSize, &ri, wm,
+ LogicalPoint(wm), nsSize(), flags);
+}
+
+/**
+ * Return the accumulated margin+border+padding in aAxis for aFrame (a subgrid)
+ * and its ancestor subgrids.
+ */
+static LogicalMargin SubgridAccumulatedMarginBorderPadding(
+ nsIFrame* aFrame, const Subgrid* aSubgrid, WritingMode aResultWM,
+ LogicalAxis aAxis) {
+ MOZ_ASSERT(aFrame->IsGridContainerFrame());
+ auto* subgridFrame = static_cast<nsGridContainerFrame*>(aFrame);
+ LogicalMargin result(aSubgrid->mMarginBorderPadding);
+ auto* parent = subgridFrame->ParentGridContainerForSubgrid();
+ auto subgridCBWM = parent->GetWritingMode();
+ auto childRange = aSubgrid->mArea.LineRangeForAxis(aAxis);
+ bool skipStartSide = false;
+ bool skipEndSide = false;
+ auto axis = aSubgrid->mIsOrthogonal ? GetOrthogonalAxis(aAxis) : aAxis;
+ // If aFrame's parent is also a subgrid, then add its MBP on the edges that
+ // are adjacent (i.e. start or end in the same track), recursively.
+ // ("parent" refers to the grid-frame we're currently adding MBP for,
+ // and "grandParent" its parent, as we walk up the chain.)
+ while (parent->IsSubgrid(axis)) {
+ auto* parentSubgrid = parent->GetProperty(Subgrid::Prop());
+ auto* grandParent = parent->ParentGridContainerForSubgrid();
+ auto parentCBWM = grandParent->GetWritingMode();
+ if (parentCBWM.IsOrthogonalTo(subgridCBWM)) {
+ axis = GetOrthogonalAxis(axis);
+ }
+ const auto& parentRange = parentSubgrid->mArea.LineRangeForAxis(axis);
+ bool sameDir = parentCBWM.ParallelAxisStartsOnSameSide(axis, subgridCBWM);
+ if (sameDir) {
+ skipStartSide |= childRange.mStart != 0;
+ skipEndSide |= childRange.mEnd != parentRange.Extent();
+ } else {
+ skipEndSide |= childRange.mStart != 0;
+ skipStartSide |= childRange.mEnd != parentRange.Extent();
+ }
+ if (skipStartSide && skipEndSide) {
+ break;
+ }
+ auto mbp =
+ parentSubgrid->mMarginBorderPadding.ConvertTo(subgridCBWM, parentCBWM);
+ if (skipStartSide) {
+ mbp.Start(aAxis, subgridCBWM) = nscoord(0);
+ }
+ if (skipEndSide) {
+ mbp.End(aAxis, subgridCBWM) = nscoord(0);
+ }
+ result += mbp;
+ parent = grandParent;
+ childRange = parentRange;
+ }
+ return result.ConvertTo(aResultWM, subgridCBWM);
+}
+
+/**
+ * Return the [min|max]-content contribution of aChild to its parent (i.e.
+ * the child's margin-box) in aAxis.
+ */
+static nscoord ContentContribution(
+ const GridItemInfo& aGridItem, const GridReflowInput& aState,
+ gfxContext* aRC, WritingMode aCBWM, LogicalAxis aAxis,
+ const Maybe<LogicalSize>& aPercentageBasis, IntrinsicISizeType aConstraint,
+ nscoord aMinSizeClamp = NS_MAXSIZE, uint32_t aFlags = 0) {
+ nsIFrame* child = aGridItem.mFrame;
+
+ nscoord extraMargin = 0;
+ nsGridContainerFrame::Subgrid* subgrid = nullptr;
+ if (child->GetParent() != aState.mFrame) {
+ // |child| is a subgrid descendant, so it contributes its subgrids'
+ // margin+border+padding for any edge tracks that it spans.
+ auto* subgridFrame = child->GetParent();
+ subgrid = subgridFrame->GetProperty(Subgrid::Prop());
+ const auto itemEdgeBits = aGridItem.mState[aAxis] & ItemState::eEdgeBits;
+ if (itemEdgeBits) {
+ LogicalMargin mbp = SubgridAccumulatedMarginBorderPadding(
+ subgridFrame, subgrid, aCBWM, aAxis);
+ if (itemEdgeBits & ItemState::eStartEdge) {
+ extraMargin += mbp.Start(aAxis, aCBWM);
+ }
+ if (itemEdgeBits & ItemState::eEndEdge) {
+ extraMargin += mbp.End(aAxis, aCBWM);
+ }
+ }
+ // It also contributes (half of) the subgrid's gap on its edges (if any)
+ // subtracted by the non-subgrid ancestor grid container's gap.
+ // Note that this can also be negative since it's considered a margin.
+ if (itemEdgeBits != ItemState::eEdgeBits) {
+ auto subgridAxis = aCBWM.IsOrthogonalTo(subgridFrame->GetWritingMode())
+ ? GetOrthogonalAxis(aAxis)
+ : aAxis;
+ auto& gapStyle = subgridAxis == eLogicalAxisBlock
+ ? subgridFrame->StylePosition()->mRowGap
+ : subgridFrame->StylePosition()->mColumnGap;
+ if (!gapStyle.IsNormal()) {
+ auto subgridExtent = subgridAxis == eLogicalAxisBlock
+ ? subgrid->mGridRowEnd
+ : subgrid->mGridColEnd;
+ if (subgridExtent > 1) {
+ nscoord subgridGap =
+ nsLayoutUtils::ResolveGapToLength(gapStyle, NS_UNCONSTRAINEDSIZE);
+ auto& tracks =
+ aAxis == eLogicalAxisBlock ? aState.mRows : aState.mCols;
+ auto gapDelta = subgridGap - tracks.mGridGap;
+ if (!itemEdgeBits) {
+ extraMargin += gapDelta;
+ } else {
+ extraMargin += gapDelta / 2;
+ }
+ }
+ }
+ }
+ }
+
+ PhysicalAxis axis(aCBWM.PhysicalAxis(aAxis));
+ nscoord size = nsLayoutUtils::IntrinsicForAxis(
+ axis, aRC, child, aConstraint, aPercentageBasis,
+ aFlags | nsLayoutUtils::BAIL_IF_REFLOW_NEEDED, aMinSizeClamp);
+ auto childWM = child->GetWritingMode();
+ const bool isOrthogonal = childWM.IsOrthogonalTo(aCBWM);
+ auto childAxis = isOrthogonal ? GetOrthogonalAxis(aAxis) : aAxis;
+ if (size == NS_INTRINSIC_ISIZE_UNKNOWN && childAxis == eLogicalAxisBlock) {
+ // We need to reflow the child to find its BSize contribution.
+ // XXX this will give mostly correct results for now (until bug 1174569).
+ nscoord availISize = INFINITE_ISIZE_COORD;
+ nscoord availBSize = NS_UNCONSTRAINEDSIZE;
+ // The next two variables are MinSizeClamp values in the child's axes.
+ nscoord iMinSizeClamp = NS_MAXSIZE;
+ nscoord bMinSizeClamp = NS_MAXSIZE;
+ LogicalSize cbSize(childWM, 0, NS_UNCONSTRAINEDSIZE);
+ // Below, we try to resolve the child's grid-area size in its inline-axis
+ // to use as the CB/Available size in the MeasuringReflow that follows.
+ if (child->GetParent() != aState.mFrame) {
+ // This item is a child of a subgrid descendant.
+ auto* subgridFrame =
+ static_cast<nsGridContainerFrame*>(child->GetParent());
+ MOZ_ASSERT(subgridFrame->IsGridContainerFrame());
+ auto* uts = subgridFrame->GetProperty(UsedTrackSizes::Prop());
+ if (!uts) {
+ uts = new UsedTrackSizes();
+ subgridFrame->SetProperty(UsedTrackSizes::Prop(), uts);
+ }
+ // The grid-item's inline-axis as expressed in the subgrid's WM.
+ auto subgridAxis = childWM.IsOrthogonalTo(subgridFrame->GetWritingMode())
+ ? eLogicalAxisBlock
+ : eLogicalAxisInline;
+ uts->ResolveTrackSizesForAxis(subgridFrame, subgridAxis, *aRC);
+ if (uts->mCanResolveLineRangeSize[subgridAxis]) {
+ auto* subgrid =
+ subgridFrame->GetProperty(nsGridContainerFrame::Subgrid::Prop());
+ const GridItemInfo* originalItem = nullptr;
+ for (const auto& item : subgrid->mGridItems) {
+ if (item.mFrame == child) {
+ originalItem = &item;
+ break;
+ }
+ }
+ MOZ_ASSERT(originalItem, "huh?");
+ const auto& range = originalItem->mArea.LineRangeForAxis(subgridAxis);
+ nscoord pos, sz;
+ range.ToPositionAndLength(uts->mSizes[subgridAxis], &pos, &sz);
+ if (childWM.IsOrthogonalTo(subgridFrame->GetWritingMode())) {
+ availBSize = sz;
+ cbSize.BSize(childWM) = sz;
+ if (aGridItem.mState[aAxis] & ItemState::eClampMarginBoxMinSize) {
+ bMinSizeClamp = sz;
+ }
+ } else {
+ availISize = sz;
+ cbSize.ISize(childWM) = sz;
+ if (aGridItem.mState[aAxis] & ItemState::eClampMarginBoxMinSize) {
+ iMinSizeClamp = sz;
+ }
+ }
+ }
+ } else if (aState.mCols.mCanResolveLineRangeSize) {
+ nscoord sz = aState.mCols.ResolveSize(aGridItem.mArea.mCols);
+ if (isOrthogonal) {
+ availBSize = sz;
+ cbSize.BSize(childWM) = sz;
+ if (aGridItem.mState[aAxis] & ItemState::eClampMarginBoxMinSize) {
+ bMinSizeClamp = sz;
+ }
+ } else {
+ availISize = sz;
+ cbSize.ISize(childWM) = sz;
+ if (aGridItem.mState[aAxis] & ItemState::eClampMarginBoxMinSize) {
+ iMinSizeClamp = sz;
+ }
+ }
+ }
+ if (isOrthogonal == (aAxis == eLogicalAxisInline)) {
+ bMinSizeClamp = aMinSizeClamp;
+ } else {
+ iMinSizeClamp = aMinSizeClamp;
+ }
+ LogicalSize availableSize(childWM, availISize, availBSize);
+ size = ::MeasuringReflow(child, aState.mReflowInput, aRC, availableSize,
+ cbSize, iMinSizeClamp, bMinSizeClamp);
+ size += child->GetLogicalUsedMargin(childWM).BStartEnd(childWM);
+ nscoord overflow = size - aMinSizeClamp;
+ if (MOZ_UNLIKELY(overflow > 0)) {
+ nscoord contentSize = child->ContentBSize(childWM);
+ nscoord newContentSize = std::max(nscoord(0), contentSize - overflow);
+ // XXXmats deal with percentages better, see bug 1300369 comment 27.
+ size -= contentSize - newContentSize;
+ }
+ }
+ MOZ_ASSERT(aGridItem.mBaselineOffset[aAxis] >= 0,
+ "baseline offset should be non-negative at this point");
+ MOZ_ASSERT((aGridItem.mState[aAxis] & ItemState::eIsBaselineAligned) ||
+ aGridItem.mBaselineOffset[aAxis] == nscoord(0),
+ "baseline offset should be zero when not baseline-aligned");
+ size += aGridItem.mBaselineOffset[aAxis];
+ size += extraMargin;
+ return std::max(size, 0);
+}
+
+struct CachedIntrinsicSizes {
+ Maybe<nscoord> mMinSize;
+ Maybe<nscoord> mMinContentContribution;
+ Maybe<nscoord> mMaxContentContribution;
+
+ // The item's percentage basis for intrinsic sizing purposes.
+ Maybe<LogicalSize> mPercentageBasis;
+
+ // "if the grid item spans only grid tracks that have a fixed max track
+ // sizing function, its automatic minimum size in that dimension is
+ // further clamped to less than or equal to the size necessary to fit its
+ // margin box within the resulting grid area (flooring at zero)"
+ // https://drafts.csswg.org/css-grid/#min-size-auto
+ // This is the clamp value to use for that:
+ nscoord mMinSizeClamp = NS_MAXSIZE;
+};
+
+static nscoord MinContentContribution(const GridItemInfo& aGridItem,
+ const GridReflowInput& aState,
+ gfxContext* aRC, WritingMode aCBWM,
+ LogicalAxis aAxis,
+ CachedIntrinsicSizes* aCache) {
+ if (aCache->mMinContentContribution.isSome()) {
+ return aCache->mMinContentContribution.value();
+ }
+ if (aCache->mPercentageBasis.isNothing()) {
+ aCache->mPercentageBasis.emplace(
+ aState.PercentageBasisFor(aAxis, aGridItem));
+ }
+ nscoord s = ContentContribution(
+ aGridItem, aState, aRC, aCBWM, aAxis, aCache->mPercentageBasis,
+ IntrinsicISizeType::MinISize, aCache->mMinSizeClamp);
+ aCache->mMinContentContribution.emplace(s);
+ return s;
+}
+
+static nscoord MaxContentContribution(const GridItemInfo& aGridItem,
+ const GridReflowInput& aState,
+ gfxContext* aRC, WritingMode aCBWM,
+ LogicalAxis aAxis,
+ CachedIntrinsicSizes* aCache) {
+ if (aCache->mMaxContentContribution.isSome()) {
+ return aCache->mMaxContentContribution.value();
+ }
+ if (aCache->mPercentageBasis.isNothing()) {
+ aCache->mPercentageBasis.emplace(
+ aState.PercentageBasisFor(aAxis, aGridItem));
+ }
+ nscoord s = ContentContribution(
+ aGridItem, aState, aRC, aCBWM, aAxis, aCache->mPercentageBasis,
+ IntrinsicISizeType::PrefISize, aCache->mMinSizeClamp);
+ aCache->mMaxContentContribution.emplace(s);
+ return s;
+}
+
+// Computes the min-size contribution for a grid item, as defined at
+// https://drafts.csswg.org/css-grid/#min-size-contribution
+static nscoord MinSize(const GridItemInfo& aGridItem,
+ const GridReflowInput& aState, gfxContext* aRC,
+ WritingMode aCBWM, LogicalAxis aAxis,
+ CachedIntrinsicSizes* aCache) {
+ if (aCache->mMinSize.isSome()) {
+ return aCache->mMinSize.value();
+ }
+ nsIFrame* child = aGridItem.mFrame;
+ PhysicalAxis axis(aCBWM.PhysicalAxis(aAxis));
+ const nsStylePosition* stylePos = child->StylePosition();
+ StyleSize sizeStyle =
+ axis == eAxisHorizontal ? stylePos->mWidth : stylePos->mHeight;
+
+ auto ourInlineAxis = child->GetWritingMode().PhysicalAxis(eLogicalAxisInline);
+ // max-content and min-content should behave as initial value in block axis.
+ // FIXME: Bug 567039: moz-fit-content and -moz-available are not supported
+ // for block size dimension on sizing properties (e.g. height), so we
+ // treat it as `auto`.
+ if (axis != ourInlineAxis && sizeStyle.BehavesLikeInitialValueOnBlockAxis()) {
+ sizeStyle = StyleSize::Auto();
+ }
+
+ if (!sizeStyle.IsAuto() && !sizeStyle.HasPercent()) {
+ nscoord s =
+ MinContentContribution(aGridItem, aState, aRC, aCBWM, aAxis, aCache);
+ aCache->mMinSize.emplace(s);
+ return s;
+ }
+
+ if (aCache->mPercentageBasis.isNothing()) {
+ aCache->mPercentageBasis.emplace(
+ aState.PercentageBasisFor(aAxis, aGridItem));
+ }
+
+ // https://drafts.csswg.org/css-grid/#min-size-auto
+ // This calculates the min-content contribution from either a definite
+ // min-width (or min-height depending on aAxis), or the "specified /
+ // transferred size" for min-width:auto if overflow == visible (as min-width:0
+ // otherwise), or NS_UNCONSTRAINEDSIZE for other min-width intrinsic values
+ // (which results in always taking the "content size" part below).
+ MOZ_ASSERT(aGridItem.mBaselineOffset[aAxis] >= 0,
+ "baseline offset should be non-negative at this point");
+ MOZ_ASSERT((aGridItem.mState[aAxis] & ItemState::eIsBaselineAligned) ||
+ aGridItem.mBaselineOffset[aAxis] == nscoord(0),
+ "baseline offset should be zero when not baseline-aligned");
+ nscoord sz = aGridItem.mBaselineOffset[aAxis] +
+ nsLayoutUtils::MinSizeContributionForAxis(
+ axis, aRC, child, IntrinsicISizeType::MinISize,
+ *aCache->mPercentageBasis);
+ const StyleSize& style =
+ axis == eAxisHorizontal ? stylePos->mMinWidth : stylePos->mMinHeight;
+ // max-content and min-content should behave as initial value in block axis.
+ // FIXME: Bug 567039: moz-fit-content and -moz-available are not supported
+ // for block size dimension on sizing properties (e.g. height), so we
+ // treat it as `auto`.
+ const bool inInlineAxis = axis == ourInlineAxis;
+ const bool isAuto =
+ style.IsAuto() ||
+ (!inInlineAxis && style.BehavesLikeInitialValueOnBlockAxis());
+ if ((inInlineAxis && nsIFrame::ToExtremumLength(style)) ||
+ (isAuto && !child->StyleDisplay()->IsScrollableOverflow())) {
+ // Now calculate the "content size" part and return whichever is smaller.
+ MOZ_ASSERT(isAuto || sz == NS_UNCONSTRAINEDSIZE);
+ sz = std::min(sz, ContentContribution(aGridItem, aState, aRC, aCBWM, aAxis,
+ aCache->mPercentageBasis,
+ IntrinsicISizeType::MinISize,
+ aCache->mMinSizeClamp,
+ nsLayoutUtils::MIN_INTRINSIC_ISIZE));
+ }
+ aCache->mMinSize.emplace(sz);
+ return sz;
+}
+
+void nsGridContainerFrame::Tracks::CalculateSizes(
+ GridReflowInput& aState, nsTArray<GridItemInfo>& aGridItems,
+ const TrackSizingFunctions& aFunctions, nscoord aContentBoxSize,
+ LineRange GridArea::*aRange, SizingConstraint aConstraint) {
+ nscoord percentageBasis = aContentBoxSize;
+ if (percentageBasis == NS_UNCONSTRAINEDSIZE) {
+ percentageBasis = 0;
+ }
+ InitializeItemBaselines(aState, aGridItems);
+ ResolveIntrinsicSize(aState, aGridItems, aFunctions, aRange, percentageBasis,
+ aConstraint);
+ if (aConstraint != SizingConstraint::MinContent) {
+ nscoord freeSpace = aContentBoxSize;
+ if (freeSpace != NS_UNCONSTRAINEDSIZE) {
+ freeSpace -= SumOfGridGaps();
+ }
+ DistributeFreeSpace(freeSpace);
+ StretchFlexibleTracks(aState, aGridItems, aFunctions, freeSpace);
+ }
+}
+
+TrackSize::StateBits nsGridContainerFrame::Tracks::StateBitsForRange(
+ const LineRange& aRange) const {
+ MOZ_ASSERT(!aRange.IsAuto(), "must have a definite range");
+ TrackSize::StateBits state = TrackSize::StateBits{0};
+ for (auto i : aRange.Range()) {
+ state |= mSizes[i].mState;
+ }
+ return state;
+}
+
+static void AddSubgridContribution(TrackSize& aSize,
+ nscoord aMarginBorderPadding) {
+ if (aSize.mState & TrackSize::eIntrinsicMinSizing) {
+ aSize.mBase = std::max(aSize.mBase, aMarginBorderPadding);
+ aSize.mLimit = std::max(aSize.mLimit, aSize.mBase);
+ }
+ // XXX maybe eFlexMaxSizing too?
+ // (once we implement https://github.com/w3c/csswg-drafts/issues/2177)
+ if (aSize.mState &
+ (TrackSize::eIntrinsicMaxSizing | TrackSize::eFitContent)) {
+ aSize.mLimit = std::max(aSize.mLimit, aMarginBorderPadding);
+ }
+}
+
+bool nsGridContainerFrame::Tracks::ResolveIntrinsicSizeForNonSpanningItems(
+ GridReflowInput& aState, const TrackSizingFunctions& aFunctions,
+ nscoord aPercentageBasis, SizingConstraint aConstraint,
+ const LineRange& aRange, const GridItemInfo& aGridItem) {
+ gfxContext* rc = &aState.mRenderingContext;
+ WritingMode wm = aState.mWM;
+ CachedIntrinsicSizes cache;
+ TrackSize& sz = mSizes[aRange.mStart];
+
+ // min sizing
+ if (sz.mState & TrackSize::eAutoMinSizing) {
+ nscoord s;
+ // Check if we need to apply "Automatic Minimum Size" and cache it.
+ if (aGridItem.ShouldApplyAutoMinSize(wm, mAxis, aPercentageBasis)) {
+ aGridItem.mState[mAxis] |= ItemState::eApplyAutoMinSize;
+ // Clamp it if it's spanning a definite track max-sizing function.
+ if (TrackSize::IsDefiniteMaxSizing(sz.mState)) {
+ cache.mMinSizeClamp = aFunctions.MaxSizingFor(aRange.mStart)
+ .AsBreadth()
+ .Resolve(aPercentageBasis);
+ aGridItem.mState[mAxis] |= ItemState::eClampMarginBoxMinSize;
+ }
+ if (aConstraint != SizingConstraint::MaxContent) {
+ s = MinContentContribution(aGridItem, aState, rc, wm, mAxis, &cache);
+ } else {
+ s = MaxContentContribution(aGridItem, aState, rc, wm, mAxis, &cache);
+ }
+ } else {
+ s = MinSize(aGridItem, aState, rc, wm, mAxis, &cache);
+ }
+ sz.mBase = std::max(sz.mBase, s);
+ } else if (sz.mState & TrackSize::eMinContentMinSizing) {
+ auto s = MinContentContribution(aGridItem, aState, rc, wm, mAxis, &cache);
+ sz.mBase = std::max(sz.mBase, s);
+ } else if (sz.mState & TrackSize::eMaxContentMinSizing) {
+ auto s = MaxContentContribution(aGridItem, aState, rc, wm, mAxis, &cache);
+ sz.mBase = std::max(sz.mBase, s);
+ }
+
+ // max sizing
+ if (sz.mState & TrackSize::eMinContentMaxSizing) {
+ auto s = MinContentContribution(aGridItem, aState, rc, wm, mAxis, &cache);
+ if (sz.mLimit == NS_UNCONSTRAINEDSIZE) {
+ sz.mLimit = s;
+ } else {
+ sz.mLimit = std::max(sz.mLimit, s);
+ }
+ } else if (sz.mState &
+ (TrackSize::eAutoMaxSizing | TrackSize::eMaxContentMaxSizing)) {
+ auto s = MaxContentContribution(aGridItem, aState, rc, wm, mAxis, &cache);
+ if (sz.mLimit == NS_UNCONSTRAINEDSIZE) {
+ sz.mLimit = s;
+ } else {
+ sz.mLimit = std::max(sz.mLimit, s);
+ }
+ if (MOZ_UNLIKELY(sz.mState & TrackSize::eFitContent)) {
+ // Clamp mLimit to the fit-content() size, for §12.5.1.
+ nscoord fitContentClamp = aFunctions.SizingFor(aRange.mStart)
+ .AsFitContent()
+ .AsBreadth()
+ .Resolve(aPercentageBasis);
+ sz.mLimit = std::min(sz.mLimit, fitContentClamp);
+ }
+ }
+
+ if (sz.mLimit < sz.mBase) {
+ sz.mLimit = sz.mBase;
+ }
+
+ return sz.mState & TrackSize::eFlexMaxSizing;
+}
+
+void nsGridContainerFrame::Tracks::CalculateItemBaselines(
+ nsTArray<ItemBaselineData>& aBaselineItems,
+ BaselineSharingGroup aBaselineGroup) {
+ if (aBaselineItems.IsEmpty()) {
+ return;
+ }
+
+ // Sort the collected items on their baseline track.
+ std::sort(aBaselineItems.begin(), aBaselineItems.end(),
+ ItemBaselineData::IsBaselineTrackLessThan);
+
+ MOZ_ASSERT(mSizes.Length() > 0, "having an item implies at least one track");
+ const uint32_t lastTrack = mSizes.Length() - 1;
+ nscoord maxBaseline = 0;
+ nscoord maxDescent = 0;
+ uint32_t currentTrack = kAutoLine; // guaranteed to not match any item
+ uint32_t trackStartIndex = 0;
+ for (uint32_t i = 0, len = aBaselineItems.Length(); true; ++i) {
+ // Find the maximum baseline and descent in the current track.
+ if (i != len) {
+ const ItemBaselineData& item = aBaselineItems[i];
+ if (currentTrack == item.mBaselineTrack) {
+ maxBaseline = std::max(maxBaseline, item.mBaseline);
+ maxDescent = std::max(maxDescent, item.mSize - item.mBaseline);
+ continue;
+ }
+ }
+ // Iterate the current track again and update the baseline offsets making
+ // all items baseline-aligned within this group in this track.
+ for (uint32_t j = trackStartIndex; j < i; ++j) {
+ const ItemBaselineData& item = aBaselineItems[j];
+ item.mGridItem->mBaselineOffset[mAxis] = maxBaseline - item.mBaseline;
+ MOZ_ASSERT(item.mGridItem->mBaselineOffset[mAxis] >= 0);
+ }
+ if (i != 0) {
+ // Store the size of this baseline-aligned subtree.
+ mSizes[currentTrack].mBaselineSubtreeSize[aBaselineGroup] =
+ maxBaseline + maxDescent;
+ // Record the first(last) baseline for the first(last) track.
+ if (currentTrack == 0 && aBaselineGroup == BaselineSharingGroup::First) {
+ mBaseline[aBaselineGroup] = maxBaseline;
+ }
+ if (currentTrack == lastTrack &&
+ aBaselineGroup == BaselineSharingGroup::Last) {
+ mBaseline[aBaselineGroup] = maxBaseline;
+ }
+ }
+ if (i == len) {
+ break;
+ }
+ // Initialize data for the next track with baseline-aligned items.
+ const ItemBaselineData& item = aBaselineItems[i];
+ currentTrack = item.mBaselineTrack;
+ trackStartIndex = i;
+ maxBaseline = item.mBaseline;
+ maxDescent = item.mSize - item.mBaseline;
+ }
+}
+
+void nsGridContainerFrame::Tracks::InitializeItemBaselines(
+ GridReflowInput& aState, nsTArray<GridItemInfo>& aGridItems) {
+ MOZ_ASSERT(!mIsMasonry);
+ if (aState.mFrame->IsSubgrid(mAxis)) {
+ // A grid container's subgridded axis doesn't have a baseline.
+ return;
+ }
+
+ nsTArray<ItemBaselineData> firstBaselineItems;
+ nsTArray<ItemBaselineData> lastBaselineItems;
+ const WritingMode containerWM = aState.mWM;
+ ComputedStyle* containerStyle = aState.mFrame->Style();
+
+ for (GridItemInfo& gridItem : aGridItems) {
+ if (gridItem.IsSubgrid(mAxis)) {
+ // A subgrid itself is never baseline-aligned.
+ continue;
+ }
+
+ nsIFrame* child = gridItem.mFrame;
+ uint32_t baselineTrack = kAutoLine;
+ auto state = ItemState(0);
+ const auto childWM = child->GetWritingMode();
+
+ const bool isOrthogonal = containerWM.IsOrthogonalTo(childWM);
+ const bool isInlineAxis = mAxis == eLogicalAxisInline; // i.e. columns
+
+ // XXX update the line below to include orthogonal grid/table boxes
+ // XXX since they have baselines in both dimensions. And flexbox with
+ // XXX reversed main/cross axis?
+ const bool itemHasBaselineParallelToTrack = isInlineAxis == isOrthogonal;
+ if (itemHasBaselineParallelToTrack) {
+ // [align|justify]-self:[last ]baseline.
+ auto selfAlignment =
+ isOrthogonal
+ ? child->StylePosition()->UsedJustifySelf(containerStyle)._0
+ : child->StylePosition()->UsedAlignSelf(containerStyle)._0;
+ selfAlignment &= ~StyleAlignFlags::FLAG_BITS;
+ if (selfAlignment == StyleAlignFlags::BASELINE) {
+ state |= ItemState::eFirstBaseline | ItemState::eSelfBaseline;
+ const GridArea& area = gridItem.mArea;
+ baselineTrack = isInlineAxis ? area.mCols.mStart : area.mRows.mStart;
+ } else if (selfAlignment == StyleAlignFlags::LAST_BASELINE) {
+ state |= ItemState::eLastBaseline | ItemState::eSelfBaseline;
+ const GridArea& area = gridItem.mArea;
+ baselineTrack = (isInlineAxis ? area.mCols.mEnd : area.mRows.mEnd) - 1;
+ }
+
+ // [align|justify]-content:[last ]baseline.
+ // https://drafts.csswg.org/css-align-3/#baseline-align-content
+ // "[...] and its computed 'align-self' or 'justify-self' (whichever
+ // affects its block axis) is 'stretch' or 'self-start' ('self-end').
+ // For this purpose, the 'start', 'end', 'flex-start', and 'flex-end'
+ // values of 'align-self' are treated as either 'self-start' or
+ // 'self-end', whichever they end up equivalent to.
+ auto alignContent = child->StylePosition()->mAlignContent.primary;
+ alignContent &= ~StyleAlignFlags::FLAG_BITS;
+ if (alignContent == StyleAlignFlags::BASELINE ||
+ alignContent == StyleAlignFlags::LAST_BASELINE) {
+ const auto selfAlignEdge = alignContent == StyleAlignFlags::BASELINE
+ ? StyleAlignFlags::SELF_START
+ : StyleAlignFlags::SELF_END;
+ bool validCombo = selfAlignment == StyleAlignFlags::NORMAL ||
+ selfAlignment == StyleAlignFlags::STRETCH ||
+ selfAlignment == selfAlignEdge;
+ if (!validCombo) {
+ // We're doing alignment in the axis that's orthogonal to mAxis here.
+ LogicalAxis alignAxis = GetOrthogonalAxis(mAxis);
+ // |sameSide| is true if the container's start side in this axis is
+ // the same as the child's start side, in the child's parallel axis.
+ bool sameSide =
+ containerWM.ParallelAxisStartsOnSameSide(alignAxis, childWM);
+ if (selfAlignment == StyleAlignFlags::LEFT) {
+ selfAlignment = !isInlineAxis || containerWM.IsBidiLTR()
+ ? StyleAlignFlags::START
+ : StyleAlignFlags::END;
+ } else if (selfAlignment == StyleAlignFlags::RIGHT) {
+ selfAlignment = isInlineAxis && containerWM.IsBidiLTR()
+ ? StyleAlignFlags::END
+ : StyleAlignFlags::START;
+ }
+
+ if (selfAlignment == StyleAlignFlags::START ||
+ selfAlignment == StyleAlignFlags::FLEX_START) {
+ validCombo =
+ sameSide == (alignContent == StyleAlignFlags::BASELINE);
+ } else if (selfAlignment == StyleAlignFlags::END ||
+ selfAlignment == StyleAlignFlags::FLEX_END) {
+ validCombo =
+ sameSide == (alignContent == StyleAlignFlags::LAST_BASELINE);
+ }
+ }
+ if (validCombo) {
+ const GridArea& area = gridItem.mArea;
+ if (alignContent == StyleAlignFlags::BASELINE) {
+ state |= ItemState::eFirstBaseline | ItemState::eContentBaseline;
+ baselineTrack =
+ isInlineAxis ? area.mCols.mStart : area.mRows.mStart;
+ } else if (alignContent == StyleAlignFlags::LAST_BASELINE) {
+ state |= ItemState::eLastBaseline | ItemState::eContentBaseline;
+ baselineTrack =
+ (isInlineAxis ? area.mCols.mEnd : area.mRows.mEnd) - 1;
+ }
+ }
+ }
+ }
+
+ if (state & ItemState::eIsBaselineAligned) {
+ // XXXmats if |child| is a descendant of a subgrid then the metrics
+ // below needs to account for the accumulated MPB somehow...
+
+ // XXX available size issue
+ LogicalSize avail(childWM, INFINITE_ISIZE_COORD, NS_UNCONSTRAINEDSIZE);
+ auto* rc = &aState.mRenderingContext;
+ // XXX figure out if we can avoid/merge this reflow with the main reflow.
+ // XXX (after bug 1174569 is sorted out)
+ //
+ // XXX How should we handle percentage padding here? (bug 1330866)
+ // XXX (see ::ContentContribution and how it deals with percentages)
+ // XXX What if the true baseline after line-breaking differs from this
+ // XXX hypothetical baseline based on an infinite inline size?
+ // XXX Maybe we should just call ::ContentContribution here instead?
+ // XXX For now we just pass an unconstrined-bsize CB:
+ LogicalSize cbSize(childWM, 0, NS_UNCONSTRAINEDSIZE);
+ ::MeasuringReflow(child, aState.mReflowInput, rc, avail, cbSize);
+
+ nsGridContainerFrame* grid = do_QueryFrame(child);
+ auto frameSize =
+ isInlineAxis ? child->ISize(containerWM) : child->BSize(containerWM);
+ auto margin = child->GetLogicalUsedMargin(containerWM);
+ auto alignSize =
+ frameSize + (isInlineAxis ? margin.IStartEnd(containerWM)
+ : margin.BStartEnd(containerWM));
+
+ Maybe<nscoord> baseline;
+ auto baselineSharingGroup = state & ItemState::eFirstBaseline
+ ? BaselineSharingGroup::First
+ : BaselineSharingGroup::Last;
+ if (grid) {
+ baseline.emplace((isOrthogonal == isInlineAxis)
+ ? grid->GetBBaseline(baselineSharingGroup)
+ : grid->GetIBaseline(baselineSharingGroup));
+ } else {
+ baseline = child->GetNaturalBaselineBOffset(
+ childWM, baselineSharingGroup, BaselineExportContext::Other);
+
+ if (!baseline) {
+ // If baseline alignment is specified on a grid item whose size in
+ // that axis depends on the size of an intrinsically-sized track, that
+ // item does not participate in baseline alignment, and instead uses
+ // its fallback alignment as if that were originally specified.
+ // https://drafts.csswg.org/css-grid-1/#row-align
+
+ // Check if the item crosses any tracks that are intrinsically sized.
+ auto range = gridItem.mArea.LineRangeForAxis(mAxis).Range();
+ auto isTrackAutoSize =
+ std::find_if(range.begin(), range.end(), [&](auto track) {
+ constexpr auto intrinsicSizeFlags =
+ TrackSize::eIntrinsicMinSizing |
+ TrackSize::eIntrinsicMaxSizing | TrackSize::eFitContent |
+ TrackSize::eFlexMaxSizing;
+ return (mSizes[track].mState & intrinsicSizeFlags) != 0;
+ }) != range.end();
+
+ // If either the track or the item is not auto sized, then the item
+ // participates in baseline alignment.
+ if (!isTrackAutoSize ||
+ !gridItem.IsBSizeDependentOnContainerSize(containerWM)) {
+ baseline.emplace(Baseline::SynthesizeBOffsetFromBorderBox(
+ child, containerWM, baselineSharingGroup));
+ }
+ }
+ }
+
+ if (baseline) {
+ nscoord finalBaseline = *baseline;
+ NS_ASSERTION(finalBaseline != NS_INTRINSIC_ISIZE_UNKNOWN,
+ "about to use an unknown baseline");
+
+ if (baselineSharingGroup == BaselineSharingGroup::First) {
+ finalBaseline += isInlineAxis ? margin.IStart(containerWM)
+ : margin.BStart(containerWM);
+
+ } else {
+ finalBaseline += isInlineAxis ? margin.IEnd(containerWM)
+ : margin.BEnd(containerWM);
+ state |= ItemState::eEndSideBaseline;
+ }
+
+ auto& baselineItems =
+ (baselineSharingGroup == BaselineSharingGroup::First)
+ ? firstBaselineItems
+ : lastBaselineItems;
+ baselineItems.AppendElement(ItemBaselineData{
+ baselineTrack, finalBaseline, alignSize, &gridItem});
+ } else {
+ state &= ~ItemState::eAllBaselineBits;
+ }
+ }
+
+ MOZ_ASSERT(
+ (state & (ItemState::eFirstBaseline | ItemState::eLastBaseline)) !=
+ (ItemState::eFirstBaseline | ItemState::eLastBaseline),
+ "first/last baseline bits are mutually exclusive");
+ MOZ_ASSERT(
+ (state & (ItemState::eSelfBaseline | ItemState::eContentBaseline)) !=
+ (ItemState::eSelfBaseline | ItemState::eContentBaseline),
+ "*-self and *-content baseline bits are mutually exclusive");
+ MOZ_ASSERT(
+ !(state & (ItemState::eFirstBaseline | ItemState::eLastBaseline)) ==
+ !(state & (ItemState::eSelfBaseline | ItemState::eContentBaseline)),
+ "first/last bit requires self/content bit and vice versa");
+
+ gridItem.mState[mAxis] |= state;
+ gridItem.mBaselineOffset[mAxis] = nscoord(0);
+ }
+
+ if (firstBaselineItems.IsEmpty() && lastBaselineItems.IsEmpty()) {
+ return;
+ }
+
+ // TODO: CSS Align spec issue - how to align a baseline subtree in a track?
+ // https://lists.w3.org/Archives/Public/www-style/2016May/0141.html
+ mBaselineSubtreeAlign[BaselineSharingGroup::First] = StyleAlignFlags::START;
+ mBaselineSubtreeAlign[BaselineSharingGroup::Last] = StyleAlignFlags::END;
+
+ CalculateItemBaselines(firstBaselineItems, BaselineSharingGroup::First);
+ CalculateItemBaselines(lastBaselineItems, BaselineSharingGroup::Last);
+}
+
+// TODO: we store the wrong baseline group offset in some cases (bug 1632200)
+void nsGridContainerFrame::Tracks::InitializeItemBaselinesInMasonryAxis(
+ GridReflowInput& aState, nsTArray<GridItemInfo>& aGridItems,
+ BaselineAlignmentSet aSet, const nsSize& aContainerSize,
+ nsTArray<nscoord>& aTrackSizes,
+ nsTArray<ItemBaselineData>& aFirstBaselineItems,
+ nsTArray<ItemBaselineData>& aLastBaselineItems) {
+ MOZ_ASSERT(mIsMasonry);
+ WritingMode wm = aState.mWM;
+ ComputedStyle* containerSC = aState.mFrame->Style();
+ for (GridItemInfo& gridItem : aGridItems) {
+ if (gridItem.IsSubgrid(mAxis)) {
+ // A subgrid itself is never baseline-aligned.
+ continue;
+ }
+ const auto& area = gridItem.mArea;
+ if (aSet.mItemSet == BaselineAlignmentSet::LastItems) {
+ // NOTE: eIsLastItemInMasonryTrack is set also if the item is the ONLY
+ // item in its track; the eIsBaselineAligned check excludes it though
+ // since it participates in the start baseline groups in that case.
+ //
+ // XXX what if it's the only item in THAT baseline group?
+ // XXX should it participate in the last-item group instead then
+ // if there are more baseline-aligned items there?
+ if (!(gridItem.mState[mAxis] & ItemState::eIsLastItemInMasonryTrack) ||
+ (gridItem.mState[mAxis] & ItemState::eIsBaselineAligned)) {
+ continue;
+ }
+ } else {
+ if (area.LineRangeForAxis(mAxis).mStart > 0 ||
+ (gridItem.mState[mAxis] & ItemState::eIsBaselineAligned)) {
+ continue;
+ }
+ }
+ auto trackAlign =
+ aState.mGridStyle
+ ->UsedTracksAlignment(
+ mAxis, area.LineRangeForAxis(GetOrthogonalAxis(mAxis)).mStart)
+ .primary;
+ if (!aSet.MatchTrackAlignment(trackAlign)) {
+ continue;
+ }
+
+ nsIFrame* child = gridItem.mFrame;
+ uint32_t baselineTrack = kAutoLine;
+ auto state = ItemState(0);
+ auto childWM = child->GetWritingMode();
+ const bool isOrthogonal = wm.IsOrthogonalTo(childWM);
+ const bool isInlineAxis = mAxis == eLogicalAxisInline; // i.e. columns
+ // XXX update the line below to include orthogonal grid/table boxes
+ // XXX since they have baselines in both dimensions. And flexbox with
+ // XXX reversed main/cross axis?
+ const bool itemHasBaselineParallelToTrack = isInlineAxis == isOrthogonal;
+ if (itemHasBaselineParallelToTrack) {
+ const auto* pos = child->StylePosition();
+ // [align|justify]-self:[last ]baseline.
+ auto selfAlignment = pos->UsedSelfAlignment(mAxis, containerSC);
+ selfAlignment &= ~StyleAlignFlags::FLAG_BITS;
+ if (selfAlignment == StyleAlignFlags::BASELINE) {
+ state |= ItemState::eFirstBaseline | ItemState::eSelfBaseline;
+ baselineTrack = isInlineAxis ? area.mCols.mStart : area.mRows.mStart;
+ } else if (selfAlignment == StyleAlignFlags::LAST_BASELINE) {
+ state |= ItemState::eLastBaseline | ItemState::eSelfBaseline;
+ baselineTrack = (isInlineAxis ? area.mCols.mEnd : area.mRows.mEnd) - 1;
+ } else {
+ // [align|justify]-content:[last ]baseline.
+ auto childAxis = isOrthogonal ? GetOrthogonalAxis(mAxis) : mAxis;
+ auto alignContent = pos->UsedContentAlignment(childAxis).primary;
+ alignContent &= ~StyleAlignFlags::FLAG_BITS;
+ if (alignContent == StyleAlignFlags::BASELINE) {
+ state |= ItemState::eFirstBaseline | ItemState::eContentBaseline;
+ baselineTrack = isInlineAxis ? area.mCols.mStart : area.mRows.mStart;
+ } else if (alignContent == StyleAlignFlags::LAST_BASELINE) {
+ state |= ItemState::eLastBaseline | ItemState::eContentBaseline;
+ baselineTrack =
+ (isInlineAxis ? area.mCols.mEnd : area.mRows.mEnd) - 1;
+ }
+ }
+ }
+
+ if (state & ItemState::eIsBaselineAligned) {
+ // XXXmats if |child| is a descendant of a subgrid then the metrics
+ // below needs to account for the accumulated MPB somehow...
+
+ nscoord baseline;
+ nsGridContainerFrame* grid = do_QueryFrame(child);
+ if (state & ItemState::eFirstBaseline) {
+ if (grid) {
+ if (isOrthogonal == isInlineAxis) {
+ baseline = grid->GetBBaseline(BaselineSharingGroup::First);
+ } else {
+ baseline = grid->GetIBaseline(BaselineSharingGroup::First);
+ }
+ }
+ if (grid || nsLayoutUtils::GetFirstLineBaseline(wm, child, &baseline)) {
+ NS_ASSERTION(baseline != NS_INTRINSIC_ISIZE_UNKNOWN,
+ "about to use an unknown baseline");
+ auto frameSize = isInlineAxis ? child->ISize(wm) : child->BSize(wm);
+ nscoord alignSize;
+ LogicalPoint pos =
+ child->GetLogicalNormalPosition(wm, aContainerSize);
+ baseline += pos.Pos(mAxis, wm);
+ if (aSet.mTrackAlignmentSet == BaselineAlignmentSet::EndStretch) {
+ state |= ItemState::eEndSideBaseline;
+ // Convert to distance from the track end.
+ baseline =
+ aTrackSizes[gridItem.mArea
+ .LineRangeForAxis(GetOrthogonalAxis(mAxis))
+ .mStart] -
+ baseline;
+ }
+ alignSize = frameSize;
+ aFirstBaselineItems.AppendElement(ItemBaselineData(
+ {baselineTrack, baseline, alignSize, &gridItem}));
+ } else {
+ state &= ~ItemState::eAllBaselineBits;
+ }
+ } else {
+ if (grid) {
+ if (isOrthogonal == isInlineAxis) {
+ baseline = grid->GetBBaseline(BaselineSharingGroup::Last);
+ } else {
+ baseline = grid->GetIBaseline(BaselineSharingGroup::Last);
+ }
+ }
+ if (grid || nsLayoutUtils::GetLastLineBaseline(wm, child, &baseline)) {
+ NS_ASSERTION(baseline != NS_INTRINSIC_ISIZE_UNKNOWN,
+ "about to use an unknown baseline");
+ auto frameSize = isInlineAxis ? child->ISize(wm) : child->BSize(wm);
+ auto m = child->GetLogicalUsedMargin(wm);
+ if (!grid &&
+ aSet.mTrackAlignmentSet == BaselineAlignmentSet::EndStretch) {
+ // Convert to distance from border-box end.
+ state |= ItemState::eEndSideBaseline;
+ LogicalPoint pos =
+ child->GetLogicalNormalPosition(wm, aContainerSize);
+ baseline += pos.Pos(mAxis, wm);
+ baseline =
+ aTrackSizes[gridItem.mArea
+ .LineRangeForAxis(GetOrthogonalAxis(mAxis))
+ .mStart] -
+ baseline;
+ } else if (grid && aSet.mTrackAlignmentSet ==
+ BaselineAlignmentSet::StartStretch) {
+ // Convert to distance from border-box start.
+ baseline = frameSize - baseline;
+ }
+ if (aSet.mItemSet == BaselineAlignmentSet::LastItems &&
+ aSet.mTrackAlignmentSet == BaselineAlignmentSet::StartStretch) {
+ LogicalPoint pos =
+ child->GetLogicalNormalPosition(wm, aContainerSize);
+ baseline += pos.B(wm);
+ }
+ if (aSet.mTrackAlignmentSet == BaselineAlignmentSet::EndStretch) {
+ state |= ItemState::eEndSideBaseline;
+ }
+ auto descent =
+ baseline + ((state & ItemState::eEndSideBaseline)
+ ? (isInlineAxis ? m.IEnd(wm) : m.BEnd(wm))
+ : (isInlineAxis ? m.IStart(wm) : m.BStart(wm)));
+ auto alignSize =
+ frameSize + (isInlineAxis ? m.IStartEnd(wm) : m.BStartEnd(wm));
+ aLastBaselineItems.AppendElement(
+ ItemBaselineData({baselineTrack, descent, alignSize, &gridItem}));
+ } else {
+ state &= ~ItemState::eAllBaselineBits;
+ }
+ }
+ }
+ MOZ_ASSERT(
+ (state & (ItemState::eFirstBaseline | ItemState::eLastBaseline)) !=
+ (ItemState::eFirstBaseline | ItemState::eLastBaseline),
+ "first/last baseline bits are mutually exclusive");
+ MOZ_ASSERT(
+ (state & (ItemState::eSelfBaseline | ItemState::eContentBaseline)) !=
+ (ItemState::eSelfBaseline | ItemState::eContentBaseline),
+ "*-self and *-content baseline bits are mutually exclusive");
+ MOZ_ASSERT(
+ !(state & (ItemState::eFirstBaseline | ItemState::eLastBaseline)) ==
+ !(state & (ItemState::eSelfBaseline | ItemState::eContentBaseline)),
+ "first/last bit requires self/content bit and vice versa");
+ gridItem.mState[mAxis] |= state;
+ gridItem.mBaselineOffset[mAxis] = nscoord(0);
+ }
+
+ CalculateItemBaselines(aFirstBaselineItems, BaselineSharingGroup::First);
+ CalculateItemBaselines(aLastBaselineItems, BaselineSharingGroup::Last);
+
+ // TODO: make sure the mBaselines (i.e. the baselines we export from
+ // the grid container) are offset from the correct container edge.
+ // Also, which of the baselines do we pick to export exactly?
+
+ MOZ_ASSERT(aFirstBaselineItems.Length() != 1 ||
+ aFirstBaselineItems[0].mGridItem->mBaselineOffset[mAxis] == 0,
+ "a baseline group that contains only one item should not "
+ "produce a non-zero item baseline offset");
+ MOZ_ASSERT(aLastBaselineItems.Length() != 1 ||
+ aLastBaselineItems[0].mGridItem->mBaselineOffset[mAxis] == 0,
+ "a baseline group that contains only one item should not "
+ "produce a non-zero item baseline offset");
+}
+
+void nsGridContainerFrame::Tracks::AlignBaselineSubtree(
+ const GridItemInfo& aGridItem) const {
+ if (mIsMasonry) {
+ return;
+ }
+ auto state = aGridItem.mState[mAxis];
+ if (!(state & ItemState::eIsBaselineAligned)) {
+ return;
+ }
+ const GridArea& area = aGridItem.mArea;
+ int32_t baselineTrack;
+ const bool isFirstBaseline = state & ItemState::eFirstBaseline;
+ if (isFirstBaseline) {
+ baselineTrack =
+ mAxis == eLogicalAxisBlock ? area.mRows.mStart : area.mCols.mStart;
+ } else {
+ baselineTrack =
+ (mAxis == eLogicalAxisBlock ? area.mRows.mEnd : area.mCols.mEnd) - 1;
+ }
+ const TrackSize& sz = mSizes[baselineTrack];
+ auto baselineGroup = isFirstBaseline ? BaselineSharingGroup::First
+ : BaselineSharingGroup::Last;
+ nscoord delta = sz.mBase - sz.mBaselineSubtreeSize[baselineGroup];
+ const auto subtreeAlign = mBaselineSubtreeAlign[baselineGroup];
+ if (subtreeAlign == StyleAlignFlags::START) {
+ if (state & ItemState::eLastBaseline) {
+ aGridItem.mBaselineOffset[mAxis] += delta;
+ }
+ } else if (subtreeAlign == StyleAlignFlags::END) {
+ if (isFirstBaseline) {
+ aGridItem.mBaselineOffset[mAxis] += delta;
+ }
+ } else if (subtreeAlign == StyleAlignFlags::CENTER) {
+ aGridItem.mBaselineOffset[mAxis] += delta / 2;
+ } else {
+ MOZ_ASSERT_UNREACHABLE("unexpected baseline subtree alignment");
+ }
+}
+
+template <nsGridContainerFrame::Tracks::TrackSizingPhase phase>
+bool nsGridContainerFrame::Tracks::GrowSizeForSpanningItems(
+ nsTArray<SpanningItemData>::iterator aIter,
+ nsTArray<SpanningItemData>::iterator aIterEnd, nsTArray<uint32_t>& aTracks,
+ nsTArray<TrackSize>& aPlan, nsTArray<TrackSize>& aItemPlan,
+ TrackSize::StateBits aSelector, const FitContentClamper& aFitContentClamper,
+ bool aNeedInfinitelyGrowableFlag) {
+ constexpr bool isMaxSizingPhase =
+ phase == TrackSizingPhase::IntrinsicMaximums ||
+ phase == TrackSizingPhase::MaxContentMaximums;
+ bool needToUpdateSizes = false;
+ InitializePlan<phase>(aPlan);
+ for (; aIter != aIterEnd; ++aIter) {
+ const SpanningItemData& item = *aIter;
+ if (!(item.mState & aSelector)) {
+ continue;
+ }
+ if (isMaxSizingPhase) {
+ for (auto i : item.mLineRange.Range()) {
+ aPlan[i].mState |= TrackSize::eModified;
+ }
+ }
+ nscoord space = item.SizeContributionForPhase<phase>();
+ if (space <= 0) {
+ continue;
+ }
+ aTracks.ClearAndRetainStorage();
+ space = CollectGrowable<phase>(space, item.mLineRange, aSelector, aTracks);
+ if (space > 0) {
+ DistributeToTrackSizes<phase>(space, aPlan, aItemPlan, aTracks, aSelector,
+ aFitContentClamper);
+ needToUpdateSizes = true;
+ }
+ }
+ if (isMaxSizingPhase) {
+ needToUpdateSizes = true;
+ }
+ if (needToUpdateSizes) {
+ CopyPlanToSize<phase>(aPlan, aNeedInfinitelyGrowableFlag);
+ }
+ return needToUpdateSizes;
+}
+
+void nsGridContainerFrame::Tracks::ResolveIntrinsicSize(
+ GridReflowInput& aState, nsTArray<GridItemInfo>& aGridItems,
+ const TrackSizingFunctions& aFunctions, LineRange GridArea::*aRange,
+ nscoord aPercentageBasis, SizingConstraint aConstraint) {
+ // Resolve Intrinsic Track Sizes
+ // https://w3c.github.io/csswg-drafts/css-grid-1/#algo-content
+ // We're also setting eIsFlexing on the item state here to speed up
+ // FindUsedFlexFraction later.
+
+ gfxContext* rc = &aState.mRenderingContext;
+ WritingMode wm = aState.mWM;
+
+ // Data we accumulate when grouping similar sized spans together.
+ struct PerSpanData {
+ uint32_t mItemCountWithSameSpan = 0;
+ TrackSize::StateBits mStateBits = TrackSize::StateBits{0};
+ };
+ AutoTArray<PerSpanData, 16> perSpanData;
+
+ nsTArray<SpanningItemData> spanningItems;
+ uint32_t maxSpan = 0; // max span of items in `spanningItems`.
+
+ // Setup track selector for step 3.2:
+ const auto contentBasedMinSelector =
+ aConstraint == SizingConstraint::MinContent
+ ? TrackSize::eIntrinsicMinSizing
+ : TrackSize::eMinOrMaxContentMinSizing;
+
+ // Setup track selector for step 3.3:
+ const auto maxContentMinSelector =
+ aConstraint == SizingConstraint::MaxContent
+ ? (TrackSize::eMaxContentMinSizing | TrackSize::eAutoMinSizing)
+ : TrackSize::eMaxContentMinSizing;
+
+ const auto orthogonalAxis = GetOrthogonalAxis(mAxis);
+ const bool isMasonryInOtherAxis = aState.mFrame->IsMasonry(orthogonalAxis);
+
+ for (auto& gridItem : aGridItems) {
+ MOZ_ASSERT(!(gridItem.mState[mAxis] &
+ (ItemState::eApplyAutoMinSize | ItemState::eIsFlexing |
+ ItemState::eClampMarginBoxMinSize)),
+ "Why are any of these bits set already?");
+
+ const GridArea& area = gridItem.mArea;
+ const LineRange& lineRange = area.*aRange;
+
+ // If we have masonry layout in the other axis then skip this item unless
+ // it's in the first masonry track, or has definite placement in this axis,
+ // or spans all tracks in this axis (since that implies it will be placed
+ // at line 1 regardless of layout results of other items).
+ if (isMasonryInOtherAxis &&
+ gridItem.mArea.LineRangeForAxis(orthogonalAxis).mStart != 0 &&
+ (gridItem.mState[mAxis] & ItemState::eAutoPlacement) &&
+ gridItem.mArea.LineRangeForAxis(mAxis).Extent() != mSizes.Length()) {
+ continue;
+ }
+
+ uint32_t span = lineRange.Extent();
+ if (MOZ_UNLIKELY(gridItem.mState[mAxis] & ItemState::eIsSubgrid)) {
+ auto itemWM = gridItem.mFrame->GetWritingMode();
+ auto percentageBasis = aState.PercentageBasisFor(mAxis, gridItem);
+
+ if (percentageBasis.ISize(itemWM) == NS_UNCONSTRAINEDSIZE) {
+ percentageBasis.ISize(itemWM) = nscoord(0);
+ }
+
+ if (percentageBasis.BSize(itemWM) == NS_UNCONSTRAINEDSIZE) {
+ percentageBasis.BSize(itemWM) = nscoord(0);
+ }
+
+ auto* subgrid =
+ SubgridComputeMarginBorderPadding(gridItem, percentageBasis);
+ LogicalMargin mbp = SubgridAccumulatedMarginBorderPadding(
+ gridItem.SubgridFrame(), subgrid, wm, mAxis);
+
+ if (span == 1) {
+ AddSubgridContribution(mSizes[lineRange.mStart],
+ mbp.StartEnd(mAxis, wm));
+ } else {
+ AddSubgridContribution(mSizes[lineRange.mStart], mbp.Start(mAxis, wm));
+ AddSubgridContribution(mSizes[lineRange.mEnd - 1], mbp.End(mAxis, wm));
+ }
+ continue;
+ }
+
+ if (span == 1) {
+ // Step 2. Size tracks to fit non-spanning items.
+ if (ResolveIntrinsicSizeForNonSpanningItems(aState, aFunctions,
+ aPercentageBasis, aConstraint,
+ lineRange, gridItem)) {
+ gridItem.mState[mAxis] |= ItemState::eIsFlexing;
+ }
+ } else {
+ TrackSize::StateBits state = StateBitsForRange(lineRange);
+
+ // Check if we need to apply "Automatic Minimum Size" and cache it.
+ if ((state & TrackSize::eAutoMinSizing) &&
+ !(state & TrackSize::eFlexMaxSizing) &&
+ gridItem.ShouldApplyAutoMinSize(wm, mAxis, aPercentageBasis)) {
+ gridItem.mState[mAxis] |= ItemState::eApplyAutoMinSize;
+ }
+
+ if (state & TrackSize::eFlexMaxSizing) {
+ gridItem.mState[mAxis] |= ItemState::eIsFlexing;
+ } else if (state & (TrackSize::eIntrinsicMinSizing |
+ TrackSize::eIntrinsicMaxSizing)) {
+ // Collect data for Step 3.
+ maxSpan = std::max(maxSpan, span);
+ if (span >= perSpanData.Length()) {
+ perSpanData.SetLength(2 * span);
+ }
+
+ perSpanData[span].mItemCountWithSameSpan++;
+ perSpanData[span].mStateBits |= state;
+
+ CachedIntrinsicSizes cache;
+
+ // Calculate data for "Automatic Minimum Size" clamping, if needed.
+ if (TrackSize::IsDefiniteMaxSizing(state) &&
+ (gridItem.mState[mAxis] & ItemState::eApplyAutoMinSize)) {
+ nscoord minSizeClamp = 0;
+ for (auto i : lineRange.Range()) {
+ minSizeClamp += aFunctions.MaxSizingFor(i).AsBreadth().Resolve(
+ aPercentageBasis);
+ }
+ minSizeClamp += mGridGap * (span - 1);
+ cache.mMinSizeClamp = minSizeClamp;
+ gridItem.mState[mAxis] |= ItemState::eClampMarginBoxMinSize;
+ }
+
+ // Collect the various grid item size contributions we need.
+ nscoord minSize = 0;
+ if (state & TrackSize::eIntrinsicMinSizing) { // for 3.1
+ minSize = MinSize(gridItem, aState, rc, wm, mAxis, &cache);
+ }
+ nscoord minContent = 0;
+ if (state & (contentBasedMinSelector | // for 3.2
+ TrackSize::eIntrinsicMaxSizing)) { // for 3.5
+ minContent =
+ MinContentContribution(gridItem, aState, rc, wm, mAxis, &cache);
+ }
+ nscoord maxContent = 0;
+ if (state & (maxContentMinSelector | // for 3.3
+ TrackSize::eAutoOrMaxContentMaxSizing)) { // for 3.6
+ maxContent =
+ MaxContentContribution(gridItem, aState, rc, wm, mAxis, &cache);
+ }
+
+ spanningItems.AppendElement(
+ SpanningItemData({span, state, lineRange, minSize, minContent,
+ maxContent, gridItem.mFrame}));
+ }
+ }
+
+ MOZ_ASSERT(!(gridItem.mState[mAxis] & ItemState::eClampMarginBoxMinSize) ||
+ (gridItem.mState[mAxis] & ItemState::eApplyAutoMinSize),
+ "clamping only applies to Automatic Minimum Size");
+ }
+
+ // Step 3 - Increase sizes to accommodate spanning items crossing
+ // content-sized tracks.
+ if (maxSpan) {
+ auto fitContentClamper = [&aFunctions, aPercentageBasis](uint32_t aTrack,
+ nscoord aMinSize,
+ nscoord* aSize) {
+ nscoord fitContentLimit = ::ResolveToDefiniteSize(
+ aFunctions.MaxSizingFor(aTrack), aPercentageBasis);
+ if (*aSize > fitContentLimit) {
+ *aSize = std::max(aMinSize, fitContentLimit);
+ return true;
+ }
+ return false;
+ };
+
+ // Sort the collected items on span length, shortest first. There's no need
+ // for a stable sort here since the sizing isn't order dependent within
+ // a group of items with the same span length.
+ std::sort(spanningItems.begin(), spanningItems.end(),
+ SpanningItemData::IsSpanLessThan);
+
+ nsTArray<uint32_t> tracks(maxSpan);
+ nsTArray<TrackSize> plan(mSizes.Length());
+ plan.SetLength(mSizes.Length());
+ nsTArray<TrackSize> itemPlan(mSizes.Length());
+ itemPlan.SetLength(mSizes.Length());
+ // Start / end iterator for items of the same span length:
+ auto spanGroupStart = spanningItems.begin();
+ auto spanGroupEnd = spanGroupStart;
+ const auto end = spanningItems.end();
+ for (; spanGroupStart != end; spanGroupStart = spanGroupEnd) {
+ const uint32_t span = spanGroupStart->mSpan;
+ spanGroupEnd = spanGroupStart + perSpanData[span].mItemCountWithSameSpan;
+ TrackSize::StateBits stateBitsForSpan = perSpanData[span].mStateBits;
+ bool updatedBase = false; // Did we update any mBase in step 3.1..3.3?
+ TrackSize::StateBits selector(TrackSize::eIntrinsicMinSizing);
+ if (stateBitsForSpan & selector) {
+ // Step 3.1 MinSize to intrinsic min-sizing.
+ updatedBase =
+ GrowSizeForSpanningItems<TrackSizingPhase::IntrinsicMinimums>(
+ spanGroupStart, spanGroupEnd, tracks, plan, itemPlan, selector);
+ }
+
+ selector = contentBasedMinSelector;
+ if (stateBitsForSpan & selector) {
+ // Step 3.2 MinContentContribution to min-/max-content (and 'auto' when
+ // sizing under a min-content constraint) min-sizing.
+ updatedBase |=
+ GrowSizeForSpanningItems<TrackSizingPhase::ContentBasedMinimums>(
+ spanGroupStart, spanGroupEnd, tracks, plan, itemPlan, selector);
+ }
+
+ selector = maxContentMinSelector;
+ if (stateBitsForSpan & selector) {
+ // Step 3.3 MaxContentContribution to max-content (and 'auto' when
+ // sizing under a max-content constraint) min-sizing.
+ updatedBase |=
+ GrowSizeForSpanningItems<TrackSizingPhase::MaxContentMinimums>(
+ spanGroupStart, spanGroupEnd, tracks, plan, itemPlan, selector);
+ }
+
+ if (updatedBase) {
+ // Step 3.4
+ for (TrackSize& sz : mSizes) {
+ if (sz.mBase > sz.mLimit) {
+ sz.mLimit = sz.mBase;
+ }
+ }
+ }
+
+ selector = TrackSize::eIntrinsicMaxSizing;
+ if (stateBitsForSpan & selector) {
+ const bool willRunStep3_6 =
+ stateBitsForSpan & TrackSize::eAutoOrMaxContentMaxSizing;
+ // Step 3.5 MinContentContribution to intrinsic max-sizing.
+ GrowSizeForSpanningItems<TrackSizingPhase::IntrinsicMaximums>(
+ spanGroupStart, spanGroupEnd, tracks, plan, itemPlan, selector,
+ fitContentClamper, willRunStep3_6);
+
+ if (willRunStep3_6) {
+ // Step 2.6 MaxContentContribution to max-content max-sizing.
+ selector = TrackSize::eAutoOrMaxContentMaxSizing;
+ GrowSizeForSpanningItems<TrackSizingPhase::MaxContentMaximums>(
+ spanGroupStart, spanGroupEnd, tracks, plan, itemPlan, selector,
+ fitContentClamper);
+ }
+ }
+ }
+ }
+
+ // Step 5 - If any track still has an infinite growth limit, set its growth
+ // limit to its base size.
+ for (TrackSize& sz : mSizes) {
+ if (sz.mLimit == NS_UNCONSTRAINEDSIZE) {
+ sz.mLimit = sz.mBase;
+ }
+ }
+}
+
+float nsGridContainerFrame::Tracks::FindFrUnitSize(
+ const LineRange& aRange, const nsTArray<uint32_t>& aFlexTracks,
+ const TrackSizingFunctions& aFunctions, nscoord aSpaceToFill) const {
+ MOZ_ASSERT(aSpaceToFill > 0 && !aFlexTracks.IsEmpty());
+ float flexFactorSum = 0.0f;
+ nscoord leftOverSpace = aSpaceToFill;
+ for (auto i : aRange.Range()) {
+ const TrackSize& sz = mSizes[i];
+ if (sz.mState & TrackSize::eFlexMaxSizing) {
+ flexFactorSum += aFunctions.MaxSizingFor(i).AsFr();
+ } else {
+ leftOverSpace -= sz.mBase;
+ if (leftOverSpace <= 0) {
+ return 0.0f;
+ }
+ }
+ }
+ bool restart;
+ float hypotheticalFrSize;
+ nsTArray<uint32_t> flexTracks(aFlexTracks.Clone());
+ uint32_t numFlexTracks = flexTracks.Length();
+ do {
+ restart = false;
+ hypotheticalFrSize = leftOverSpace / std::max(flexFactorSum, 1.0f);
+ for (uint32_t i = 0, len = flexTracks.Length(); i < len; ++i) {
+ uint32_t track = flexTracks[i];
+ if (track == kAutoLine) {
+ continue; // Track marked as inflexible in a prev. iter of this loop.
+ }
+ float flexFactor = aFunctions.MaxSizingFor(track).AsFr();
+ const nscoord base = mSizes[track].mBase;
+ if (flexFactor * hypotheticalFrSize < base) {
+ // 12.7.1.4: Treat this track as inflexible.
+ flexTracks[i] = kAutoLine;
+ flexFactorSum -= flexFactor;
+ leftOverSpace -= base;
+ --numFlexTracks;
+ if (numFlexTracks == 0 || leftOverSpace <= 0) {
+ return 0.0f;
+ }
+ restart = true;
+ // break; XXX (bug 1176621 comment 16) measure which is more common
+ }
+ }
+ } while (restart);
+ return hypotheticalFrSize;
+}
+
+float nsGridContainerFrame::Tracks::FindUsedFlexFraction(
+ GridReflowInput& aState, nsTArray<GridItemInfo>& aGridItems,
+ const nsTArray<uint32_t>& aFlexTracks,
+ const TrackSizingFunctions& aFunctions, nscoord aAvailableSize) const {
+ if (aAvailableSize != NS_UNCONSTRAINEDSIZE) {
+ // Use all of the grid tracks and a 'space to fill' of the available space.
+ const TranslatedLineRange range(0, mSizes.Length());
+ return FindFrUnitSize(range, aFlexTracks, aFunctions, aAvailableSize);
+ }
+
+ // The used flex fraction is the maximum of:
+ // ... each flexible track's base size divided by its flex factor (which is
+ // floored at 1).
+ float fr = 0.0f;
+ for (uint32_t track : aFlexTracks) {
+ float flexFactor = aFunctions.MaxSizingFor(track).AsFr();
+ float possiblyDividedBaseSize = (flexFactor > 1.0f)
+ ? mSizes[track].mBase / flexFactor
+ : mSizes[track].mBase;
+ fr = std::max(fr, possiblyDividedBaseSize);
+ }
+ WritingMode wm = aState.mWM;
+ gfxContext* rc = &aState.mRenderingContext;
+ // ... the result of 'finding the size of an fr' for each item that spans
+ // a flex track with its max-content contribution as 'space to fill'
+ for (const GridItemInfo& item : aGridItems) {
+ if (item.mState[mAxis] & ItemState::eIsFlexing) {
+ // XXX optimize: bug 1194446
+ auto pb = Some(aState.PercentageBasisFor(mAxis, item));
+ nscoord spaceToFill = ContentContribution(item, aState, rc, wm, mAxis, pb,
+ IntrinsicISizeType::PrefISize);
+ const LineRange& range =
+ mAxis == eLogicalAxisInline ? item.mArea.mCols : item.mArea.mRows;
+ MOZ_ASSERT(range.Extent() >= 1);
+ const auto spannedGaps = range.Extent() - 1;
+ if (spannedGaps > 0) {
+ spaceToFill -= mGridGap * spannedGaps;
+ }
+ if (spaceToFill <= 0) {
+ continue;
+ }
+ // ... and all its spanned tracks as input.
+ nsTArray<uint32_t> itemFlexTracks;
+ for (auto i : range.Range()) {
+ if (mSizes[i].mState & TrackSize::eFlexMaxSizing) {
+ itemFlexTracks.AppendElement(i);
+ }
+ }
+ float itemFr =
+ FindFrUnitSize(range, itemFlexTracks, aFunctions, spaceToFill);
+ fr = std::max(fr, itemFr);
+ }
+ }
+ return fr;
+}
+
+void nsGridContainerFrame::Tracks::StretchFlexibleTracks(
+ GridReflowInput& aState, nsTArray<GridItemInfo>& aGridItems,
+ const TrackSizingFunctions& aFunctions, nscoord aAvailableSize) {
+ if (aAvailableSize <= 0) {
+ return;
+ }
+ nsTArray<uint32_t> flexTracks(mSizes.Length());
+ for (uint32_t i = 0, len = mSizes.Length(); i < len; ++i) {
+ if (mSizes[i].mState & TrackSize::eFlexMaxSizing) {
+ flexTracks.AppendElement(i);
+ }
+ }
+ if (flexTracks.IsEmpty()) {
+ return;
+ }
+ nscoord minSize = 0;
+ nscoord maxSize = NS_UNCONSTRAINEDSIZE;
+ if (aState.mReflowInput) {
+ auto* ri = aState.mReflowInput;
+ minSize = mAxis == eLogicalAxisBlock ? ri->ComputedMinBSize()
+ : ri->ComputedMinISize();
+ maxSize = mAxis == eLogicalAxisBlock ? ri->ComputedMaxBSize()
+ : ri->ComputedMaxISize();
+ }
+ Maybe<CopyableAutoTArray<TrackSize, 32>> origSizes;
+ bool applyMinMax = (minSize != 0 || maxSize != NS_UNCONSTRAINEDSIZE) &&
+ aAvailableSize == NS_UNCONSTRAINEDSIZE;
+ // We iterate twice at most. The 2nd time if the grid size changed after
+ // applying a min/max-size (can only occur if aAvailableSize is indefinite).
+ while (true) {
+ float fr = FindUsedFlexFraction(aState, aGridItems, flexTracks, aFunctions,
+ aAvailableSize);
+ if (fr != 0.0f) {
+ for (uint32_t i : flexTracks) {
+ float flexFactor = aFunctions.MaxSizingFor(i).AsFr();
+ nscoord flexLength = NSToCoordRound(flexFactor * fr);
+ nscoord& base = mSizes[i].mBase;
+ if (flexLength > base) {
+ if (applyMinMax && origSizes.isNothing()) {
+ origSizes.emplace(mSizes);
+ }
+ base = flexLength;
+ }
+ }
+ }
+ if (applyMinMax) {
+ applyMinMax = false;
+ // https://drafts.csswg.org/css-grid/#algo-flex-tracks
+ // "If using this flex fraction would cause the grid to be smaller than
+ // the grid container’s min-width/height (or larger than the grid
+ // container’s max-width/height), then redo this step, treating the free
+ // space as definite [...]"
+ const auto sumOfGridGaps = SumOfGridGaps();
+ nscoord newSize = SumOfGridTracks() + sumOfGridGaps;
+ if (newSize > maxSize) {
+ aAvailableSize = maxSize;
+ } else if (newSize < minSize) {
+ aAvailableSize = minSize;
+ }
+ if (aAvailableSize != NS_UNCONSTRAINEDSIZE) {
+ aAvailableSize = std::max(0, aAvailableSize - sumOfGridGaps);
+ // Restart with the original track sizes and definite aAvailableSize.
+ if (origSizes.isSome()) {
+ mSizes = std::move(*origSizes);
+ origSizes.reset();
+ } // else, no mSizes[].mBase were changed above so it's still correct
+ if (aAvailableSize == 0) {
+ break; // zero available size wouldn't change any sizes though...
+ }
+ continue;
+ }
+ }
+ break;
+ }
+}
+
+void nsGridContainerFrame::Tracks::AlignJustifyContent(
+ const nsStylePosition* aStyle, StyleContentDistribution aAligmentStyleValue,
+ WritingMode aWM, nscoord aContentBoxSize, bool aIsSubgriddedAxis) {
+ const bool isAlign = mAxis == eLogicalAxisBlock;
+ // Align-/justify-content doesn't apply in a subgridded axis.
+ // Gap properties do apply though so we need to stretch/position the tracks
+ // to center-align the gaps with the parent's gaps.
+ if (MOZ_UNLIKELY(aIsSubgriddedAxis)) {
+ auto& gap = isAlign ? aStyle->mRowGap : aStyle->mColumnGap;
+ if (gap.IsNormal()) {
+ return;
+ }
+ auto len = mSizes.Length();
+ if (len <= 1) {
+ return;
+ }
+ // This stores the gap deltas between the subgrid gap and the gaps in
+ // the used track sizes (as encoded in its tracks' mPosition):
+ nsTArray<nscoord> gapDeltas;
+ const size_t numGaps = len - 1;
+ gapDeltas.SetLength(numGaps);
+ for (size_t i = 0; i < numGaps; ++i) {
+ TrackSize& sz1 = mSizes[i];
+ TrackSize& sz2 = mSizes[i + 1];
+ nscoord currentGap = sz2.mPosition - (sz1.mPosition + sz1.mBase);
+ gapDeltas[i] = mGridGap - currentGap;
+ }
+ // Recompute the tracks' size/position so that they end up with
+ // a subgrid-gap centered on the original track gap.
+ nscoord currentPos = mSizes[0].mPosition;
+ nscoord lastHalfDelta(0);
+ for (size_t i = 0; i < numGaps; ++i) {
+ TrackSize& sz = mSizes[i];
+ nscoord delta = gapDeltas[i];
+ nscoord halfDelta;
+ nscoord roundingError = NSCoordDivRem(delta, 2, &halfDelta);
+ auto newSize = sz.mBase - (halfDelta + roundingError) - lastHalfDelta;
+ lastHalfDelta = halfDelta;
+ // If the gap delta (in particular 'halfDelta + lastHalfDelta') is larger
+ // than the current track size, newSize can be negative. Don't let the new
+ // track size (mBase) be negative.
+ sz.mBase = std::max(newSize, 0);
+ sz.mPosition = currentPos;
+ currentPos += newSize + mGridGap;
+ }
+ auto& lastTrack = mSizes.LastElement();
+ auto newSize = lastTrack.mBase - lastHalfDelta;
+ lastTrack.mBase = std::max(newSize, 0);
+ lastTrack.mPosition = currentPos;
+ return;
+ }
+
+ if (mSizes.IsEmpty()) {
+ return;
+ }
+
+ bool overflowSafe;
+ auto alignment = ::GetAlignJustifyValue(aAligmentStyleValue.primary, aWM,
+ isAlign, &overflowSafe);
+ if (alignment == StyleAlignFlags::NORMAL) {
+ alignment = StyleAlignFlags::STRETCH;
+ // we may need a fallback for 'stretch' below
+ aAligmentStyleValue = {alignment};
+ }
+
+ // Compute the free space and count auto-sized tracks.
+ size_t numAutoTracks = 0;
+ nscoord space;
+ if (alignment != StyleAlignFlags::START) {
+ nscoord trackSizeSum = 0;
+ if (aIsSubgriddedAxis) {
+ numAutoTracks = mSizes.Length();
+ } else {
+ for (const TrackSize& sz : mSizes) {
+ trackSizeSum += sz.mBase;
+ if (sz.mState & TrackSize::eAutoMaxSizing) {
+ ++numAutoTracks;
+ }
+ }
+ }
+ space = aContentBoxSize - trackSizeSum - SumOfGridGaps();
+ // Use the fallback value instead when applicable.
+ if (space < 0 ||
+ (alignment == StyleAlignFlags::SPACE_BETWEEN && mSizes.Length() == 1)) {
+ auto fallback = ::GetAlignJustifyFallbackIfAny(aAligmentStyleValue, aWM,
+ isAlign, &overflowSafe);
+ if (fallback) {
+ alignment = *fallback;
+ }
+ }
+ if (space == 0 || (space < 0 && overflowSafe)) {
+ // XXX check that this makes sense also for [last ]baseline (bug 1151204).
+ alignment = StyleAlignFlags::START;
+ }
+ }
+
+ // Optimize the cases where we just need to set each track's position.
+ nscoord pos = 0;
+ bool distribute = true;
+ if (alignment == StyleAlignFlags::BASELINE ||
+ alignment == StyleAlignFlags::LAST_BASELINE) {
+ NS_WARNING("NYI: 'first/last baseline' (bug 1151204)"); // XXX
+ alignment = StyleAlignFlags::START;
+ }
+ if (alignment == StyleAlignFlags::START) {
+ distribute = false;
+ } else if (alignment == StyleAlignFlags::END) {
+ pos = space;
+ distribute = false;
+ } else if (alignment == StyleAlignFlags::CENTER) {
+ pos = space / 2;
+ distribute = false;
+ } else if (alignment == StyleAlignFlags::STRETCH) {
+ distribute = numAutoTracks != 0;
+ }
+ if (!distribute) {
+ for (TrackSize& sz : mSizes) {
+ sz.mPosition = pos;
+ pos += sz.mBase + mGridGap;
+ }
+ return;
+ }
+
+ // Distribute free space to/between tracks and set their position.
+ MOZ_ASSERT(space > 0, "should've handled that on the fallback path above");
+ nscoord between, roundingError;
+ if (alignment == StyleAlignFlags::STRETCH) {
+ MOZ_ASSERT(numAutoTracks > 0, "we handled numAutoTracks == 0 above");
+ // The outer loop typically only runs once - it repeats only in a masonry
+ // axis when some stretchable items reach their `max-size`.
+ // It's O(n^2) worst case; if all items are stretchable with a `max-size`
+ // and exactly one item reaches its `max-size` each round.
+ while (space) {
+ pos = 0;
+ nscoord spacePerTrack;
+ roundingError = NSCoordDivRem(space, numAutoTracks, &spacePerTrack);
+ space = 0;
+ for (TrackSize& sz : mSizes) {
+ sz.mPosition = pos;
+ if (!(sz.mState & TrackSize::eAutoMaxSizing)) {
+ pos += sz.mBase + mGridGap;
+ continue;
+ }
+ nscoord stretch = spacePerTrack;
+ if (roundingError) {
+ roundingError -= 1;
+ stretch += 1;
+ }
+ nscoord newBase = sz.mBase + stretch;
+ if (mIsMasonry && (sz.mState & TrackSize::eClampToLimit)) {
+ auto clampedSize = std::min(newBase, sz.mLimit);
+ auto sizeOverLimit = newBase - clampedSize;
+ if (sizeOverLimit > 0) {
+ newBase = clampedSize;
+ sz.mState &= ~(sz.mState & TrackSize::eAutoMaxSizing);
+ // This repeats the outer loop to distribute the superfluous space:
+ space += sizeOverLimit;
+ if (--numAutoTracks == 0) {
+ // ... except if we don't have any stretchable items left.
+ space = 0;
+ }
+ }
+ }
+ sz.mBase = newBase;
+ pos += newBase + mGridGap;
+ }
+ }
+ MOZ_ASSERT(!roundingError, "we didn't distribute all rounding error?");
+ return;
+ }
+ if (alignment == StyleAlignFlags::SPACE_BETWEEN) {
+ MOZ_ASSERT(mSizes.Length() > 1, "should've used a fallback above");
+ roundingError = NSCoordDivRem(space, mSizes.Length() - 1, &between);
+ } else if (alignment == StyleAlignFlags::SPACE_AROUND) {
+ roundingError = NSCoordDivRem(space, mSizes.Length(), &between);
+ pos = between / 2;
+ } else if (alignment == StyleAlignFlags::SPACE_EVENLY) {
+ roundingError = NSCoordDivRem(space, mSizes.Length() + 1, &between);
+ pos = between;
+ } else {
+ MOZ_ASSERT_UNREACHABLE("unknown align-/justify-content value");
+ between = 0; // just to avoid a compiler warning
+ roundingError = 0; // just to avoid a compiler warning
+ }
+ between += mGridGap;
+ for (TrackSize& sz : mSizes) {
+ sz.mPosition = pos;
+ nscoord spacing = between;
+ if (roundingError) {
+ roundingError -= 1;
+ spacing += 1;
+ }
+ pos += sz.mBase + spacing;
+ }
+ MOZ_ASSERT(!roundingError, "we didn't distribute all rounding error?");
+}
+
+void nsGridContainerFrame::LineRange::ToPositionAndLength(
+ const nsTArray<TrackSize>& aTrackSizes, nscoord* aPos,
+ nscoord* aLength) const {
+ MOZ_ASSERT(mStart != kAutoLine && mEnd != kAutoLine,
+ "expected a definite LineRange");
+ MOZ_ASSERT(mStart < mEnd);
+ nscoord startPos = aTrackSizes[mStart].mPosition;
+ const TrackSize& sz = aTrackSizes[mEnd - 1];
+ *aPos = startPos;
+ *aLength = (sz.mPosition + sz.mBase) - startPos;
+}
+
+nscoord nsGridContainerFrame::LineRange::ToLength(
+ const nsTArray<TrackSize>& aTrackSizes) const {
+ MOZ_ASSERT(mStart != kAutoLine && mEnd != kAutoLine,
+ "expected a definite LineRange");
+ MOZ_ASSERT(mStart < mEnd);
+ nscoord startPos = aTrackSizes[mStart].mPosition;
+ const TrackSize& sz = aTrackSizes[mEnd - 1];
+ return (sz.mPosition + sz.mBase) - startPos;
+}
+
+void nsGridContainerFrame::LineRange::ToPositionAndLengthForAbsPos(
+ const Tracks& aTracks, nscoord aGridOrigin, nscoord* aPos,
+ nscoord* aLength) const {
+ // kAutoLine for abspos children contributes the corresponding edge
+ // of the grid container's padding-box.
+ if (mEnd == kAutoLine) {
+ if (mStart == kAutoLine) {
+ // done
+ } else {
+ const nscoord endPos = *aPos + *aLength;
+ auto side = mStart == aTracks.mSizes.Length()
+ ? GridLineSide::BeforeGridGap
+ : GridLineSide::AfterGridGap;
+ nscoord startPos = aTracks.GridLineEdge(mStart, side);
+ *aPos = aGridOrigin + startPos;
+ *aLength = std::max(endPos - *aPos, 0);
+ }
+ } else {
+ if (mStart == kAutoLine) {
+ auto side =
+ mEnd == 0 ? GridLineSide::AfterGridGap : GridLineSide::BeforeGridGap;
+ nscoord endPos = aTracks.GridLineEdge(mEnd, side);
+ *aLength = std::max(aGridOrigin + endPos, 0);
+ } else if (MOZ_LIKELY(mStart != mEnd)) {
+ nscoord pos;
+ ToPositionAndLength(aTracks.mSizes, &pos, aLength);
+ *aPos = aGridOrigin + pos;
+ } else {
+ // The grid area only covers removed 'auto-fit' tracks.
+ nscoord pos = aTracks.GridLineEdge(mStart, GridLineSide::BeforeGridGap);
+ *aPos = aGridOrigin + pos;
+ *aLength = nscoord(0);
+ }
+ }
+}
+
+LogicalSize nsGridContainerFrame::GridReflowInput::PercentageBasisFor(
+ LogicalAxis aAxis, const GridItemInfo& aGridItem) const {
+ auto wm = aGridItem.mFrame->GetWritingMode();
+ const auto* itemParent = aGridItem.mFrame->GetParent();
+ if (MOZ_UNLIKELY(itemParent != mFrame)) {
+ // The item comes from a descendant subgrid. Use the subgrid's
+ // used track sizes to resolve the grid area size, if present.
+ MOZ_ASSERT(itemParent->IsGridContainerFrame());
+ auto* subgridFrame = static_cast<const nsGridContainerFrame*>(itemParent);
+ MOZ_ASSERT(subgridFrame->IsSubgrid());
+ if (auto* uts = subgridFrame->GetUsedTrackSizes()) {
+ auto subgridWM = subgridFrame->GetWritingMode();
+ LogicalSize cbSize(subgridWM, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+ if (!subgridFrame->IsSubgrid(eLogicalAxisInline) &&
+ uts->mCanResolveLineRangeSize[eLogicalAxisInline]) {
+ // NOTE: At this point aGridItem.mArea is in this->mFrame coordinates
+ // and thus may have been transposed. The range values in a non-
+ // subgridded axis still has its original values in subgridFrame's
+ // coordinates though.
+ auto rangeAxis = subgridWM.IsOrthogonalTo(mWM) ? eLogicalAxisBlock
+ : eLogicalAxisInline;
+ const auto& range = aGridItem.mArea.LineRangeForAxis(rangeAxis);
+ cbSize.ISize(subgridWM) =
+ range.ToLength(uts->mSizes[eLogicalAxisInline]);
+ }
+ if (!subgridFrame->IsSubgrid(eLogicalAxisBlock) &&
+ uts->mCanResolveLineRangeSize[eLogicalAxisBlock]) {
+ auto rangeAxis = subgridWM.IsOrthogonalTo(mWM) ? eLogicalAxisInline
+ : eLogicalAxisBlock;
+ const auto& range = aGridItem.mArea.LineRangeForAxis(rangeAxis);
+ cbSize.BSize(subgridWM) =
+ range.ToLength(uts->mSizes[eLogicalAxisBlock]);
+ }
+ return cbSize.ConvertTo(wm, subgridWM);
+ }
+
+ return LogicalSize(wm, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+ }
+
+ if (aAxis == eLogicalAxisInline || !mCols.mCanResolveLineRangeSize) {
+ return LogicalSize(wm, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+ }
+ // Note: for now, we only resolve transferred percentages to row sizing.
+ // We may need to adjust these assertions once we implement bug 1300366.
+ MOZ_ASSERT(!mRows.mCanResolveLineRangeSize);
+ nscoord colSize = aGridItem.mArea.mCols.ToLength(mCols.mSizes);
+ nscoord rowSize = NS_UNCONSTRAINEDSIZE;
+ return !wm.IsOrthogonalTo(mWM) ? LogicalSize(wm, colSize, rowSize)
+ : LogicalSize(wm, rowSize, colSize);
+}
+
+LogicalRect nsGridContainerFrame::GridReflowInput::ContainingBlockFor(
+ const GridArea& aArea) const {
+ nscoord i, b, iSize, bSize;
+ MOZ_ASSERT(aArea.mCols.Extent() > 0, "grid items cover at least one track");
+ MOZ_ASSERT(aArea.mRows.Extent() > 0, "grid items cover at least one track");
+ aArea.mCols.ToPositionAndLength(mCols.mSizes, &i, &iSize);
+ aArea.mRows.ToPositionAndLength(mRows.mSizes, &b, &bSize);
+ return LogicalRect(mWM, i, b, iSize, bSize);
+}
+
+LogicalRect nsGridContainerFrame::GridReflowInput::ContainingBlockForAbsPos(
+ const GridArea& aArea, const LogicalPoint& aGridOrigin,
+ const LogicalRect& aGridCB) const {
+ nscoord i = aGridCB.IStart(mWM);
+ nscoord b = aGridCB.BStart(mWM);
+ nscoord iSize = aGridCB.ISize(mWM);
+ nscoord bSize = aGridCB.BSize(mWM);
+ aArea.mCols.ToPositionAndLengthForAbsPos(mCols, aGridOrigin.I(mWM), &i,
+ &iSize);
+ aArea.mRows.ToPositionAndLengthForAbsPos(mRows, aGridOrigin.B(mWM), &b,
+ &bSize);
+ return LogicalRect(mWM, i, b, iSize, bSize);
+}
+
+void nsGridContainerFrame::GridReflowInput::AlignJustifyContentInMasonryAxis(
+ nscoord aMasonryBoxSize, nscoord aContentBoxSize) {
+ if (aContentBoxSize == NS_UNCONSTRAINEDSIZE) {
+ aContentBoxSize = aMasonryBoxSize;
+ }
+ auto& masonryAxisTracks = mRows.mIsMasonry ? mRows : mCols;
+ MOZ_ASSERT(masonryAxisTracks.mSizes.Length() == 2,
+ "unexpected masonry axis tracks");
+ const auto masonryAxis = masonryAxisTracks.mAxis;
+ const auto contentAlignment = mGridStyle->UsedContentAlignment(masonryAxis);
+ if (contentAlignment.primary == StyleAlignFlags::NORMAL ||
+ contentAlignment.primary == StyleAlignFlags::STRETCH) {
+ // Stretch the "masonry box" to the full content box if it's smaller.
+ nscoord cbSize = std::max(aMasonryBoxSize, aContentBoxSize);
+ for (auto& sz : masonryAxisTracks.mSizes) {
+ sz.mBase = cbSize;
+ }
+ return;
+ }
+
+ // Save our current track sizes; replace them with one track sized to
+ // the masonry box and align that within our content box.
+ auto savedTrackSizes(std::move(masonryAxisTracks.mSizes));
+ masonryAxisTracks.mSizes.AppendElement(savedTrackSizes[0]);
+ masonryAxisTracks.mSizes[0].mBase = aMasonryBoxSize;
+ masonryAxisTracks.AlignJustifyContent(mGridStyle, contentAlignment, mWM,
+ aContentBoxSize, false);
+ nscoord masonryBoxOffset = masonryAxisTracks.mSizes[0].mPosition;
+ // Restore the original track sizes...
+ masonryAxisTracks.mSizes = std::move(savedTrackSizes);
+ // ...then reposition and resize all of them to the aligned result.
+ for (auto& sz : masonryAxisTracks.mSizes) {
+ sz.mPosition = masonryBoxOffset;
+ sz.mBase = aMasonryBoxSize;
+ }
+}
+
+// Note: this is called after all items have been positioned/reflowed.
+// The masonry-axis tracks have the size of the "masonry box" at this point
+// and are positioned according to 'align/justify-content'.
+void nsGridContainerFrame::GridReflowInput::AlignJustifyTracksInMasonryAxis(
+ const LogicalSize& aContentSize, const nsSize& aContainerSize) {
+ auto& masonryAxisTracks = mRows.mIsMasonry ? mRows : mCols;
+ MOZ_ASSERT(masonryAxisTracks.mSizes.Length() == 2,
+ "unexpected masonry axis tracks");
+ const auto masonryAxis = masonryAxisTracks.mAxis;
+ auto gridAxis = GetOrthogonalAxis(masonryAxis);
+ auto& gridAxisTracks = TracksFor(gridAxis);
+ AutoTArray<TrackSize, 32> savedSizes;
+ savedSizes.AppendElements(masonryAxisTracks.mSizes);
+ auto wm = mWM;
+ nscoord contentAreaStart = mBorderPadding.Start(masonryAxis, wm);
+ // The offset to the "masonry box" from our content-box start edge.
+ nscoord masonryBoxOffset = masonryAxisTracks.mSizes[0].mPosition;
+ nscoord alignmentContainerSize = masonryAxisTracks.mSizes[0].mBase;
+
+ for (auto i : IntegerRange(gridAxisTracks.mSizes.Length())) {
+ auto tracksAlignment = mGridStyle->UsedTracksAlignment(masonryAxis, i);
+ if (tracksAlignment.primary != StyleAlignFlags::START) {
+ masonryAxisTracks.mSizes.ClearAndRetainStorage();
+ for (const auto& item : mGridItems) {
+ if (item.mArea.LineRangeForAxis(gridAxis).mStart == i) {
+ const auto* child = item.mFrame;
+ LogicalRect rect = child->GetLogicalRect(wm, aContainerSize);
+ TrackSize sz = {0, 0, 0, {0, 0}, TrackSize::StateBits{0}};
+ const auto& margin = child->GetLogicalUsedMargin(wm);
+ sz.mPosition = rect.Start(masonryAxis, wm) -
+ margin.Start(masonryAxis, wm) - contentAreaStart;
+ sz.mBase =
+ rect.Size(masonryAxis, wm) + margin.StartEnd(masonryAxis, wm);
+ // Account for a align-self baseline offset on the end side.
+ // XXXmats hmm, it seems it would be a lot simpler to just store
+ // these baseline adjustments into the UsedMarginProperty instead
+ auto state = item.mState[masonryAxis];
+ if ((state & ItemState::eSelfBaseline) &&
+ (state & ItemState::eEndSideBaseline)) {
+ sz.mBase += item.mBaselineOffset[masonryAxis];
+ }
+ if (tracksAlignment.primary == StyleAlignFlags::STRETCH) {
+ const auto* pos = child->StylePosition();
+ auto itemAlignment =
+ pos->UsedSelfAlignment(masonryAxis, mFrame->Style());
+ if (child->StyleMargin()->HasAuto(masonryAxis, wm)) {
+ sz.mState |= TrackSize::eAutoMaxSizing;
+ sz.mState |= TrackSize::eItemHasAutoMargin;
+ } else if (pos->Size(masonryAxis, wm).IsAuto() &&
+ (itemAlignment == StyleAlignFlags::NORMAL ||
+ itemAlignment == StyleAlignFlags::STRETCH)) {
+ sz.mState |= TrackSize::eAutoMaxSizing;
+ sz.mState |= TrackSize::eItemStretchSize;
+ const auto& max = pos->MaxSize(masonryAxis, wm);
+ if (max.ConvertsToLength()) { // XXX deal with percentages
+ // XXX add in baselineOffset ? use actual frame size - content
+ // size?
+ nscoord boxSizingAdjust =
+ child->GetLogicalUsedBorderAndPadding(wm).StartEnd(
+ masonryAxis, wm);
+ if (pos->mBoxSizing == StyleBoxSizing::Border) {
+ boxSizingAdjust = 0;
+ }
+ sz.mLimit = nsLayoutUtils::ComputeBSizeValue(
+ aContentSize.Size(masonryAxis, wm), boxSizingAdjust,
+ max.AsLengthPercentage());
+ sz.mLimit += margin.StartEnd(masonryAxis, wm);
+ sz.mState |= TrackSize::eClampToLimit;
+ }
+ }
+ }
+ masonryAxisTracks.mSizes.AppendElement(std::move(sz));
+ }
+ }
+ masonryAxisTracks.AlignJustifyContent(mGridStyle, tracksAlignment, wm,
+ alignmentContainerSize, false);
+ auto iter = mGridItems.begin();
+ auto end = mGridItems.end();
+ // We limit the loop to the number of items we found in the current
+ // grid-axis axis track (in the outer loop) as an optimization.
+ for (auto r : IntegerRange(masonryAxisTracks.mSizes.Length())) {
+ GridItemInfo* item = nullptr;
+ auto& sz = masonryAxisTracks.mSizes[r];
+ // Find the next item in the current grid-axis axis track.
+ for (; iter != end; ++iter) {
+ if (iter->mArea.LineRangeForAxis(gridAxis).mStart == i) {
+ item = &*iter;
+ ++iter;
+ break;
+ }
+ }
+ nsIFrame* child = item->mFrame;
+ const auto childWM = child->GetWritingMode();
+ auto masonryChildAxis =
+ childWM.IsOrthogonalTo(wm) ? gridAxis : masonryAxis;
+ LogicalMargin margin = child->GetLogicalUsedMargin(childWM);
+ bool forceReposition = false;
+ if (sz.mState & TrackSize::eItemStretchSize) {
+ auto size = child->GetLogicalSize().Size(masonryChildAxis, childWM);
+ auto newSize = sz.mBase - margin.StartEnd(masonryChildAxis, childWM);
+ if (size != newSize) {
+ // XXX need to pass aIMinSizeClamp aBMinSizeClamp ?
+ LogicalSize cb =
+ ContainingBlockFor(item->mArea).Size(wm).ConvertTo(childWM, wm);
+ LogicalSize availableSize = cb;
+ cb.Size(masonryChildAxis, childWM) = alignmentContainerSize;
+ availableSize.Size(eLogicalAxisBlock, childWM) =
+ NS_UNCONSTRAINEDSIZE;
+ const auto& bp = child->GetLogicalUsedBorderAndPadding(childWM);
+ newSize -= bp.StartEnd(masonryChildAxis, childWM);
+ ::PostReflowStretchChild(child, *mReflowInput, availableSize, cb,
+ masonryChildAxis, newSize);
+ if (childWM.IsPhysicalRTL()) {
+ // The NormalPosition of this child is frame-size dependent so we
+ // need to reset its stored position below.
+ forceReposition = true;
+ }
+ }
+ } else if (sz.mState & TrackSize::eItemHasAutoMargin) {
+ // Re-compute the auto-margin(s) in the masonry axis.
+ auto size = child->GetLogicalSize().Size(masonryChildAxis, childWM);
+ auto spaceToFill = sz.mBase - size;
+ if (spaceToFill > nscoord(0)) {
+ const auto& marginStyle = child->StyleMargin();
+ if (marginStyle->mMargin.Start(masonryChildAxis, childWM)
+ .IsAuto()) {
+ if (marginStyle->mMargin.End(masonryChildAxis, childWM)
+ .IsAuto()) {
+ nscoord half;
+ nscoord roundingError = NSCoordDivRem(spaceToFill, 2, &half);
+ margin.Start(masonryChildAxis, childWM) = half;
+ margin.End(masonryChildAxis, childWM) = half + roundingError;
+ } else {
+ margin.Start(masonryChildAxis, childWM) = spaceToFill;
+ }
+ } else {
+ MOZ_ASSERT(
+ marginStyle->mMargin.End(masonryChildAxis, childWM).IsAuto());
+ margin.End(masonryChildAxis, childWM) = spaceToFill;
+ }
+ nsMargin* propValue =
+ child->GetProperty(nsIFrame::UsedMarginProperty());
+ if (propValue) {
+ *propValue = margin.GetPhysicalMargin(childWM);
+ } else {
+ child->AddProperty(
+ nsIFrame::UsedMarginProperty(),
+ new nsMargin(margin.GetPhysicalMargin(childWM)));
+ }
+ }
+ }
+ nscoord newPos = contentAreaStart + masonryBoxOffset + sz.mPosition +
+ margin.Start(masonryChildAxis, childWM);
+ LogicalPoint pos = child->GetLogicalNormalPosition(wm, aContainerSize);
+ auto delta = newPos - pos.Pos(masonryAxis, wm);
+ if (delta != 0 || forceReposition) {
+ LogicalPoint logicalDelta(wm);
+ logicalDelta.Pos(masonryAxis, wm) = delta;
+ child->MovePositionBy(wm, logicalDelta);
+ }
+ }
+ } else if (masonryBoxOffset != nscoord(0)) {
+ // TODO move placeholders too
+ auto delta = masonryBoxOffset;
+ LogicalPoint logicalDelta(wm);
+ logicalDelta.Pos(masonryAxis, wm) = delta;
+ for (const auto& item : mGridItems) {
+ if (item.mArea.LineRangeForAxis(gridAxis).mStart != i) {
+ continue;
+ }
+ item.mFrame->MovePositionBy(wm, logicalDelta);
+ }
+ }
+ }
+ masonryAxisTracks.mSizes = std::move(savedSizes);
+}
+
+/**
+ * Return a Fragmentainer object if we have a fragmentainer frame in our
+ * ancestor chain of containing block (CB) reflow inputs. We'll only
+ * continue traversing the ancestor chain as long as the CBs have
+ * the same writing-mode and have overflow:visible.
+ */
+Maybe<nsGridContainerFrame::Fragmentainer>
+nsGridContainerFrame::GetNearestFragmentainer(
+ const GridReflowInput& aState) const {
+ Maybe<nsGridContainerFrame::Fragmentainer> data;
+ const ReflowInput* gridRI = aState.mReflowInput;
+ if (!gridRI->IsInFragmentedContext()) {
+ return data;
+ }
+ WritingMode wm = aState.mWM;
+ const ReflowInput* cbRI = gridRI->mCBReflowInput;
+ for (; cbRI; cbRI = cbRI->mCBReflowInput) {
+ nsIScrollableFrame* sf = do_QueryFrame(cbRI->mFrame);
+ if (sf) {
+ break;
+ }
+ if (wm.IsOrthogonalTo(cbRI->GetWritingMode())) {
+ break;
+ }
+ LayoutFrameType frameType = cbRI->mFrame->Type();
+ if ((frameType == LayoutFrameType::Canvas &&
+ PresContext()->IsPaginated()) ||
+ frameType == LayoutFrameType::ColumnSet) {
+ data.emplace();
+ data->mIsTopOfPage = gridRI->mFlags.mIsTopOfPage;
+ if (gridRI->AvailableBSize() != NS_UNCONSTRAINEDSIZE) {
+ data->mToFragmentainerEnd = aState.mFragBStart +
+ gridRI->AvailableBSize() -
+ aState.mBorderPadding.BStart(wm);
+ } else {
+ // This occurs when nsColumnSetFrame reflows its last column in
+ // unconstrained available block-size.
+ data->mToFragmentainerEnd = NS_UNCONSTRAINEDSIZE;
+ }
+ const auto numRows = aState.mRows.mSizes.Length();
+ data->mCanBreakAtStart =
+ numRows > 0 && aState.mRows.mSizes[0].mPosition > 0;
+ nscoord bSize = gridRI->ComputedBSize();
+ data->mIsAutoBSize = bSize == NS_UNCONSTRAINEDSIZE;
+ if (data->mIsAutoBSize) {
+ bSize = gridRI->ComputedMinBSize();
+ } else {
+ bSize = gridRI->ApplyMinMaxBSize(bSize);
+ }
+ nscoord gridEnd =
+ aState.mRows.GridLineEdge(numRows, GridLineSide::BeforeGridGap);
+ data->mCanBreakAtEnd = bSize > gridEnd && bSize > aState.mFragBStart;
+ break;
+ }
+ }
+ return data;
+}
+
+void nsGridContainerFrame::ReflowInFlowChild(
+ nsIFrame* aChild, const GridItemInfo* aGridItemInfo, nsSize aContainerSize,
+ const Maybe<nscoord>& aStretchBSize, const Fragmentainer* aFragmentainer,
+ const GridReflowInput& aState, const LogicalRect& aContentArea,
+ ReflowOutput& aDesiredSize, nsReflowStatus& aStatus) {
+ nsPresContext* pc = PresContext();
+ ComputedStyle* containerSC = Style();
+ WritingMode wm = aState.mReflowInput->GetWritingMode();
+ const bool isGridItem = !!aGridItemInfo;
+ MOZ_ASSERT(isGridItem == !aChild->IsPlaceholderFrame());
+ LogicalRect cb(wm);
+ WritingMode childWM = aChild->GetWritingMode();
+ bool isConstrainedBSize = false;
+ nscoord toFragmentainerEnd;
+ // The part of the child's grid area that's in previous container fragments.
+ nscoord consumedGridAreaBSize = 0;
+ const bool isOrthogonal = wm.IsOrthogonalTo(childWM);
+ if (MOZ_LIKELY(isGridItem)) {
+ MOZ_ASSERT(aGridItemInfo->mFrame == aChild);
+ const GridArea& area = aGridItemInfo->mArea;
+ MOZ_ASSERT(area.IsDefinite());
+ cb = aState.ContainingBlockFor(area);
+ if (aFragmentainer && !wm.IsOrthogonalTo(childWM)) {
+ // |gridAreaBOffset| is the offset of the child's grid area in this
+ // container fragment (if negative, that distance is the child CB size
+ // consumed in previous container fragments). Note that cb.BStart
+ // (initially) and aState.mFragBStart are in "global" grid coordinates
+ // (like all track positions).
+ nscoord gridAreaBOffset = cb.BStart(wm) - aState.mFragBStart;
+ consumedGridAreaBSize = std::max(0, -gridAreaBOffset);
+ cb.BStart(wm) = std::max(0, gridAreaBOffset);
+ if (aFragmentainer->mToFragmentainerEnd != NS_UNCONSTRAINEDSIZE) {
+ toFragmentainerEnd = aFragmentainer->mToFragmentainerEnd -
+ aState.mFragBStart - cb.BStart(wm);
+ toFragmentainerEnd = std::max(toFragmentainerEnd, 0);
+ isConstrainedBSize = true;
+ }
+ }
+ cb += aContentArea.Origin(wm);
+ aState.mRows.AlignBaselineSubtree(*aGridItemInfo);
+ aState.mCols.AlignBaselineSubtree(*aGridItemInfo);
+ // Setup [align|justify]-content:[last ]baseline related frame properties.
+ // These are added to the padding in SizeComputationInput::InitOffsets.
+ // (a negative value signals the value is for 'last baseline' and should be
+ // added to the (logical) end padding)
+ typedef const FramePropertyDescriptor<SmallValueHolder<nscoord>>* Prop;
+ auto SetProp = [aGridItemInfo, aChild](LogicalAxis aGridAxis, Prop aProp) {
+ auto state = aGridItemInfo->mState[aGridAxis];
+ auto baselineAdjust = (state & ItemState::eContentBaseline)
+ ? aGridItemInfo->mBaselineOffset[aGridAxis]
+ : nscoord(0);
+ if (baselineAdjust < nscoord(0)) {
+ // This happens when the subtree overflows its track.
+ // XXX spec issue? it's unclear how to handle this.
+ baselineAdjust = nscoord(0);
+ } else if (GridItemInfo::BaselineAlignmentAffectsEndSide(state)) {
+ baselineAdjust = -baselineAdjust;
+ }
+ if (baselineAdjust != nscoord(0)) {
+ aChild->SetProperty(aProp, baselineAdjust);
+ } else {
+ aChild->RemoveProperty(aProp);
+ }
+ };
+ SetProp(eLogicalAxisBlock,
+ isOrthogonal ? IBaselinePadProperty() : BBaselinePadProperty());
+ SetProp(eLogicalAxisInline,
+ isOrthogonal ? BBaselinePadProperty() : IBaselinePadProperty());
+ } else {
+ // By convention, for frames that perform CSS Box Alignment, we position
+ // placeholder children at the start corner of their alignment container,
+ // and in this case that's usually the grid's content-box.
+ // ("Usually" - the exception is when the grid *also* forms the
+ // abs.pos. containing block. In that case, the alignment container isn't
+ // the content-box -- it's some grid area instead. But that case doesn't
+ // require any special handling here, because we handle it later using a
+ // special flag (ReflowInput::InitFlag::StaticPosIsCBOrigin) which will make
+ // us ignore the placeholder's position entirely.)
+ cb = aContentArea;
+ aChild->AddStateBits(PLACEHOLDER_STATICPOS_NEEDS_CSSALIGN);
+ }
+
+ LogicalSize reflowSize(cb.Size(wm));
+ if (isConstrainedBSize) {
+ reflowSize.BSize(wm) = toFragmentainerEnd;
+ }
+ LogicalSize childCBSize = reflowSize.ConvertTo(childWM, wm);
+
+ // Setup the ClampMarginBoxMinSize reflow flags and property, if needed.
+ ComputeSizeFlags csFlags;
+ if (aGridItemInfo) {
+ const auto childIAxisInWM =
+ isOrthogonal ? eLogicalAxisBlock : eLogicalAxisInline;
+ // Clamp during reflow if we're stretching in that axis.
+ if (GridItemShouldStretch(aChild, eLogicalAxisInline)) {
+ if (aGridItemInfo->mState[childIAxisInWM] &
+ ItemState::eClampMarginBoxMinSize) {
+ csFlags += ComputeSizeFlag::IClampMarginBoxMinSize;
+ }
+ } else {
+ csFlags += ComputeSizeFlag::ShrinkWrap;
+ }
+
+ const auto childBAxisInWM = GetOrthogonalAxis(childIAxisInWM);
+ if (GridItemShouldStretch(aChild, eLogicalAxisBlock) &&
+ aGridItemInfo->mState[childBAxisInWM] &
+ ItemState::eClampMarginBoxMinSize) {
+ csFlags += ComputeSizeFlag::BClampMarginBoxMinSize;
+ aChild->SetProperty(BClampMarginBoxMinSizeProperty(),
+ childCBSize.BSize(childWM));
+ } else {
+ aChild->RemoveProperty(BClampMarginBoxMinSizeProperty());
+ }
+
+ if ((aGridItemInfo->mState[childIAxisInWM] &
+ ItemState::eApplyAutoMinSize)) {
+ csFlags += ComputeSizeFlag::IApplyAutoMinSize;
+ }
+ }
+
+ if (!isConstrainedBSize) {
+ childCBSize.BSize(childWM) = NS_UNCONSTRAINEDSIZE;
+ }
+ LogicalSize percentBasis(cb.Size(wm).ConvertTo(childWM, wm));
+ ReflowInput childRI(pc, *aState.mReflowInput, aChild, childCBSize,
+ Some(percentBasis), {}, {}, csFlags);
+ childRI.mFlags.mIsTopOfPage =
+ aFragmentainer ? aFragmentainer->mIsTopOfPage : false;
+
+ // FIXME (perf): It would be faster to do this only if the previous reflow of
+ // the child was a measuring reflow, and only if the child does some of the
+ // things that are affected by ComputeSizeFlag::IsGridMeasuringReflow.
+ childRI.SetBResize(true);
+ childRI.mFlags.mIsBResizeForPercentages = true;
+
+ // If the child is stretching in its block axis, and we might be fragmenting
+ // it in that axis, then setup a frame property to tell
+ // nsBlockFrame::ComputeFinalSize the size.
+ if (isConstrainedBSize && !wm.IsOrthogonalTo(childWM)) {
+ const bool stretch = childRI.mStylePosition->BSize(childWM).IsAuto() &&
+ GridItemShouldStretch(aChild, eLogicalAxisBlock);
+ if (stretch) {
+ aChild->SetProperty(FragStretchBSizeProperty(), *aStretchBSize);
+ } else {
+ aChild->RemoveProperty(FragStretchBSizeProperty());
+ }
+ }
+
+ // We need the width of the child before we can correctly convert
+ // the writing-mode of its origin, so we reflow at (0, 0) using a dummy
+ // aContainerSize, and then pass the correct position to FinishReflowChild.
+ ReflowOutput childSize(childRI);
+ const nsSize dummyContainerSize;
+
+ ReflowChild(aChild, pc, childSize, childRI, childWM, LogicalPoint(childWM),
+ dummyContainerSize, ReflowChildFlags::Default, aStatus);
+ LogicalPoint childPos = cb.Origin(wm).ConvertTo(
+ childWM, wm, aContainerSize - childSize.PhysicalSize());
+ // Apply align/justify-self and reflow again if that affects the size.
+ if (MOZ_LIKELY(isGridItem)) {
+ LogicalSize size = childSize.Size(childWM); // from the ReflowChild()
+ auto applyItemSelfAlignment = [&](LogicalAxis aAxis, nscoord aCBSize) {
+ auto align =
+ childRI.mStylePosition->UsedSelfAlignment(aAxis, containerSC);
+ auto state = aGridItemInfo->mState[aAxis];
+ auto flags = AlignJustifyFlags::NoFlags;
+ if (IsMasonry(aAxis)) {
+ // In a masonry axis, we inhibit applying 'stretch' and auto-margins
+ // here since AlignJustifyTracksInMasonryAxis deals with that.
+ // The only other {align,justify}-{self,content} values that have an
+ // effect are '[last] baseline', the rest behave as 'start'.
+ if (MOZ_LIKELY(!(state & ItemState::eSelfBaseline))) {
+ align = {StyleAlignFlags::START};
+ } else {
+ auto group = (state & ItemState::eFirstBaseline)
+ ? BaselineSharingGroup::First
+ : BaselineSharingGroup::Last;
+ auto itemStart = aGridItemInfo->mArea.LineRangeForAxis(aAxis).mStart;
+ aCBSize = aState.TracksFor(aAxis)
+ .mSizes[itemStart]
+ .mBaselineSubtreeSize[group];
+ }
+ flags = AlignJustifyFlags::IgnoreAutoMargins;
+ } else if (state & ItemState::eContentBaseline) {
+ align = {(state & ItemState::eFirstBaseline)
+ ? StyleAlignFlags::SELF_START
+ : StyleAlignFlags::SELF_END};
+ }
+ if (aAxis == eLogicalAxisBlock) {
+ AlignSelf(*aGridItemInfo, align, aCBSize, wm, childRI, size, flags,
+ &childPos);
+ } else {
+ JustifySelf(*aGridItemInfo, align, aCBSize, wm, childRI, size, flags,
+ &childPos);
+ }
+ };
+ if (aStatus.IsComplete()) {
+ applyItemSelfAlignment(eLogicalAxisBlock,
+ cb.BSize(wm) - consumedGridAreaBSize);
+ }
+ applyItemSelfAlignment(eLogicalAxisInline, cb.ISize(wm));
+ } // else, nsAbsoluteContainingBlock.cpp will handle align/justify-self.
+
+ FinishReflowChild(aChild, pc, childSize, &childRI, childWM, childPos,
+ aContainerSize, ReflowChildFlags::ApplyRelativePositioning);
+ ConsiderChildOverflow(aDesiredSize.mOverflowAreas, aChild);
+}
+
+nscoord nsGridContainerFrame::ReflowInFragmentainer(
+ GridReflowInput& aState, const LogicalRect& aContentArea,
+ ReflowOutput& aDesiredSize, nsReflowStatus& aStatus,
+ Fragmentainer& aFragmentainer, const nsSize& aContainerSize) {
+ MOZ_ASSERT(aStatus.IsEmpty());
+ MOZ_ASSERT(aState.mReflowInput);
+
+ // Collect our grid items and sort them in row order. Collect placeholders
+ // and put them in a separate array.
+ nsTArray<const GridItemInfo*> sortedItems(aState.mGridItems.Length());
+ nsTArray<nsIFrame*> placeholders(aState.mAbsPosItems.Length());
+ aState.mIter.Reset(CSSOrderAwareFrameIterator::ChildFilter::IncludeAll);
+ for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
+ nsIFrame* child = *aState.mIter;
+ if (!child->IsPlaceholderFrame()) {
+ const GridItemInfo* info = &aState.mGridItems[aState.mIter.ItemIndex()];
+ sortedItems.AppendElement(info);
+ } else {
+ placeholders.AppendElement(child);
+ }
+ }
+ // NOTE: We don't need stable_sort here, except in Masonry layout. There are
+ // no dependencies on having content order between items on the same row in
+ // the code below in the non-Masonry case.
+ if (IsMasonry()) {
+ std::stable_sort(sortedItems.begin(), sortedItems.end(),
+ GridItemInfo::IsStartRowLessThan);
+ } else {
+ std::sort(sortedItems.begin(), sortedItems.end(),
+ GridItemInfo::IsStartRowLessThan);
+ }
+
+ // Reflow our placeholder children; they must all be complete.
+ for (auto child : placeholders) {
+ nsReflowStatus childStatus;
+ ReflowInFlowChild(child, nullptr, aContainerSize, Nothing(),
+ &aFragmentainer, aState, aContentArea, aDesiredSize,
+ childStatus);
+ MOZ_ASSERT(childStatus.IsComplete(),
+ "nsPlaceholderFrame should never need to be fragmented");
+ }
+
+ // The available size for children - we'll set this to the edge of the last
+ // row in most cases below, but for now use the full size.
+ nscoord childAvailableSize = aFragmentainer.mToFragmentainerEnd;
+ const uint32_t startRow = aState.mStartRow;
+ const uint32_t numRows = aState.mRows.mSizes.Length();
+ bool isBDBClone = aState.mReflowInput->mStyleBorder->mBoxDecorationBreak ==
+ StyleBoxDecorationBreak::Clone;
+ nscoord bpBEnd = aState.mBorderPadding.BEnd(aState.mWM);
+
+ // Set |endRow| to the first row that doesn't fit.
+ uint32_t endRow = numRows;
+ for (uint32_t row = startRow; row < numRows; ++row) {
+ auto& sz = aState.mRows.mSizes[row];
+ const nscoord bEnd = sz.mPosition + sz.mBase;
+ nscoord remainingAvailableSize = childAvailableSize - bEnd;
+ if (remainingAvailableSize < 0 ||
+ (isBDBClone && remainingAvailableSize < bpBEnd)) {
+ endRow = row;
+ break;
+ }
+ }
+
+ // Check for forced breaks on the items if available block-size for children
+ // is constrained. That is, ignore forced breaks if available block-size for
+ // children is unconstrained since our parent expected us to be fully
+ // complete.
+ bool isForcedBreak = false;
+ const bool avoidBreakInside = ShouldAvoidBreakInside(*aState.mReflowInput);
+ if (childAvailableSize != NS_UNCONSTRAINEDSIZE) {
+ const bool isTopOfPage = aFragmentainer.mIsTopOfPage;
+ for (const GridItemInfo* info : sortedItems) {
+ uint32_t itemStartRow = info->mArea.mRows.mStart;
+ if (itemStartRow == endRow) {
+ break;
+ }
+ const auto* disp = info->mFrame->StyleDisplay();
+ if (disp->BreakBefore()) {
+ // Propagate break-before on the first row to the container unless we're
+ // already at top-of-page.
+ if ((itemStartRow == 0 && !isTopOfPage) || avoidBreakInside) {
+ aStatus.SetInlineLineBreakBeforeAndReset();
+ return aState.mFragBStart;
+ }
+ if ((itemStartRow > startRow ||
+ (itemStartRow == startRow && !isTopOfPage)) &&
+ itemStartRow < endRow) {
+ endRow = itemStartRow;
+ isForcedBreak = true;
+ // reset any BREAK_AFTER we found on an earlier item
+ aStatus.Reset();
+ break; // we're done since the items are sorted in row order
+ }
+ }
+ uint32_t itemEndRow = info->mArea.mRows.mEnd;
+ if (disp->BreakAfter()) {
+ if (itemEndRow != numRows) {
+ if (itemEndRow > startRow && itemEndRow < endRow) {
+ endRow = itemEndRow;
+ isForcedBreak = true;
+ // No "break;" here since later items with break-after may have
+ // a shorter span.
+ }
+ } else {
+ // Propagate break-after on the last row to the container, we may
+ // still find a break-before on this row though (and reset aStatus).
+ aStatus.SetInlineLineBreakAfter(); // tentative
+ }
+ }
+ }
+
+ // Consume at least one row in each fragment until we have consumed them
+ // all. Except for the first row if there's a break opportunity before it.
+ if (startRow == endRow && startRow != numRows &&
+ (startRow != 0 || !aFragmentainer.mCanBreakAtStart)) {
+ ++endRow;
+ }
+
+ // Honor break-inside:avoid if we can't fit all rows.
+ if (avoidBreakInside && endRow < numRows) {
+ aStatus.SetInlineLineBreakBeforeAndReset();
+ return aState.mFragBStart;
+ }
+ }
+
+ // Calculate the block-size including this fragment.
+ nscoord bEndRow =
+ aState.mRows.GridLineEdge(endRow, GridLineSide::BeforeGridGap);
+ nscoord bSize;
+ if (aFragmentainer.mIsAutoBSize) {
+ // We only apply min-bsize once all rows are complete (when bsize is auto).
+ if (endRow < numRows) {
+ bSize = bEndRow;
+ auto clampedBSize = ClampToCSSMaxBSize(bSize, aState.mReflowInput);
+ if (MOZ_UNLIKELY(clampedBSize != bSize)) {
+ // We apply max-bsize in all fragments though.
+ bSize = clampedBSize;
+ } else if (!isBDBClone) {
+ // The max-bsize won't make this fragment COMPLETE, so the block-end
+ // border will be in a later fragment.
+ bpBEnd = 0;
+ }
+ } else {
+ bSize = aState.mReflowInput->ApplyMinMaxBSize(bEndRow);
+ }
+ } else {
+ bSize = aState.mReflowInput->ApplyMinMaxBSize(
+ aState.mReflowInput->ComputedBSize());
+ }
+
+ // Check for overflow and set aStatus INCOMPLETE if so.
+ bool overflow = bSize + bpBEnd > childAvailableSize;
+ if (overflow) {
+ if (avoidBreakInside) {
+ aStatus.SetInlineLineBreakBeforeAndReset();
+ return aState.mFragBStart;
+ }
+ bool breakAfterLastRow = endRow == numRows && aFragmentainer.mCanBreakAtEnd;
+ if (breakAfterLastRow) {
+ MOZ_ASSERT(bEndRow < bSize, "bogus aFragmentainer.mCanBreakAtEnd");
+ nscoord availableSize = childAvailableSize;
+ if (isBDBClone) {
+ availableSize -= bpBEnd;
+ }
+ // Pretend we have at least 1px available size, otherwise we'll never make
+ // progress in consuming our bSize.
+ availableSize =
+ std::max(availableSize, aState.mFragBStart + AppUnitsPerCSSPixel());
+ // Fill the fragmentainer, but not more than our desired block-size and
+ // at least to the size of the last row (even if that overflows).
+ nscoord newBSize = std::min(bSize, availableSize);
+ newBSize = std::max(newBSize, bEndRow);
+ // If it's just the border+padding that is overflowing and we have
+ // box-decoration-break:clone then we are technically COMPLETE. There's
+ // no point in creating another zero-bsize fragment in this case.
+ if (newBSize < bSize || !isBDBClone) {
+ aStatus.SetIncomplete();
+ }
+ bSize = newBSize;
+ } else if (bSize <= bEndRow && startRow + 1 < endRow) {
+ if (endRow == numRows) {
+ // We have more than one row in this fragment, so we can break before
+ // the last row instead.
+ --endRow;
+ bEndRow =
+ aState.mRows.GridLineEdge(endRow, GridLineSide::BeforeGridGap);
+ bSize = bEndRow;
+ if (aFragmentainer.mIsAutoBSize) {
+ bSize = ClampToCSSMaxBSize(bSize, aState.mReflowInput);
+ }
+ }
+ aStatus.SetIncomplete();
+ } else if (endRow < numRows) {
+ bSize = ClampToCSSMaxBSize(bEndRow, aState.mReflowInput, &aStatus);
+ } // else - no break opportunities.
+ } else {
+ // Even though our block-size fits we need to honor forced breaks, or if
+ // a row doesn't fit in an auto-sized container (unless it's constrained
+ // by a max-bsize which make us overflow-incomplete).
+ if (endRow < numRows &&
+ (isForcedBreak || (aFragmentainer.mIsAutoBSize && bEndRow == bSize))) {
+ bSize = ClampToCSSMaxBSize(bEndRow, aState.mReflowInput, &aStatus);
+ }
+ }
+
+ // If we can't fit all rows then we're at least overflow-incomplete.
+ if (endRow < numRows) {
+ childAvailableSize = bEndRow;
+ if (aStatus.IsComplete()) {
+ aStatus.SetOverflowIncomplete();
+ aStatus.SetNextInFlowNeedsReflow();
+ }
+ } else {
+ // Children always have the full size of the rows in this fragment.
+ childAvailableSize = std::max(childAvailableSize, bEndRow);
+ }
+
+ return ReflowRowsInFragmentainer(aState, aContentArea, aDesiredSize, aStatus,
+ aFragmentainer, aContainerSize, sortedItems,
+ startRow, endRow, bSize, childAvailableSize);
+}
+
+nscoord nsGridContainerFrame::ReflowRowsInFragmentainer(
+ GridReflowInput& aState, const LogicalRect& aContentArea,
+ ReflowOutput& aDesiredSize, nsReflowStatus& aStatus,
+ Fragmentainer& aFragmentainer, const nsSize& aContainerSize,
+ const nsTArray<const GridItemInfo*>& aSortedItems, uint32_t aStartRow,
+ uint32_t aEndRow, nscoord aBSize, nscoord aAvailableSize) {
+ FrameHashtable pushedItems;
+ FrameHashtable incompleteItems;
+ FrameHashtable overflowIncompleteItems;
+ Maybe<nsTArray<nscoord>> masonryAxisPos;
+ const auto rowCount = aState.mRows.mSizes.Length();
+ nscoord masonryAxisGap;
+ const auto wm = aState.mWM;
+ const bool isColMasonry = IsMasonry(eLogicalAxisInline);
+ if (isColMasonry) {
+ for (auto& sz : aState.mCols.mSizes) {
+ sz.mPosition = 0;
+ }
+ masonryAxisGap = nsLayoutUtils::ResolveGapToLength(
+ aState.mGridStyle->mColumnGap, aContentArea.ISize(wm));
+ aState.mCols.mGridGap = masonryAxisGap;
+ masonryAxisPos.emplace(rowCount);
+ masonryAxisPos->SetLength(rowCount);
+ PodZero(masonryAxisPos->Elements(), rowCount);
+ }
+ bool isBDBClone = aState.mReflowInput->mStyleBorder->mBoxDecorationBreak ==
+ StyleBoxDecorationBreak::Clone;
+ bool didGrowRow = false;
+ // As we walk across rows, we track whether the current row is at the top
+ // of its grid-fragment, to help decide whether we can break before it. When
+ // this function starts, our row is at the top of the current fragment if:
+ // - we're starting with a nonzero row (i.e. we're a continuation)
+ // OR:
+ // - we're starting with the first row, & we're not allowed to break before
+ // it (which makes it effectively at the top of its grid-fragment).
+ bool isRowTopOfPage = aStartRow != 0 || !aFragmentainer.mCanBreakAtStart;
+ const bool isStartRowTopOfPage = isRowTopOfPage;
+ // Save our full available size for later.
+ const nscoord gridAvailableSize = aFragmentainer.mToFragmentainerEnd;
+ // Propagate the constrained size to our children.
+ aFragmentainer.mToFragmentainerEnd = aAvailableSize;
+ // Reflow the items in row order up to |aEndRow| and push items after that.
+ uint32_t row = 0;
+ // |i| is intentionally signed, so we can set it to -1 to restart the loop.
+ for (int32_t i = 0, len = aSortedItems.Length(); i < len; ++i) {
+ const GridItemInfo* const info = aSortedItems[i];
+ nsIFrame* child = info->mFrame;
+ row = info->mArea.mRows.mStart;
+ MOZ_ASSERT(child->GetPrevInFlow() ? row < aStartRow : row >= aStartRow,
+ "unexpected child start row");
+ if (row >= aEndRow) {
+ pushedItems.Insert(child);
+ continue;
+ }
+
+ bool rowCanGrow = false;
+ nscoord maxRowSize = 0;
+ if (row >= aStartRow) {
+ if (row > aStartRow) {
+ isRowTopOfPage = false;
+ }
+ // Can we grow this row? Only consider span=1 items per spec...
+ rowCanGrow = !didGrowRow && info->mArea.mRows.Extent() == 1;
+ if (rowCanGrow) {
+ auto& sz = aState.mRows.mSizes[row];
+ // and only min-/max-content rows or flex rows in an auto-sized
+ // container
+ rowCanGrow = (sz.mState & TrackSize::eMinOrMaxContentMinSizing) ||
+ ((sz.mState & TrackSize::eFlexMaxSizing) &&
+ aFragmentainer.mIsAutoBSize);
+ if (rowCanGrow) {
+ if (isBDBClone) {
+ maxRowSize = gridAvailableSize - aState.mBorderPadding.BEnd(wm);
+ } else {
+ maxRowSize = gridAvailableSize;
+ }
+ maxRowSize -= sz.mPosition;
+ // ...and only if there is space for it to grow.
+ rowCanGrow = maxRowSize > sz.mBase;
+ }
+ }
+ }
+
+ if (isColMasonry) {
+ const auto& cols = info->mArea.mCols;
+ MOZ_ASSERT((cols.mStart == 0 || cols.mStart == 1) && cols.Extent() == 1);
+ aState.mCols.mSizes[cols.mStart].mPosition = masonryAxisPos.ref()[row];
+ }
+
+ // aFragmentainer.mIsTopOfPage is propagated to the child reflow input.
+ // When it's false the child may request InlineBreak::Before. We set it
+ // to false when the row is growable (as determined in the CSS Grid
+ // Fragmentation spec) and there is a non-zero space between it and the
+ // fragmentainer end (that can be used to grow it). If the child reports
+ // a forced break in this case, we grow this row to fill the fragment and
+ // restart the loop. We also restart the loop with |aEndRow = row|
+ // (but without growing any row) for a InlineBreak::Before child if it spans
+ // beyond the last row in this fragment. This is to avoid fragmenting it.
+ // We only restart the loop once.
+ aFragmentainer.mIsTopOfPage = isRowTopOfPage && !rowCanGrow;
+ nsReflowStatus childStatus;
+ // Pass along how much to stretch this fragment, in case it's needed.
+ nscoord bSize =
+ aState.mRows.GridLineEdge(std::min(aEndRow, info->mArea.mRows.mEnd),
+ GridLineSide::BeforeGridGap) -
+ aState.mRows.GridLineEdge(std::max(aStartRow, row),
+ GridLineSide::AfterGridGap);
+ ReflowInFlowChild(child, info, aContainerSize, Some(bSize), &aFragmentainer,
+ aState, aContentArea, aDesiredSize, childStatus);
+ MOZ_ASSERT(childStatus.IsInlineBreakBefore() ||
+ !childStatus.IsFullyComplete() || !child->GetNextInFlow(),
+ "fully-complete reflow should destroy any NIFs");
+
+ if (childStatus.IsInlineBreakBefore()) {
+ MOZ_ASSERT(
+ !child->GetPrevInFlow(),
+ "continuations should never report InlineBreak::Before status");
+ MOZ_ASSERT(!aFragmentainer.mIsTopOfPage,
+ "got IsInlineBreakBefore() at top of page");
+ if (!didGrowRow) {
+ if (rowCanGrow) {
+ // Grow this row and restart with the next row as |aEndRow|.
+ aState.mRows.ResizeRow(row, maxRowSize);
+ if (aState.mSharedGridData) {
+ aState.mSharedGridData->mRows.ResizeRow(row, maxRowSize);
+ }
+ didGrowRow = true;
+ aEndRow = row + 1; // growing this row makes the next one not fit
+ i = -1; // i == 0 after the next loop increment
+ isRowTopOfPage = isStartRowTopOfPage;
+ overflowIncompleteItems.Clear();
+ incompleteItems.Clear();
+ nscoord bEndRow =
+ aState.mRows.GridLineEdge(aEndRow, GridLineSide::BeforeGridGap);
+ aFragmentainer.mToFragmentainerEnd = bEndRow;
+ if (aFragmentainer.mIsAutoBSize) {
+ aBSize = ClampToCSSMaxBSize(bEndRow, aState.mReflowInput, &aStatus);
+ } else if (aStatus.IsIncomplete()) {
+ aBSize = aState.mReflowInput->ApplyMinMaxBSize(
+ aState.mReflowInput->ComputedBSize());
+ aBSize = std::min(bEndRow, aBSize);
+ }
+ continue;
+ }
+
+ if (!isRowTopOfPage) {
+ // We can break before this row - restart with it as the new end row.
+ aEndRow = row;
+ aBSize =
+ aState.mRows.GridLineEdge(aEndRow, GridLineSide::BeforeGridGap);
+ i = -1; // i == 0 after the next loop increment
+ isRowTopOfPage = isStartRowTopOfPage;
+ overflowIncompleteItems.Clear();
+ incompleteItems.Clear();
+ aStatus.SetIncomplete();
+ continue;
+ }
+ NS_ERROR("got InlineBreak::Before at top-of-page");
+ childStatus.Reset();
+ } else {
+ // We got InlineBreak::Before again after growing the row - this can
+ // happen if the child isn't splittable, e.g. some form controls.
+ childStatus.Reset();
+ if (child->GetNextInFlow()) {
+ // The child already has a fragment, so we know it's splittable.
+ childStatus.SetIncomplete();
+ } // else, report that it's complete
+ }
+ } else if (childStatus.IsInlineBreakAfter()) {
+ MOZ_ASSERT_UNREACHABLE("unexpected child reflow status");
+ }
+
+ MOZ_ASSERT(!childStatus.IsInlineBreakBefore(),
+ "should've handled InlineBreak::Before above");
+ if (childStatus.IsIncomplete()) {
+ incompleteItems.Insert(child);
+ } else if (!childStatus.IsFullyComplete()) {
+ overflowIncompleteItems.Insert(child);
+ }
+ if (isColMasonry) {
+ auto childWM = child->GetWritingMode();
+ auto childAxis =
+ !childWM.IsOrthogonalTo(wm) ? eLogicalAxisInline : eLogicalAxisBlock;
+ auto normalPos = child->GetLogicalNormalPosition(wm, aContainerSize);
+ auto sz =
+ childAxis == eLogicalAxisBlock ? child->BSize() : child->ISize();
+ auto pos = normalPos.Pos(eLogicalAxisInline, wm) + sz +
+ child->GetLogicalUsedMargin(childWM).End(childAxis, childWM);
+ masonryAxisPos.ref()[row] =
+ pos + masonryAxisGap - aContentArea.Start(eLogicalAxisInline, wm);
+ }
+ }
+
+ // Record a break before |aEndRow|.
+ aState.mNextFragmentStartRow = aEndRow;
+ if (aEndRow < rowCount) {
+ aState.mRows.BreakBeforeRow(aEndRow);
+ if (aState.mSharedGridData) {
+ aState.mSharedGridData->mRows.BreakBeforeRow(aEndRow);
+ }
+ }
+
+ const bool childrenMoved = PushIncompleteChildren(
+ pushedItems, incompleteItems, overflowIncompleteItems);
+ if (childrenMoved && aStatus.IsComplete()) {
+ aStatus.SetOverflowIncomplete();
+ aStatus.SetNextInFlowNeedsReflow();
+ }
+ if (!pushedItems.IsEmpty()) {
+ AddStateBits(NS_STATE_GRID_DID_PUSH_ITEMS);
+ // NOTE since we messed with our child list here, we intentionally
+ // make aState.mIter invalid to avoid any use of it after this point.
+ aState.mIter.Invalidate();
+ }
+ if (!incompleteItems.IsEmpty()) {
+ // NOTE since we messed with our child list here, we intentionally
+ // make aState.mIter invalid to avoid any use of it after this point.
+ aState.mIter.Invalidate();
+ }
+
+ if (isColMasonry) {
+ nscoord maxSize = 0;
+ for (auto pos : masonryAxisPos.ref()) {
+ maxSize = std::max(maxSize, pos);
+ }
+ maxSize = std::max(nscoord(0), maxSize - masonryAxisGap);
+ aState.AlignJustifyContentInMasonryAxis(maxSize, aContentArea.ISize(wm));
+ }
+
+ return aBSize;
+}
+
+// Here's a brief overview of how Masonry layout is implemented:
+// We setup two synthetic tracks in the Masonry axis so that the Reflow code
+// can treat it the same as for normal grid layout. The first track is
+// fixed (during item placement/layout) at the content box start and contains
+// the start items for each grid-axis track. The second track contains
+// all other items and is moved to the position where we want to position
+// the currently laid out item (like a sliding window as we place items).
+// Once item layout is done, the tracks are resized to be the size of
+// the "masonry box", which is the offset from the content box start to
+// the margin-box end of the item that is furthest away (this happens in
+// AlignJustifyContentInMasonryAxis() called at the end of this method).
+// This is to prepare for AlignJustifyTracksInMasonryAxis, which is called
+// later by our caller.
+// Both tracks store their first-/last-baseline group offsets as usual.
+// The first-baseline of the start track, and the last-baseline of the last
+// track (if they exist) are exported as the grid container's baselines, or
+// we fall back to picking an item's baseline (all this is per normal grid
+// layout). There's a slight difference in which items belongs to which
+// group though - see InitializeItemBaselinesInMasonryAxis for details.
+// This method returns the "masonry box" size (in the masonry axis).
+nscoord nsGridContainerFrame::MasonryLayout(GridReflowInput& aState,
+ const LogicalRect& aContentArea,
+ SizingConstraint aConstraint,
+ ReflowOutput& aDesiredSize,
+ nsReflowStatus& aStatus,
+ Fragmentainer* aFragmentainer,
+ const nsSize& aContainerSize) {
+ using BaselineAlignmentSet = Tracks::BaselineAlignmentSet;
+
+ auto recordAutoPlacement = [this, &aState](GridItemInfo* aItem,
+ LogicalAxis aGridAxis) {
+ // When we're auto-placing an item in a continuation we need to record
+ // the placement in mSharedGridData.
+ if (MOZ_UNLIKELY(aState.mSharedGridData && GetPrevInFlow()) &&
+ (aItem->mState[aGridAxis] & ItemState::eAutoPlacement)) {
+ auto* child = aItem->mFrame;
+ MOZ_RELEASE_ASSERT(!child->GetPrevInFlow(),
+ "continuations should never be auto-placed");
+ for (auto& sharedItem : aState.mSharedGridData->mGridItems) {
+ if (sharedItem.mFrame == child) {
+ sharedItem.mArea.LineRangeForAxis(aGridAxis) =
+ aItem->mArea.LineRangeForAxis(aGridAxis);
+ MOZ_ASSERT(sharedItem.mState[aGridAxis] & ItemState::eAutoPlacement);
+ sharedItem.mState[aGridAxis] &= ~ItemState::eAutoPlacement;
+ break;
+ }
+ }
+ }
+ aItem->mState[aGridAxis] &= ~ItemState::eAutoPlacement;
+ };
+
+ // Collect our grid items and sort them in grid order.
+ nsTArray<GridItemInfo*> sortedItems(aState.mGridItems.Length());
+ aState.mIter.Reset(CSSOrderAwareFrameIterator::ChildFilter::IncludeAll);
+ size_t absposIndex = 0;
+ const LogicalAxis masonryAxis =
+ IsMasonry(eLogicalAxisBlock) ? eLogicalAxisBlock : eLogicalAxisInline;
+ const auto wm = aState.mWM;
+ for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
+ nsIFrame* child = *aState.mIter;
+ if (MOZ_LIKELY(!child->IsPlaceholderFrame())) {
+ GridItemInfo* item = &aState.mGridItems[aState.mIter.ItemIndex()];
+ sortedItems.AppendElement(item);
+ } else if (aConstraint == SizingConstraint::NoConstraint) {
+ // (we only collect placeholders in the NoConstraint case since they
+ // don't affect intrinsic sizing in any way)
+ GridItemInfo* item = nullptr;
+ auto* ph = static_cast<nsPlaceholderFrame*>(child);
+ if (ph->GetOutOfFlowFrame()->GetParent() == this) {
+ item = &aState.mAbsPosItems[absposIndex++];
+ MOZ_RELEASE_ASSERT(item->mFrame == ph->GetOutOfFlowFrame());
+ auto masonryStart = item->mArea.LineRangeForAxis(masonryAxis).mStart;
+ // If the item was placed by the author at line 1 (masonryStart == 0)
+ // then include it to be placed at the masonry-box start. If it's
+ // auto-placed and has an `auto` inset value in the masonry axis then
+ // we include it to be placed after the last grid item with the same
+ // grid-axis start track.
+ // XXXmats this is all a bit experimental at this point, pending a spec
+ if (masonryStart == 0 ||
+ (masonryStart == kAutoLine && item->mFrame->StylePosition()
+ ->mOffset.Start(masonryAxis, wm)
+ .IsAuto())) {
+ sortedItems.AppendElement(item);
+ } else {
+ item = nullptr;
+ }
+ }
+ if (!item) {
+ // It wasn't included above - just reflow it and be done with it.
+ nsReflowStatus childStatus;
+ ReflowInFlowChild(child, nullptr, aContainerSize, Nothing(), nullptr,
+ aState, aContentArea, aDesiredSize, childStatus);
+ }
+ }
+ }
+ const auto masonryAutoFlow = aState.mGridStyle->mMasonryAutoFlow;
+ const bool definiteFirst =
+ masonryAutoFlow.order == StyleMasonryItemOrder::DefiniteFirst;
+ if (masonryAxis == eLogicalAxisBlock) {
+ std::stable_sort(sortedItems.begin(), sortedItems.end(),
+ definiteFirst ? GridItemInfo::RowMasonryDefiniteFirst
+ : GridItemInfo::RowMasonryOrdered);
+ } else {
+ std::stable_sort(sortedItems.begin(), sortedItems.end(),
+ definiteFirst ? GridItemInfo::ColMasonryDefiniteFirst
+ : GridItemInfo::ColMasonryOrdered);
+ }
+
+ FrameHashtable pushedItems;
+ FrameHashtable incompleteItems;
+ FrameHashtable overflowIncompleteItems;
+ nscoord toFragmentainerEnd = nscoord_MAX;
+ nscoord fragStartPos = aState.mFragBStart;
+ const bool avoidBreakInside =
+ aFragmentainer && ShouldAvoidBreakInside(*aState.mReflowInput);
+ const bool isTopOfPageAtStart =
+ aFragmentainer && aFragmentainer->mIsTopOfPage;
+ if (aFragmentainer) {
+ toFragmentainerEnd = std::max(0, aFragmentainer->mToFragmentainerEnd);
+ }
+ const LogicalAxis gridAxis = GetOrthogonalAxis(masonryAxis);
+ const auto gridAxisTrackCount = aState.TracksFor(gridAxis).mSizes.Length();
+ auto& masonryTracks = aState.TracksFor(masonryAxis);
+ auto& masonrySizes = masonryTracks.mSizes;
+ MOZ_ASSERT(masonrySizes.Length() == 2);
+ for (auto& sz : masonrySizes) {
+ sz.mPosition = fragStartPos;
+ }
+ // The current running position for each grid-axis track where the next item
+ // should be positioned. When an item is placed we'll update the tracks it
+ // spans to the end of its margin box + 'gap'.
+ nsTArray<nscoord> currentPos(gridAxisTrackCount);
+ currentPos.SetLength(gridAxisTrackCount);
+ for (auto& sz : currentPos) {
+ sz = fragStartPos;
+ }
+ nsTArray<nscoord> lastPos(currentPos.Clone());
+ nsTArray<GridItemInfo*> lastItems(gridAxisTrackCount);
+ lastItems.SetLength(gridAxisTrackCount);
+ PodZero(lastItems.Elements(), gridAxisTrackCount);
+ const nscoord gap = nsLayoutUtils::ResolveGapToLength(
+ masonryAxis == eLogicalAxisBlock ? aState.mGridStyle->mRowGap
+ : aState.mGridStyle->mColumnGap,
+ masonryTracks.mContentBoxSize);
+ masonryTracks.mGridGap = gap;
+ uint32_t cursor = 0;
+ const auto containerToMasonryBoxOffset =
+ fragStartPos - aContentArea.Start(masonryAxis, wm);
+ const bool isPack = masonryAutoFlow.placement == StyleMasonryPlacement::Pack;
+ bool didAlignStartAlignedFirstItems = false;
+
+ // Return true if any of the lastItems in aRange are baseline-aligned in
+ // the masonry axis.
+ auto lastItemHasBaselineAlignment = [&](const LineRange& aRange) {
+ for (auto i : aRange.Range()) {
+ if (auto* child = lastItems[i] ? lastItems[i]->mFrame : nullptr) {
+ const auto& pos = child->StylePosition();
+ auto selfAlignment = pos->UsedSelfAlignment(masonryAxis, this->Style());
+ if (selfAlignment == StyleAlignFlags::BASELINE ||
+ selfAlignment == StyleAlignFlags::LAST_BASELINE) {
+ return true;
+ }
+ auto childAxis = masonryAxis;
+ if (child->GetWritingMode().IsOrthogonalTo(wm)) {
+ childAxis = gridAxis;
+ }
+ auto contentAlignment = pos->UsedContentAlignment(childAxis).primary;
+ if (contentAlignment == StyleAlignFlags::BASELINE ||
+ contentAlignment == StyleAlignFlags::LAST_BASELINE) {
+ return true;
+ }
+ }
+ }
+ return false;
+ };
+
+ // Resolve aItem's placement, unless it's definite already. Return its
+ // masonry axis position with that placement.
+ auto placeItem = [&](GridItemInfo* aItem) -> nscoord {
+ auto& masonryAxisRange = aItem->mArea.LineRangeForAxis(masonryAxis);
+ MOZ_ASSERT(masonryAxisRange.mStart != 0, "item placement is already final");
+ auto& gridAxisRange = aItem->mArea.LineRangeForAxis(gridAxis);
+ bool isAutoPlaced = aItem->mState[gridAxis] & ItemState::eAutoPlacement;
+ uint32_t start = isAutoPlaced ? 0 : gridAxisRange.mStart;
+ if (isAutoPlaced && !isPack) {
+ start = cursor;
+ isAutoPlaced = false;
+ }
+ const uint32_t extent = gridAxisRange.Extent();
+ if (start + extent > gridAxisTrackCount) {
+ // Note that this will only happen to auto-placed items since the grid is
+ // always wide enough to fit other items.
+ start = 0;
+ }
+ // This keeps track of the smallest `maxPosForRange` value that
+ // we discover in the loop below:
+ nscoord minPos = nscoord_MAX;
+ MOZ_ASSERT(extent <= gridAxisTrackCount);
+ const uint32_t iEnd = gridAxisTrackCount + 1 - extent;
+ for (uint32_t i = start; i < iEnd; ++i) {
+ // Find the max `currentPos` value for the tracks that we would span
+ // if we were to use `i` as our start track:
+ nscoord maxPosForRange = 0;
+ for (auto j = i, jEnd = j + extent; j < jEnd; ++j) {
+ maxPosForRange = std::max(currentPos[j], maxPosForRange);
+ }
+ if (maxPosForRange < minPos) {
+ minPos = maxPosForRange;
+ start = i;
+ }
+ if (!isAutoPlaced) {
+ break;
+ }
+ }
+ gridAxisRange.mStart = start;
+ gridAxisRange.mEnd = start + extent;
+ bool isFirstItem = true;
+ for (uint32_t i : gridAxisRange.Range()) {
+ if (lastItems[i]) {
+ isFirstItem = false;
+ break;
+ }
+ }
+ // If this is the first item in its spanned grid tracks, then place it in
+ // the first masonry track. Otherwise, place it in the second masonry track.
+ masonryAxisRange.mStart = isFirstItem ? 0 : 1;
+ masonryAxisRange.mEnd = masonryAxisRange.mStart + 1;
+ return minPos;
+ };
+
+ // Handle the resulting reflow status after reflowing aItem.
+ // This may set aStatus to BreakBefore which the caller is expected
+ // to handle by returning from MasonryLayout.
+ // @return true if this item should consume all remaining space
+ auto handleChildStatus = [&](GridItemInfo* aItem,
+ const nsReflowStatus& aChildStatus) {
+ bool result = false;
+ if (MOZ_UNLIKELY(aFragmentainer)) {
+ auto* child = aItem->mFrame;
+ if (!aChildStatus.IsComplete() || aChildStatus.IsInlineBreakBefore() ||
+ aChildStatus.IsInlineBreakAfter() ||
+ child->StyleDisplay()->BreakAfter()) {
+ if (!isTopOfPageAtStart && avoidBreakInside) {
+ aStatus.SetInlineLineBreakBeforeAndReset();
+ return result;
+ }
+ result = true;
+ }
+ if (aChildStatus.IsInlineBreakBefore()) {
+ aStatus.SetIncomplete();
+ pushedItems.Insert(child);
+ } else if (aChildStatus.IsIncomplete()) {
+ recordAutoPlacement(aItem, gridAxis);
+ aStatus.SetIncomplete();
+ incompleteItems.Insert(child);
+ } else if (!aChildStatus.IsFullyComplete()) {
+ recordAutoPlacement(aItem, gridAxis);
+ overflowIncompleteItems.Insert(child);
+ }
+ }
+ return result;
+ };
+
+ // @return the distance from the masonry-box start to the end of the margin-
+ // box of aChild
+ auto offsetToMarginBoxEnd = [&](nsIFrame* aChild) {
+ auto childWM = aChild->GetWritingMode();
+ auto childAxis = !childWM.IsOrthogonalTo(wm) ? masonryAxis : gridAxis;
+ auto normalPos = aChild->GetLogicalNormalPosition(wm, aContainerSize);
+ auto sz =
+ childAxis == eLogicalAxisBlock ? aChild->BSize() : aChild->ISize();
+ return containerToMasonryBoxOffset + normalPos.Pos(masonryAxis, wm) + sz +
+ aChild->GetLogicalUsedMargin(childWM).End(childAxis, childWM);
+ };
+
+ // Apply baseline alignment to items belonging to the given set.
+ nsTArray<Tracks::ItemBaselineData> firstBaselineItems;
+ nsTArray<Tracks::ItemBaselineData> lastBaselineItems;
+ auto applyBaselineAlignment = [&](BaselineAlignmentSet aSet) {
+ firstBaselineItems.ClearAndRetainStorage();
+ lastBaselineItems.ClearAndRetainStorage();
+ masonryTracks.InitializeItemBaselinesInMasonryAxis(
+ aState, aState.mGridItems, aSet, aContainerSize, currentPos,
+ firstBaselineItems, lastBaselineItems);
+
+ bool didBaselineAdjustment = false;
+ nsTArray<Tracks::ItemBaselineData>* baselineItems[] = {&firstBaselineItems,
+ &lastBaselineItems};
+ for (const auto* items : baselineItems) {
+ for (const auto& data : *items) {
+ GridItemInfo* item = data.mGridItem;
+ MOZ_ASSERT((item->mState[masonryAxis] & ItemState::eIsBaselineAligned));
+ nscoord baselineOffset = item->mBaselineOffset[masonryAxis];
+ if (baselineOffset == nscoord(0)) {
+ continue; // no adjustment needed for this item
+ }
+ didBaselineAdjustment = true;
+ auto* child = item->mFrame;
+ auto masonryAxisStart =
+ item->mArea.LineRangeForAxis(masonryAxis).mStart;
+ auto gridAxisRange = item->mArea.LineRangeForAxis(gridAxis);
+ masonrySizes[masonryAxisStart].mPosition =
+ aSet.mItemSet == BaselineAlignmentSet::LastItems
+ ? lastPos[gridAxisRange.mStart]
+ : fragStartPos;
+ bool consumeAllSpace = false;
+ const auto state = item->mState[masonryAxis];
+ if ((state & ItemState::eContentBaseline) ||
+ MOZ_UNLIKELY(aFragmentainer)) {
+ if (MOZ_UNLIKELY(aFragmentainer)) {
+ aFragmentainer->mIsTopOfPage =
+ isTopOfPageAtStart &&
+ masonrySizes[masonryAxisStart].mPosition == fragStartPos;
+ }
+ nsReflowStatus childStatus;
+ ReflowInFlowChild(child, item, aContainerSize, Nothing(),
+ aFragmentainer, aState, aContentArea, aDesiredSize,
+ childStatus);
+ consumeAllSpace = handleChildStatus(item, childStatus);
+ if (aStatus.IsInlineBreakBefore()) {
+ return false;
+ }
+ } else if (!(state & ItemState::eEndSideBaseline)) {
+ // `align/justify-self` baselines on the start side can be handled by
+ // just moving the frame (except in a fragmentainer in which case we
+ // reflow it above instead since it might make it INCOMPLETE).
+ LogicalPoint logicalDelta(wm);
+ logicalDelta.Pos(masonryAxis, wm) = baselineOffset;
+ child->MovePositionBy(wm, logicalDelta);
+ }
+ if ((state & ItemState::eEndSideBaseline) && !consumeAllSpace) {
+ // Account for an end-side baseline adjustment.
+ for (uint32_t i : gridAxisRange.Range()) {
+ currentPos[i] += baselineOffset;
+ }
+ } else {
+ nscoord pos = consumeAllSpace ? toFragmentainerEnd
+ : offsetToMarginBoxEnd(child);
+ pos += gap;
+ for (uint32_t i : gridAxisRange.Range()) {
+ currentPos[i] = pos;
+ }
+ }
+ }
+ }
+ return didBaselineAdjustment;
+ };
+
+ // Place and reflow items. We'll use two fake tracks in the masonry axis.
+ // The first contains items that were placed there by the regular grid
+ // placement algo (PlaceGridItems) and we may add some items here if there
+ // are still empty slots. The second track contains all other items.
+ // Both tracks always have the size of the content box in the masonry axis.
+ // The position of the first track is always at the start. The position
+ // of the second track is updated as we go to a position where we want
+ // the current item to be positioned.
+ for (GridItemInfo* item : sortedItems) {
+ auto* child = item->mFrame;
+ auto& masonryRange = item->mArea.LineRangeForAxis(masonryAxis);
+ auto& gridRange = item->mArea.LineRangeForAxis(gridAxis);
+ nsReflowStatus childStatus;
+ if (MOZ_UNLIKELY(child->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW))) {
+ auto contentArea = aContentArea;
+ nscoord pos = nscoord_MAX;
+ // XXXmats take mEnd into consideration...
+ if (gridRange.mStart == kAutoLine) {
+ for (auto p : currentPos) {
+ pos = std::min(p, pos);
+ }
+ } else if (gridRange.mStart < currentPos.Length()) {
+ pos = currentPos[gridRange.mStart];
+ } else if (currentPos.Length() > 0) {
+ pos = currentPos.LastElement();
+ }
+ if (pos == nscoord_MAX) {
+ pos = nscoord(0);
+ }
+ contentArea.Start(masonryAxis, wm) = pos;
+ child = child->GetPlaceholderFrame();
+ ReflowInFlowChild(child, nullptr, aContainerSize, Nothing(), nullptr,
+ aState, contentArea, aDesiredSize, childStatus);
+ } else {
+ MOZ_ASSERT(gridRange.Extent() > 0 &&
+ gridRange.Extent() <= gridAxisTrackCount);
+ MOZ_ASSERT((masonryRange.mStart == 0 || masonryRange.mStart == 1) &&
+ masonryRange.Extent() == 1);
+ if (masonryRange.mStart != 0) {
+ masonrySizes[1].mPosition = placeItem(item);
+ }
+
+ // If this is the first item NOT in the first track and if any of
+ // the grid-axis tracks we span has a baseline-aligned item then we
+ // need to do that baseline alignment now since it may affect
+ // the placement of this and later items.
+ if (!didAlignStartAlignedFirstItems &&
+ aConstraint == SizingConstraint::NoConstraint &&
+ masonryRange.mStart != 0 && lastItemHasBaselineAlignment(gridRange)) {
+ didAlignStartAlignedFirstItems = true;
+ if (applyBaselineAlignment({BaselineAlignmentSet::FirstItems,
+ BaselineAlignmentSet::StartStretch})) {
+ // Baseline alignment resized some items - redo our placement.
+ masonrySizes[1].mPosition = placeItem(item);
+ }
+ if (aStatus.IsInlineBreakBefore()) {
+ return fragStartPos;
+ }
+ }
+
+ for (uint32_t i : gridRange.Range()) {
+ lastItems[i] = item;
+ }
+ cursor = gridRange.mEnd;
+ if (cursor >= gridAxisTrackCount) {
+ cursor = 0;
+ }
+
+ nscoord pos;
+ if (aConstraint == SizingConstraint::NoConstraint) {
+ const auto* disp = child->StyleDisplay();
+ if (MOZ_UNLIKELY(aFragmentainer)) {
+ aFragmentainer->mIsTopOfPage =
+ isTopOfPageAtStart &&
+ masonrySizes[masonryRange.mStart].mPosition == fragStartPos;
+ if (!aFragmentainer->mIsTopOfPage &&
+ (disp->BreakBefore() ||
+ masonrySizes[masonryRange.mStart].mPosition >=
+ toFragmentainerEnd)) {
+ childStatus.SetInlineLineBreakBeforeAndReset();
+ }
+ }
+ if (!childStatus.IsInlineBreakBefore()) {
+ ReflowInFlowChild(child, item, aContainerSize, Nothing(),
+ aFragmentainer, aState, aContentArea, aDesiredSize,
+ childStatus);
+ }
+ bool consumeAllSpace = handleChildStatus(item, childStatus);
+ if (aStatus.IsInlineBreakBefore()) {
+ return fragStartPos;
+ }
+ pos =
+ consumeAllSpace ? toFragmentainerEnd : offsetToMarginBoxEnd(child);
+ } else {
+ LogicalSize percentBasis(
+ aState.PercentageBasisFor(eLogicalAxisInline, *item));
+ IntrinsicISizeType type = aConstraint == SizingConstraint::MaxContent
+ ? IntrinsicISizeType::PrefISize
+ : IntrinsicISizeType::MinISize;
+ auto sz =
+ ::ContentContribution(*item, aState, &aState.mRenderingContext, wm,
+ masonryAxis, Some(percentBasis), type);
+ pos = sz + masonrySizes[masonryRange.mStart].mPosition;
+ }
+ pos += gap;
+ for (uint32_t i : gridRange.Range()) {
+ lastPos[i] = currentPos[i];
+ currentPos[i] = pos;
+ }
+ }
+ }
+
+ // Do the remaining baseline alignment sets.
+ if (aConstraint == SizingConstraint::NoConstraint) {
+ for (auto*& item : lastItems) {
+ if (item) {
+ item->mState[masonryAxis] |= ItemState::eIsLastItemInMasonryTrack;
+ }
+ }
+ BaselineAlignmentSet baselineSets[] = {
+ {BaselineAlignmentSet::FirstItems, BaselineAlignmentSet::StartStretch},
+ {BaselineAlignmentSet::FirstItems, BaselineAlignmentSet::EndStretch},
+ {BaselineAlignmentSet::LastItems, BaselineAlignmentSet::StartStretch},
+ {BaselineAlignmentSet::LastItems, BaselineAlignmentSet::EndStretch},
+ };
+ for (uint32_t i = 0; i < ArrayLength(baselineSets); ++i) {
+ if (i == 0 && didAlignStartAlignedFirstItems) {
+ continue;
+ }
+ applyBaselineAlignment(baselineSets[i]);
+ }
+ }
+
+ const bool childrenMoved = PushIncompleteChildren(
+ pushedItems, incompleteItems, overflowIncompleteItems);
+ if (childrenMoved && aStatus.IsComplete()) {
+ aStatus.SetOverflowIncomplete();
+ aStatus.SetNextInFlowNeedsReflow();
+ }
+ if (!pushedItems.IsEmpty()) {
+ AddStateBits(NS_STATE_GRID_DID_PUSH_ITEMS);
+ // NOTE since we messed with our child list here, we intentionally
+ // make aState.mIter invalid to avoid any use of it after this point.
+ aState.mIter.Invalidate();
+ }
+ if (!incompleteItems.IsEmpty()) {
+ // NOTE since we messed with our child list here, we intentionally
+ // make aState.mIter invalid to avoid any use of it after this point.
+ aState.mIter.Invalidate();
+ }
+
+ nscoord masonryBoxSize = 0;
+ for (auto pos : currentPos) {
+ masonryBoxSize = std::max(masonryBoxSize, pos);
+ }
+ masonryBoxSize = std::max(nscoord(0), masonryBoxSize - gap);
+ if (aConstraint == SizingConstraint::NoConstraint) {
+ aState.AlignJustifyContentInMasonryAxis(masonryBoxSize,
+ masonryTracks.mContentBoxSize);
+ }
+ return masonryBoxSize;
+}
+
+nsGridContainerFrame* nsGridContainerFrame::ParentGridContainerForSubgrid()
+ const {
+ MOZ_ASSERT(IsSubgrid());
+ nsIFrame* p = GetParent();
+ while (p->GetContent() == GetContent()) {
+ p = p->GetParent();
+ }
+ MOZ_ASSERT(p->IsGridContainerFrame());
+ auto* parent = static_cast<nsGridContainerFrame*>(p);
+ MOZ_ASSERT(parent->HasSubgridItems());
+ return parent;
+}
+
+nscoord nsGridContainerFrame::ReflowChildren(GridReflowInput& aState,
+ const LogicalRect& aContentArea,
+ const nsSize& aContainerSize,
+ ReflowOutput& aDesiredSize,
+ nsReflowStatus& aStatus) {
+ WritingMode wm = aState.mReflowInput->GetWritingMode();
+ nscoord bSize = aContentArea.BSize(wm);
+ MOZ_ASSERT(aState.mReflowInput);
+ MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
+ if (HidesContentForLayout()) {
+ return bSize;
+ }
+
+ OverflowAreas ocBounds;
+ nsReflowStatus ocStatus;
+ if (GetPrevInFlow()) {
+ ReflowOverflowContainerChildren(PresContext(), *aState.mReflowInput,
+ ocBounds, ReflowChildFlags::Default,
+ ocStatus, MergeSortedFrameListsFor);
+ }
+
+ Maybe<Fragmentainer> fragmentainer = GetNearestFragmentainer(aState);
+ // MasonryLayout() can only handle fragmentation in the masonry-axis,
+ // so we let ReflowInFragmentainer() deal with grid-axis fragmentation
+ // in the else-clause below.
+ if (IsMasonry() &&
+ !(IsMasonry(eLogicalAxisInline) && fragmentainer.isSome())) {
+ aState.mInFragmentainer = fragmentainer.isSome();
+ nscoord sz = MasonryLayout(
+ aState, aContentArea, SizingConstraint::NoConstraint, aDesiredSize,
+ aStatus, fragmentainer.ptrOr(nullptr), aContainerSize);
+ if (IsMasonry(eLogicalAxisBlock)) {
+ bSize = aState.mReflowInput->ComputedBSize();
+ if (bSize == NS_UNCONSTRAINEDSIZE) {
+ bSize = aState.mReflowInput->ApplyMinMaxBSize(sz);
+ }
+ }
+ } else if (MOZ_UNLIKELY(fragmentainer.isSome())) {
+ if (IsMasonry(eLogicalAxisInline) && !GetPrevInFlow()) {
+ // First we do an unconstrained reflow to resolve the item placement
+ // which is then kept as-is in the constrained reflow below.
+ MasonryLayout(aState, aContentArea, SizingConstraint::NoConstraint,
+ aDesiredSize, aStatus, nullptr, aContainerSize);
+ }
+ aState.mInFragmentainer = true;
+ bSize = ReflowInFragmentainer(aState, aContentArea, aDesiredSize, aStatus,
+ *fragmentainer, aContainerSize);
+ } else {
+ aState.mIter.Reset(CSSOrderAwareFrameIterator::ChildFilter::IncludeAll);
+ for (; !aState.mIter.AtEnd(); aState.mIter.Next()) {
+ nsIFrame* child = *aState.mIter;
+ const GridItemInfo* info = nullptr;
+ if (!child->IsPlaceholderFrame()) {
+ info = &aState.mGridItems[aState.mIter.ItemIndex()];
+ }
+ ReflowInFlowChild(child, info, aContainerSize, Nothing(), nullptr, aState,
+ aContentArea, aDesiredSize, aStatus);
+ MOZ_ASSERT(aStatus.IsComplete(),
+ "child should be complete in unconstrained reflow");
+ }
+ }
+
+ // Merge overflow container bounds and status.
+ aDesiredSize.mOverflowAreas.UnionWith(ocBounds);
+ aStatus.MergeCompletionStatusFrom(ocStatus);
+
+ if (IsAbsoluteContainer()) {
+ const nsFrameList& children = GetChildList(GetAbsoluteListID());
+ if (!children.IsEmpty()) {
+ // 'gridOrigin' is the origin of the grid (the start of the first track),
+ // with respect to the grid container's padding-box (CB).
+ LogicalMargin pad(aState.mReflowInput->ComputedLogicalPadding(wm));
+ const LogicalPoint gridOrigin(wm, pad.IStart(wm), pad.BStart(wm));
+ const LogicalRect gridCB(wm, 0, 0,
+ aContentArea.ISize(wm) + pad.IStartEnd(wm),
+ bSize + pad.BStartEnd(wm));
+ const nsSize gridCBPhysicalSize = gridCB.Size(wm).GetPhysicalSize(wm);
+ size_t i = 0;
+ for (nsIFrame* child : children) {
+ MOZ_ASSERT(i < aState.mAbsPosItems.Length());
+ MOZ_ASSERT(aState.mAbsPosItems[i].mFrame == child);
+ GridArea& area = aState.mAbsPosItems[i].mArea;
+ LogicalRect itemCB =
+ aState.ContainingBlockForAbsPos(area, gridOrigin, gridCB);
+ // nsAbsoluteContainingBlock::Reflow uses physical coordinates.
+ nsRect* cb = child->GetProperty(GridItemContainingBlockRect());
+ if (!cb) {
+ cb = new nsRect;
+ child->SetProperty(GridItemContainingBlockRect(), cb);
+ }
+ *cb = itemCB.GetPhysicalRect(wm, gridCBPhysicalSize);
+ ++i;
+ }
+ // We pass a dummy rect as CB because each child has its own CB rect.
+ // The eIsGridContainerCB flag tells nsAbsoluteContainingBlock::Reflow to
+ // use those instead.
+ nsRect dummyRect;
+ AbsPosReflowFlags flags =
+ AbsPosReflowFlags::CBWidthAndHeightChanged; // XXX could be optimized
+ flags |= AbsPosReflowFlags::ConstrainHeight;
+ flags |= AbsPosReflowFlags::IsGridContainerCB;
+ GetAbsoluteContainingBlock()->Reflow(
+ this, PresContext(), *aState.mReflowInput, aStatus, dummyRect, flags,
+ &aDesiredSize.mOverflowAreas);
+ }
+ }
+ return bSize;
+}
+
+void nsGridContainerFrame::Reflow(nsPresContext* aPresContext,
+ ReflowOutput& aDesiredSize,
+ const ReflowInput& aReflowInput,
+ nsReflowStatus& aStatus) {
+ if (IsHiddenByContentVisibilityOfInFlowParentForLayout()) {
+ return;
+ }
+
+ MarkInReflow();
+ DO_GLOBAL_REFLOW_COUNT("nsGridContainerFrame");
+ DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
+ MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
+
+ if (IsFrameTreeTooDeep(aReflowInput, aDesiredSize, aStatus)) {
+ return;
+ }
+
+ NormalizeChildLists();
+
+#ifdef DEBUG
+ mDidPushItemsBitMayLie = false;
+ SanityCheckChildListsBeforeReflow();
+#endif // DEBUG
+
+ for (auto& perAxisBaseline : mBaseline) {
+ for (auto& baseline : perAxisBaseline) {
+ baseline = NS_INTRINSIC_ISIZE_UNKNOWN;
+ }
+ }
+
+ const nsStylePosition* stylePos = aReflowInput.mStylePosition;
+ auto prevInFlow = static_cast<nsGridContainerFrame*>(GetPrevInFlow());
+ if (MOZ_LIKELY(!prevInFlow)) {
+ InitImplicitNamedAreas(stylePos);
+ } else {
+ MOZ_ASSERT(prevInFlow->HasAnyStateBits(kIsSubgridBits) ==
+ HasAnyStateBits(kIsSubgridBits),
+ "continuations should have same kIsSubgridBits");
+ }
+ GridReflowInput gridReflowInput(this, aReflowInput);
+ if (gridReflowInput.mIter.ItemsAreAlreadyInOrder()) {
+ AddStateBits(NS_STATE_GRID_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER);
+ } else {
+ RemoveStateBits(NS_STATE_GRID_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER);
+ }
+ if (gridReflowInput.mIter.AtEnd() ||
+ aReflowInput.mStyleDisplay->IsContainLayout()) {
+ // We have no grid items, or we're layout-contained. So, we have no
+ // baseline, and our parent should synthesize a baseline if needed.
+ AddStateBits(NS_STATE_GRID_SYNTHESIZE_BASELINE);
+ } else {
+ RemoveStateBits(NS_STATE_GRID_SYNTHESIZE_BASELINE);
+ }
+ const nscoord computedBSize = aReflowInput.ComputedBSize();
+ const nscoord computedISize = aReflowInput.ComputedISize();
+ const WritingMode& wm = gridReflowInput.mWM;
+ const LogicalSize computedSize(wm, computedISize, computedBSize);
+
+ nscoord consumedBSize = 0;
+ nscoord bSize = 0;
+ if (MOZ_LIKELY(!prevInFlow)) {
+ Grid grid;
+ if (MOZ_LIKELY(!IsSubgrid())) {
+ RepeatTrackSizingInput repeatSizing(aReflowInput.ComputedMinSize(),
+ computedSize,
+ aReflowInput.ComputedMaxSize());
+ grid.PlaceGridItems(gridReflowInput, repeatSizing);
+ } else {
+ auto* subgrid = GetProperty(Subgrid::Prop());
+ MOZ_ASSERT(subgrid, "an ancestor forgot to call PlaceGridItems?");
+ gridReflowInput.mGridItems = subgrid->mGridItems.Clone();
+ gridReflowInput.mAbsPosItems = subgrid->mAbsPosItems.Clone();
+ grid.mGridColEnd = subgrid->mGridColEnd;
+ grid.mGridRowEnd = subgrid->mGridRowEnd;
+ }
+ // XXX Technically incorrect: 'contain-intrinsic-block-size: none' is
+ // treated as 0, ignoring our row sizes, when really we should use them but
+ // *they* should be computed as if we had no children. To be fixed in bug
+ // 1488878.
+ const Maybe<nscoord> containBSize =
+ aReflowInput.mFrame->ContainIntrinsicBSize();
+ const nscoord trackSizingBSize = [&] {
+ // This clamping only applies to auto sizes.
+ if (containBSize && computedBSize == NS_UNCONSTRAINEDSIZE) {
+ return aReflowInput.ApplyMinMaxBSize(*containBSize);
+ }
+ return computedBSize;
+ }();
+ const LogicalSize containLogicalSize(wm, computedISize, trackSizingBSize);
+ gridReflowInput.CalculateTrackSizes(grid, containLogicalSize,
+ SizingConstraint::NoConstraint);
+ if (containBSize) {
+ bSize = *containBSize;
+ } else {
+ if (IsMasonry(eLogicalAxisBlock)) {
+ bSize = computedBSize;
+ } else {
+ const auto& rowSizes = gridReflowInput.mRows.mSizes;
+ if (MOZ_LIKELY(!IsSubgrid(eLogicalAxisBlock))) {
+ // Note: we can't use GridLineEdge here since we haven't calculated
+ // the rows' mPosition yet (happens in AlignJustifyContent below).
+ for (const auto& sz : rowSizes) {
+ bSize += sz.mBase;
+ }
+ bSize += gridReflowInput.mRows.SumOfGridGaps();
+ } else if (computedBSize == NS_UNCONSTRAINEDSIZE) {
+ bSize = gridReflowInput.mRows.GridLineEdge(
+ rowSizes.Length(), GridLineSide::BeforeGridGap);
+ }
+ }
+ }
+ } else {
+ consumedBSize = CalcAndCacheConsumedBSize();
+ gridReflowInput.InitializeForContinuation(this, consumedBSize);
+ // XXX Technically incorrect: 'contain-intrinsic-block-size: none' is
+ // treated as 0, ignoring our row sizes, when really we should use them but
+ // *they* should be computed as if we had no children. To be fixed in bug
+ // 1488878.
+ if (Maybe<nscoord> containBSize =
+ aReflowInput.mFrame->ContainIntrinsicBSize()) {
+ bSize = *containBSize;
+ } else {
+ const uint32_t numRows = gridReflowInput.mRows.mSizes.Length();
+ bSize = gridReflowInput.mRows.GridLineEdge(numRows,
+ GridLineSide::AfterGridGap);
+ }
+ }
+ if (computedBSize == NS_UNCONSTRAINEDSIZE) {
+ bSize = aReflowInput.ApplyMinMaxBSize(bSize);
+ } else if (aReflowInput.ShouldApplyAutomaticMinimumOnBlockAxis()) {
+ nscoord contentBSize = aReflowInput.ApplyMinMaxBSize(bSize);
+ bSize = std::max(contentBSize, computedBSize);
+ } else {
+ bSize = computedBSize;
+ }
+ if (bSize != NS_UNCONSTRAINEDSIZE) {
+ bSize = std::max(bSize - consumedBSize, 0);
+ }
+ auto& bp = gridReflowInput.mBorderPadding;
+ LogicalRect contentArea(wm, bp.IStart(wm), bp.BStart(wm), computedISize,
+ bSize);
+
+ if (!prevInFlow) {
+ const auto& rowSizes = gridReflowInput.mRows.mSizes;
+ if (!IsRowSubgrid()) {
+ // Apply 'align-content' to the grid.
+ if (computedBSize == NS_UNCONSTRAINEDSIZE &&
+ stylePos->mRowGap.IsLengthPercentage() &&
+ stylePos->mRowGap.AsLengthPercentage().HasPercent()) {
+ // Re-resolve the row-gap now that we know our intrinsic block-size.
+ gridReflowInput.mRows.mGridGap =
+ nsLayoutUtils::ResolveGapToLength(stylePos->mRowGap, bSize);
+ }
+ if (!gridReflowInput.mRows.mIsMasonry) {
+ auto alignment = stylePos->mAlignContent;
+ gridReflowInput.mRows.AlignJustifyContent(stylePos, alignment, wm,
+ bSize, false);
+ }
+ } else {
+ if (computedBSize == NS_UNCONSTRAINEDSIZE) {
+ bSize = gridReflowInput.mRows.GridLineEdge(rowSizes.Length(),
+ GridLineSide::BeforeGridGap);
+ contentArea.BSize(wm) = std::max(bSize, nscoord(0));
+ }
+ }
+ // Save the final row sizes for use by subgrids, if needed.
+ if (HasSubgridItems() || IsSubgrid()) {
+ StoreUsedTrackSizes(eLogicalAxisBlock, rowSizes);
+ }
+ }
+
+ nsSize containerSize = contentArea.Size(wm).GetPhysicalSize(wm);
+ bool repositionChildren = false;
+ if (containerSize.width == NS_UNCONSTRAINEDSIZE && wm.IsVerticalRL()) {
+ // Note that writing-mode:vertical-rl is the only case where the block
+ // logical direction progresses in a negative physical direction, and
+ // therefore block-dir coordinate conversion depends on knowing the width
+ // of the coordinate space in order to translate between the logical and
+ // physical origins.
+ //
+ // A masonry axis size may be unconstrained, otherwise in a regular grid
+ // our intrinsic size is always known by now. We'll re-position
+ // the children below once our size is known.
+ repositionChildren = true;
+ containerSize.width = 0;
+ }
+ containerSize.width += bp.LeftRight(wm);
+ containerSize.height += bp.TopBottom(wm);
+
+ bSize = ReflowChildren(gridReflowInput, contentArea, containerSize,
+ aDesiredSize, aStatus);
+ bSize = std::max(bSize - consumedBSize, 0);
+
+ // Skip our block-end border if we're INCOMPLETE.
+ if (!aStatus.IsComplete() && !gridReflowInput.mSkipSides.BEnd() &&
+ StyleBorder()->mBoxDecorationBreak != StyleBoxDecorationBreak::Clone) {
+ bp.BEnd(wm) = nscoord(0);
+ }
+
+ LogicalSize desiredSize(wm, computedISize + bp.IStartEnd(wm),
+ bSize + bp.BStartEnd(wm));
+ aDesiredSize.SetSize(wm, desiredSize);
+ nsRect frameRect(0, 0, aDesiredSize.Width(), aDesiredSize.Height());
+ aDesiredSize.mOverflowAreas.UnionAllWith(frameRect);
+
+ if (repositionChildren) {
+ nsPoint physicalDelta(aDesiredSize.Width() - bp.LeftRight(wm), 0);
+ for (const auto& item : gridReflowInput.mGridItems) {
+ auto* child = item.mFrame;
+ child->MovePositionBy(physicalDelta);
+ ConsiderChildOverflow(aDesiredSize.mOverflowAreas, child);
+ }
+ }
+
+ if (Style()->GetPseudoType() == PseudoStyleType::scrolledContent) {
+ // Per spec, the grid area is included in a grid container's scrollable
+ // overflow region [1], as well as the padding on the end-edge sides that
+ // would satisfy the requirements of 'place-content: end' alignment [2].
+ //
+ // Note that we include the padding from all sides of the grid area, not
+ // just the end sides; this is fine because the grid area is relative to our
+ // content-box origin. The inflated bounds won't go beyond our padding-box
+ // edges on the start sides.
+ //
+ // The margin areas of grid item boxes are also included in the scrollable
+ // overflow region [2].
+ //
+ // [1] https://drafts.csswg.org/css-grid-1/#overflow
+ // [2] https://drafts.csswg.org/css-overflow-3/#scrollable
+
+ // Synthesize a grid area covering all columns and rows, and compute its
+ // rect relative to our border-box.
+ //
+ // Note: the grid columns and rows exist only if there is an explicit grid;
+ // or when an implicit grid is needed to place any grid items. See
+ // nsGridContainerFrame::Grid::PlaceGridItems().
+ const auto numCols =
+ static_cast<int32_t>(gridReflowInput.mCols.mSizes.Length());
+ const auto numRows =
+ static_cast<int32_t>(gridReflowInput.mRows.mSizes.Length());
+ if (numCols > 0 && numRows > 0) {
+ const GridArea gridArea(LineRange(0, numCols), LineRange(0, numRows));
+ const LogicalRect gridAreaRect =
+ gridReflowInput.ContainingBlockFor(gridArea) +
+ LogicalPoint(wm, bp.IStart(wm), bp.BStart(wm));
+
+ MOZ_ASSERT(bp == aReflowInput.ComputedLogicalPadding(wm),
+ "A scrolled inner frame shouldn't have any border!");
+ const LogicalMargin& padding = bp;
+ nsRect physicalGridAreaRectWithPadding =
+ gridAreaRect.GetPhysicalRect(wm, containerSize);
+ physicalGridAreaRectWithPadding.Inflate(padding.GetPhysicalMargin(wm));
+ aDesiredSize.mOverflowAreas.UnionAllWith(physicalGridAreaRectWithPadding);
+ }
+
+ nsRect gridItemMarginBoxBounds;
+ for (const auto& item : gridReflowInput.mGridItems) {
+ gridItemMarginBoxBounds =
+ gridItemMarginBoxBounds.Union(item.mFrame->GetMarginRect());
+ }
+ aDesiredSize.mOverflowAreas.UnionAllWith(gridItemMarginBoxBounds);
+ }
+
+ // TODO: fix align-tracks alignment in fragments
+ if ((IsMasonry(eLogicalAxisBlock) && !prevInFlow) ||
+ IsMasonry(eLogicalAxisInline)) {
+ gridReflowInput.AlignJustifyTracksInMasonryAxis(
+ contentArea.Size(wm), aDesiredSize.PhysicalSize());
+ }
+
+ // Convert INCOMPLETE -> OVERFLOW_INCOMPLETE and zero bsize if we're an OC.
+ if (HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) {
+ if (!aStatus.IsComplete()) {
+ aStatus.SetOverflowIncomplete();
+ aStatus.SetNextInFlowNeedsReflow();
+ }
+ bSize = 0;
+ desiredSize.BSize(wm) = bSize + bp.BStartEnd(wm);
+ aDesiredSize.SetSize(wm, desiredSize);
+ }
+
+ if (!gridReflowInput.mInFragmentainer) {
+ MOZ_ASSERT(gridReflowInput.mIter.IsValid());
+ auto sz = frameRect.Size();
+ CalculateBaselines(BaselineSet::eBoth, &gridReflowInput.mIter,
+ &gridReflowInput.mGridItems, gridReflowInput.mCols, 0,
+ gridReflowInput.mCols.mSizes.Length(), wm, sz,
+ bp.IStart(wm), bp.IEnd(wm), desiredSize.ISize(wm));
+ CalculateBaselines(BaselineSet::eBoth, &gridReflowInput.mIter,
+ &gridReflowInput.mGridItems, gridReflowInput.mRows, 0,
+ gridReflowInput.mRows.mSizes.Length(), wm, sz,
+ bp.BStart(wm), bp.BEnd(wm), desiredSize.BSize(wm));
+ } else {
+ // Only compute 'first baseline' if this fragment contains the first track.
+ // XXXmats maybe remove this condition? bug 1306499
+ BaselineSet baselines = BaselineSet::eNone;
+ if (gridReflowInput.mStartRow == 0 &&
+ gridReflowInput.mStartRow != gridReflowInput.mNextFragmentStartRow) {
+ baselines = BaselineSet::eFirst;
+ }
+ // Only compute 'last baseline' if this fragment contains the last track.
+ // XXXmats maybe remove this condition? bug 1306499
+ uint32_t len = gridReflowInput.mRows.mSizes.Length();
+ if (gridReflowInput.mStartRow != len &&
+ gridReflowInput.mNextFragmentStartRow == len) {
+ baselines = BaselineSet(baselines | BaselineSet::eLast);
+ }
+ Maybe<CSSOrderAwareFrameIterator> iter;
+ Maybe<nsTArray<GridItemInfo>> gridItems;
+ if (baselines != BaselineSet::eNone) {
+ // We need to create a new iterator and GridItemInfo array because we
+ // might have pushed some children at this point.
+ // Even if the gridReflowInput iterator is invalid we can reuse its
+ // state about order to optimize initialization of the new iterator.
+ // An ordered child list can't become unordered by pushing frames.
+ // An unordered list can become ordered in a number of cases, but we
+ // ignore that here and guess that the child list is still unordered.
+ // XXX this is O(n^2) in the number of items in this fragment: bug 1306705
+ using Filter = CSSOrderAwareFrameIterator::ChildFilter;
+ using Order = CSSOrderAwareFrameIterator::OrderState;
+ bool ordered = gridReflowInput.mIter.ItemsAreAlreadyInOrder();
+ auto orderState = ordered ? Order::Ordered : Order::Unordered;
+ iter.emplace(this, FrameChildListID::Principal, Filter::SkipPlaceholders,
+ orderState);
+ gridItems.emplace();
+ for (; !iter->AtEnd(); iter->Next()) {
+ auto child = **iter;
+ for (const auto& info : gridReflowInput.mGridItems) {
+ if (info.mFrame == child) {
+ gridItems->AppendElement(info);
+ }
+ }
+ }
+ }
+ auto sz = frameRect.Size();
+ CalculateBaselines(baselines, iter.ptrOr(nullptr), gridItems.ptrOr(nullptr),
+ gridReflowInput.mCols, 0,
+ gridReflowInput.mCols.mSizes.Length(), wm, sz,
+ bp.IStart(wm), bp.IEnd(wm), desiredSize.ISize(wm));
+ CalculateBaselines(baselines, iter.ptrOr(nullptr), gridItems.ptrOr(nullptr),
+ gridReflowInput.mRows, gridReflowInput.mStartRow,
+ gridReflowInput.mNextFragmentStartRow, wm, sz,
+ bp.BStart(wm), bp.BEnd(wm), desiredSize.BSize(wm));
+ }
+
+ if (HasAnyStateBits(NS_STATE_GRID_COMPUTED_INFO)) {
+ // This state bit will never be cleared, since reflow can be called
+ // multiple times in fragmented grids, and it's challenging to scope
+ // the bit to only that sequence of calls. This is relatively harmless
+ // since this bit is only set by accessing a ChromeOnly property, and
+ // therefore can't unduly slow down normal web browsing.
+
+ // Clear our GridFragmentInfo property, which might be holding a stale
+ // dom::Grid object built from previously-computed info. This will
+ // ensure that the next call to GetGridFragments will create a new one.
+ if (mozilla::dom::Grid* grid = TakeProperty(GridFragmentInfo())) {
+ grid->ForgetFrame();
+ }
+
+ // Now that we know column and row sizes and positions, set
+ // the ComputedGridTrackInfo and related properties
+
+ const auto* subgrid = GetProperty(Subgrid::Prop());
+ const auto* subgridColRange = subgrid && IsSubgrid(eLogicalAxisInline)
+ ? &subgrid->SubgridCols()
+ : nullptr;
+
+ LineNameMap colLineNameMap(
+ gridReflowInput.mGridStyle, GetImplicitNamedAreas(),
+ gridReflowInput.mColFunctions, nullptr, subgridColRange, true);
+ uint32_t colTrackCount = gridReflowInput.mCols.mSizes.Length();
+ nsTArray<nscoord> colTrackPositions(colTrackCount);
+ nsTArray<nscoord> colTrackSizes(colTrackCount);
+ nsTArray<uint32_t> colTrackStates(colTrackCount);
+ nsTArray<bool> colRemovedRepeatTracks(
+ gridReflowInput.mColFunctions.mRemovedRepeatTracks.Clone());
+ uint32_t col = 0;
+ for (const TrackSize& sz : gridReflowInput.mCols.mSizes) {
+ colTrackPositions.AppendElement(sz.mPosition);
+ colTrackSizes.AppendElement(sz.mBase);
+ bool isRepeat =
+ ((col >= gridReflowInput.mColFunctions.mRepeatAutoStart) &&
+ (col < gridReflowInput.mColFunctions.mRepeatAutoEnd));
+ colTrackStates.AppendElement(
+ isRepeat ? (uint32_t)mozilla::dom::GridTrackState::Repeat
+ : (uint32_t)mozilla::dom::GridTrackState::Static);
+
+ col++;
+ }
+ // Get the number of explicit tracks first. The order of argument evaluation
+ // is implementation-defined. We should be OK here because colTrackSizes is
+ // taken by rvalue, but computing the size first prevents any changes in the
+ // argument types of the constructor from breaking this.
+ const uint32_t numColExplicitTracks =
+ IsSubgrid(eLogicalAxisInline)
+ ? colTrackSizes.Length()
+ : gridReflowInput.mColFunctions.NumExplicitTracks();
+ ComputedGridTrackInfo* colInfo = new ComputedGridTrackInfo(
+ gridReflowInput.mColFunctions.mExplicitGridOffset, numColExplicitTracks,
+ 0, col, std::move(colTrackPositions), std::move(colTrackSizes),
+ std::move(colTrackStates), std::move(colRemovedRepeatTracks),
+ gridReflowInput.mColFunctions.mRepeatAutoStart,
+ colLineNameMap.GetResolvedLineNamesForComputedGridTrackInfo(),
+ IsSubgrid(eLogicalAxisInline), IsMasonry(eLogicalAxisInline));
+ SetProperty(GridColTrackInfo(), colInfo);
+
+ const auto* subgridRowRange = subgrid && IsSubgrid(eLogicalAxisBlock)
+ ? &subgrid->SubgridRows()
+ : nullptr;
+ LineNameMap rowLineNameMap(
+ gridReflowInput.mGridStyle, GetImplicitNamedAreas(),
+ gridReflowInput.mRowFunctions, nullptr, subgridRowRange, true);
+ uint32_t rowTrackCount = gridReflowInput.mRows.mSizes.Length();
+ nsTArray<nscoord> rowTrackPositions(rowTrackCount);
+ nsTArray<nscoord> rowTrackSizes(rowTrackCount);
+ nsTArray<uint32_t> rowTrackStates(rowTrackCount);
+ nsTArray<bool> rowRemovedRepeatTracks(
+ gridReflowInput.mRowFunctions.mRemovedRepeatTracks.Clone());
+ uint32_t row = 0;
+ for (const TrackSize& sz : gridReflowInput.mRows.mSizes) {
+ rowTrackPositions.AppendElement(sz.mPosition);
+ rowTrackSizes.AppendElement(sz.mBase);
+ bool isRepeat =
+ ((row >= gridReflowInput.mRowFunctions.mRepeatAutoStart) &&
+ (row < gridReflowInput.mRowFunctions.mRepeatAutoEnd));
+ rowTrackStates.AppendElement(
+ isRepeat ? (uint32_t)mozilla::dom::GridTrackState::Repeat
+ : (uint32_t)mozilla::dom::GridTrackState::Static);
+
+ row++;
+ }
+ // Get the number of explicit tracks first. The order of argument evaluation
+ // is implementation-defined. We should be OK here because colTrackSizes is
+ // taken by rvalue, but computing the size first prevents any changes in the
+ // argument types of the constructor from breaking this.
+ const uint32_t numRowExplicitTracks =
+ IsSubgrid(eLogicalAxisBlock)
+ ? rowTrackSizes.Length()
+ : gridReflowInput.mRowFunctions.NumExplicitTracks();
+ // Row info has to accommodate fragmentation of the grid, which may happen
+ // in later calls to Reflow. For now, presume that no more fragmentation
+ // will occur.
+ ComputedGridTrackInfo* rowInfo = new ComputedGridTrackInfo(
+ gridReflowInput.mRowFunctions.mExplicitGridOffset, numRowExplicitTracks,
+ gridReflowInput.mStartRow, row, std::move(rowTrackPositions),
+ std::move(rowTrackSizes), std::move(rowTrackStates),
+ std::move(rowRemovedRepeatTracks),
+ gridReflowInput.mRowFunctions.mRepeatAutoStart,
+ rowLineNameMap.GetResolvedLineNamesForComputedGridTrackInfo(),
+ IsSubgrid(eLogicalAxisBlock), IsMasonry(eLogicalAxisBlock));
+ SetProperty(GridRowTrackInfo(), rowInfo);
+
+ if (prevInFlow) {
+ // This frame is fragmenting rows from a previous frame, so patch up
+ // the prior GridRowTrackInfo with a new end row.
+
+ // FIXME: This can be streamlined and/or removed when bug 1151204 lands.
+
+ ComputedGridTrackInfo* priorRowInfo =
+ prevInFlow->GetProperty(GridRowTrackInfo());
+
+ // Adjust track positions based on the first track in this fragment.
+ if (priorRowInfo->mPositions.Length() >
+ priorRowInfo->mStartFragmentTrack) {
+ nscoord delta =
+ priorRowInfo->mPositions[priorRowInfo->mStartFragmentTrack];
+ for (nscoord& pos : priorRowInfo->mPositions) {
+ pos -= delta;
+ }
+ }
+
+ ComputedGridTrackInfo* revisedPriorRowInfo = new ComputedGridTrackInfo(
+ priorRowInfo->mNumLeadingImplicitTracks,
+ priorRowInfo->mNumExplicitTracks, priorRowInfo->mStartFragmentTrack,
+ gridReflowInput.mStartRow, std::move(priorRowInfo->mPositions),
+ std::move(priorRowInfo->mSizes), std::move(priorRowInfo->mStates),
+ std::move(priorRowInfo->mRemovedRepeatTracks),
+ priorRowInfo->mRepeatFirstTrack,
+ std::move(priorRowInfo->mResolvedLineNames), priorRowInfo->mIsSubgrid,
+ priorRowInfo->mIsMasonry);
+ prevInFlow->SetProperty(GridRowTrackInfo(), revisedPriorRowInfo);
+ }
+
+ // Generate the line info properties. We need to provide the number of
+ // repeat tracks produced in the reflow. Only explicit names are assigned
+ // to lines here; the mozilla::dom::GridLines class will later extract
+ // implicit names from grid areas and assign them to the appropriate lines.
+
+ auto& colFunctions = gridReflowInput.mColFunctions;
+
+ // Generate column lines first.
+ uint32_t capacity = gridReflowInput.mCols.mSizes.Length();
+ nsTArray<nsTArray<RefPtr<nsAtom>>> columnLineNames(capacity);
+ for (col = 0; col <= gridReflowInput.mCols.mSizes.Length(); col++) {
+ // Offset col by the explicit grid offset, to get the original names.
+ nsTArray<RefPtr<nsAtom>> explicitNames =
+ colLineNameMap.GetExplicitLineNamesAtIndex(
+ col - colFunctions.mExplicitGridOffset);
+
+ columnLineNames.EmplaceBack(std::move(explicitNames));
+ }
+ // Get the explicit names that follow a repeat auto declaration.
+ nsTArray<RefPtr<nsAtom>> colNamesFollowingRepeat;
+ nsTArray<RefPtr<nsAtom>> colBeforeRepeatAuto;
+ nsTArray<RefPtr<nsAtom>> colAfterRepeatAuto;
+ // Note: the following is only used for a non-subgridded axis.
+ if (colLineNameMap.HasRepeatAuto()) {
+ MOZ_ASSERT(!colFunctions.mTemplate.IsSubgrid());
+ // The line name list after the repeatAutoIndex holds the line names
+ // for the first explicit line after the repeat auto declaration.
+ uint32_t repeatAutoEnd = colLineNameMap.RepeatAutoStart() + 1;
+ for (auto* list : colLineNameMap.ExpandedLineNames()[repeatAutoEnd]) {
+ for (auto& name : list->AsSpan()) {
+ colNamesFollowingRepeat.AppendElement(name.AsAtom());
+ }
+ }
+ auto names = colLineNameMap.TrackAutoRepeatLineNames();
+ for (auto& name : names[0].AsSpan()) {
+ colBeforeRepeatAuto.AppendElement(name.AsAtom());
+ }
+ for (auto& name : names[1].AsSpan()) {
+ colAfterRepeatAuto.AppendElement(name.AsAtom());
+ }
+ }
+
+ ComputedGridLineInfo* columnLineInfo = new ComputedGridLineInfo(
+ std::move(columnLineNames), std::move(colBeforeRepeatAuto),
+ std::move(colAfterRepeatAuto), std::move(colNamesFollowingRepeat));
+ SetProperty(GridColumnLineInfo(), columnLineInfo);
+
+ // Generate row lines next.
+ auto& rowFunctions = gridReflowInput.mRowFunctions;
+ capacity = gridReflowInput.mRows.mSizes.Length();
+ nsTArray<nsTArray<RefPtr<nsAtom>>> rowLineNames(capacity);
+ for (row = 0; row <= gridReflowInput.mRows.mSizes.Length(); row++) {
+ // Offset row by the explicit grid offset, to get the original names.
+ nsTArray<RefPtr<nsAtom>> explicitNames =
+ rowLineNameMap.GetExplicitLineNamesAtIndex(
+ row - rowFunctions.mExplicitGridOffset);
+ rowLineNames.EmplaceBack(std::move(explicitNames));
+ }
+ // Get the explicit names that follow a repeat auto declaration.
+ nsTArray<RefPtr<nsAtom>> rowNamesFollowingRepeat;
+ nsTArray<RefPtr<nsAtom>> rowBeforeRepeatAuto;
+ nsTArray<RefPtr<nsAtom>> rowAfterRepeatAuto;
+ // Note: the following is only used for a non-subgridded axis.
+ if (rowLineNameMap.HasRepeatAuto()) {
+ MOZ_ASSERT(!rowFunctions.mTemplate.IsSubgrid());
+ // The line name list after the repeatAutoIndex holds the line names
+ // for the first explicit line after the repeat auto declaration.
+ uint32_t repeatAutoEnd = rowLineNameMap.RepeatAutoStart() + 1;
+ for (auto* list : rowLineNameMap.ExpandedLineNames()[repeatAutoEnd]) {
+ for (auto& name : list->AsSpan()) {
+ rowNamesFollowingRepeat.AppendElement(name.AsAtom());
+ }
+ }
+ auto names = rowLineNameMap.TrackAutoRepeatLineNames();
+ for (auto& name : names[0].AsSpan()) {
+ rowBeforeRepeatAuto.AppendElement(name.AsAtom());
+ }
+ for (auto& name : names[1].AsSpan()) {
+ rowAfterRepeatAuto.AppendElement(name.AsAtom());
+ }
+ }
+
+ ComputedGridLineInfo* rowLineInfo = new ComputedGridLineInfo(
+ std::move(rowLineNames), std::move(rowBeforeRepeatAuto),
+ std::move(rowAfterRepeatAuto), std::move(rowNamesFollowingRepeat));
+ SetProperty(GridRowLineInfo(), rowLineInfo);
+
+ // Generate area info for explicit areas. Implicit areas are handled
+ // elsewhere.
+ if (!gridReflowInput.mGridStyle->mGridTemplateAreas.IsNone()) {
+ auto* areas = new StyleOwnedSlice<NamedArea>(
+ gridReflowInput.mGridStyle->mGridTemplateAreas.AsAreas()->areas);
+ SetProperty(ExplicitNamedAreasProperty(), areas);
+ } else {
+ RemoveProperty(ExplicitNamedAreasProperty());
+ }
+ }
+
+ if (!prevInFlow) {
+ SharedGridData* sharedGridData = GetProperty(SharedGridData::Prop());
+ if (!aStatus.IsFullyComplete()) {
+ if (!sharedGridData) {
+ sharedGridData = new SharedGridData;
+ SetProperty(SharedGridData::Prop(), sharedGridData);
+ }
+ sharedGridData->mCols.mSizes = std::move(gridReflowInput.mCols.mSizes);
+ sharedGridData->mCols.mContentBoxSize =
+ gridReflowInput.mCols.mContentBoxSize;
+ sharedGridData->mCols.mBaselineSubtreeAlign =
+ gridReflowInput.mCols.mBaselineSubtreeAlign;
+ sharedGridData->mCols.mIsMasonry = gridReflowInput.mCols.mIsMasonry;
+ sharedGridData->mRows.mSizes = std::move(gridReflowInput.mRows.mSizes);
+ // Save the original row grid sizes and gaps so we can restore them later
+ // in GridReflowInput::Initialize for the continuations.
+ auto& origRowData = sharedGridData->mOriginalRowData;
+ origRowData.ClearAndRetainStorage();
+ origRowData.SetCapacity(sharedGridData->mRows.mSizes.Length());
+ nscoord prevTrackEnd = 0;
+ for (auto& sz : sharedGridData->mRows.mSizes) {
+ SharedGridData::RowData data = {sz.mBase, sz.mPosition - prevTrackEnd};
+ origRowData.AppendElement(data);
+ prevTrackEnd = sz.mPosition + sz.mBase;
+ }
+ sharedGridData->mRows.mContentBoxSize =
+ gridReflowInput.mRows.mContentBoxSize;
+ sharedGridData->mRows.mBaselineSubtreeAlign =
+ gridReflowInput.mRows.mBaselineSubtreeAlign;
+ sharedGridData->mRows.mIsMasonry = gridReflowInput.mRows.mIsMasonry;
+ sharedGridData->mGridItems = std::move(gridReflowInput.mGridItems);
+ sharedGridData->mAbsPosItems = std::move(gridReflowInput.mAbsPosItems);
+
+ sharedGridData->mGenerateComputedGridInfo =
+ HasAnyStateBits(NS_STATE_GRID_COMPUTED_INFO);
+ } else if (sharedGridData && !GetNextInFlow()) {
+ RemoveProperty(SharedGridData::Prop());
+ }
+ }
+
+ FinishAndStoreOverflow(&aDesiredSize);
+}
+
+void nsGridContainerFrame::UpdateSubgridFrameState() {
+ nsFrameState oldBits = GetStateBits() & kIsSubgridBits;
+ nsFrameState newBits = ComputeSelfSubgridMasonryBits() & kIsSubgridBits;
+ if (newBits != oldBits) {
+ RemoveStateBits(kIsSubgridBits);
+ if (!newBits) {
+ RemoveProperty(Subgrid::Prop());
+ } else {
+ AddStateBits(newBits);
+ }
+ }
+}
+
+nsFrameState nsGridContainerFrame::ComputeSelfSubgridMasonryBits() const {
+ nsFrameState bits = nsFrameState(0);
+ const auto* pos = StylePosition();
+
+ // We can only have masonry layout in one axis.
+ if (pos->mGridTemplateRows.IsMasonry()) {
+ bits |= NS_STATE_GRID_IS_ROW_MASONRY;
+ } else if (pos->mGridTemplateColumns.IsMasonry()) {
+ bits |= NS_STATE_GRID_IS_COL_MASONRY;
+ }
+
+ // NOTE: The rest of this function is only relevant if we're a subgrid;
+ // hence, we return early as soon as we rule out that possibility.
+
+ // 'contain:layout/paint' makes us an "independent formatting context",
+ // which prevents us from being a subgrid in this case (but not always).
+ // We will also need to check our containing scroll frame for this property.
+ // https://drafts.csswg.org/css-display-3/#establish-an-independent-formatting-context
+ if (ShouldInhibitSubgridDueToIFC(this)) {
+ return bits;
+ }
+
+ // Skip over our scroll frame and such if we have it, to find our "parent
+ // grid", if we have one.
+
+ // After this loop, 'parent' will represent the parent of the outermost frame
+ // that shares our content node. (Normally this is just our parent frame, but
+ // if we're e.g. a scrolled frame, then this will be the parent of our
+ // wrapper-scrollable-frame.) If 'parent' turns out to be a grid container,
+ // then it's our "parent grid", and we could potentially be a subgrid of it.
+ auto* parent = GetParent();
+ while (parent && parent->GetContent() == GetContent()) {
+ // If we find our containing frame (e.g. our scroll frame) can't be a
+ // subgrid, then we can't be a subgrid, for the same reasons as above. This
+ // can happen when this frame is itself a grid item with "overflow:scroll"
+ // or similar.
+ if (ShouldInhibitSubgridDueToIFC(parent)) {
+ return bits;
+ }
+ parent = parent->GetParent();
+ }
+ const nsGridContainerFrame* parentGrid = do_QueryFrame(parent);
+ if (parentGrid) {
+ bool isOrthogonal =
+ GetWritingMode().IsOrthogonalTo(parent->GetWritingMode());
+ bool isColSubgrid = pos->mGridTemplateColumns.IsSubgrid();
+ // Subgridding a parent masonry axis makes us use masonry layout too,
+ // unless our other axis is a masonry axis.
+ if (isColSubgrid &&
+ parent->HasAnyStateBits(isOrthogonal ? NS_STATE_GRID_IS_ROW_MASONRY
+ : NS_STATE_GRID_IS_COL_MASONRY)) {
+ isColSubgrid = false;
+ if (!HasAnyStateBits(NS_STATE_GRID_IS_ROW_MASONRY)) {
+ bits |= NS_STATE_GRID_IS_COL_MASONRY;
+ }
+ }
+ if (isColSubgrid) {
+ bits |= NS_STATE_GRID_IS_COL_SUBGRID;
+ }
+
+ bool isRowSubgrid = pos->mGridTemplateRows.IsSubgrid();
+ if (isRowSubgrid &&
+ parent->HasAnyStateBits(isOrthogonal ? NS_STATE_GRID_IS_COL_MASONRY
+ : NS_STATE_GRID_IS_ROW_MASONRY)) {
+ isRowSubgrid = false;
+ if (!HasAnyStateBits(NS_STATE_GRID_IS_COL_MASONRY)) {
+ bits |= NS_STATE_GRID_IS_ROW_MASONRY;
+ }
+ }
+ if (isRowSubgrid) {
+ bits |= NS_STATE_GRID_IS_ROW_SUBGRID;
+ }
+ }
+ return bits;
+}
+
+void nsGridContainerFrame::Init(nsIContent* aContent, nsContainerFrame* aParent,
+ nsIFrame* aPrevInFlow) {
+ nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
+
+ if (HasAnyStateBits(NS_FRAME_FONT_INFLATION_CONTAINER)) {
+ AddStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT);
+ }
+
+ nsFrameState bits = nsFrameState(0);
+ if (MOZ_LIKELY(!aPrevInFlow)) {
+ bits = ComputeSelfSubgridMasonryBits();
+ } else {
+ bits = aPrevInFlow->GetStateBits() &
+ (NS_STATE_GRID_IS_ROW_MASONRY | NS_STATE_GRID_IS_COL_MASONRY |
+ kIsSubgridBits | NS_STATE_GRID_HAS_COL_SUBGRID_ITEM |
+ NS_STATE_GRID_HAS_ROW_SUBGRID_ITEM);
+ }
+ AddStateBits(bits);
+}
+
+void nsGridContainerFrame::DidSetComputedStyle(ComputedStyle* aOldStyle) {
+ nsContainerFrame::DidSetComputedStyle(aOldStyle);
+
+ if (!aOldStyle) {
+ return; // Init() already initialized the bits.
+ }
+ UpdateSubgridFrameState();
+}
+
+nscoord nsGridContainerFrame::IntrinsicISize(gfxContext* aRenderingContext,
+ IntrinsicISizeType aType) {
+ // Calculate the sum of column sizes under intrinsic sizing.
+ // http://dev.w3.org/csswg/css-grid/#intrinsic-sizes
+ NormalizeChildLists();
+ GridReflowInput state(this, *aRenderingContext);
+ InitImplicitNamedAreas(state.mGridStyle); // XXX optimize
+
+ // The min/sz/max sizes are the input to the "repeat-to-fill" algorithm:
+ // https://drafts.csswg.org/css-grid/#auto-repeat
+ // They're only used for auto-repeat so we skip computing them otherwise.
+ RepeatTrackSizingInput repeatSizing(state.mWM);
+ if (!IsColSubgrid() && state.mColFunctions.mHasRepeatAuto) {
+ repeatSizing.InitFromStyle(eLogicalAxisInline, state.mWM,
+ state.mFrame->Style());
+ }
+ if ((!IsRowSubgrid() && state.mRowFunctions.mHasRepeatAuto &&
+ !(state.mGridStyle->mGridAutoFlow & StyleGridAutoFlow::ROW)) ||
+ IsMasonry(eLogicalAxisInline)) {
+ // Only 'grid-auto-flow:column' can create new implicit columns, so that's
+ // the only case where our block-size can affect the number of columns.
+ // Masonry layout always depends on how many rows we have though.
+ repeatSizing.InitFromStyle(eLogicalAxisBlock, state.mWM,
+ state.mFrame->Style());
+ }
+
+ Grid grid;
+ if (MOZ_LIKELY(!IsSubgrid())) {
+ grid.PlaceGridItems(state, repeatSizing); // XXX optimize
+ } else {
+ auto* subgrid = GetProperty(Subgrid::Prop());
+ state.mGridItems = subgrid->mGridItems.Clone();
+ state.mAbsPosItems = subgrid->mAbsPosItems.Clone();
+ grid.mGridColEnd = subgrid->mGridColEnd;
+ grid.mGridRowEnd = subgrid->mGridRowEnd;
+ }
+
+ auto constraint = aType == IntrinsicISizeType::MinISize
+ ? SizingConstraint::MinContent
+ : SizingConstraint::MaxContent;
+ if (IsMasonry(eLogicalAxisInline)) {
+ ReflowOutput desiredSize(state.mWM);
+ nsSize containerSize;
+ LogicalRect contentArea(state.mWM);
+ nsReflowStatus status;
+ state.mRows.mSizes.SetLength(grid.mGridRowEnd);
+ state.CalculateTrackSizesForAxis(eLogicalAxisInline, grid,
+ NS_UNCONSTRAINEDSIZE, constraint);
+ return MasonryLayout(state, contentArea, constraint, desiredSize, status,
+ nullptr, containerSize);
+ }
+
+ if (grid.mGridColEnd == 0) {
+ return nscoord(0);
+ }
+
+ state.CalculateTrackSizesForAxis(eLogicalAxisInline, grid,
+ NS_UNCONSTRAINEDSIZE, constraint);
+
+ if (MOZ_LIKELY(!IsSubgrid())) {
+ return state.mCols.SumOfGridTracksAndGaps();
+ }
+ const auto& last = state.mCols.mSizes.LastElement();
+ return last.mPosition + last.mBase;
+}
+
+nscoord nsGridContainerFrame::GetMinISize(gfxContext* aRC) {
+ auto* f = static_cast<nsGridContainerFrame*>(FirstContinuation());
+ if (f != this) {
+ return f->GetMinISize(aRC);
+ }
+
+ DISPLAY_MIN_INLINE_SIZE(this, mCachedMinISize);
+ if (mCachedMinISize == NS_INTRINSIC_ISIZE_UNKNOWN) {
+ Maybe<nscoord> containISize = ContainIntrinsicISize();
+ mCachedMinISize = containISize
+ ? *containISize
+ : IntrinsicISize(aRC, IntrinsicISizeType::MinISize);
+ }
+ return mCachedMinISize;
+}
+
+nscoord nsGridContainerFrame::GetPrefISize(gfxContext* aRC) {
+ auto* f = static_cast<nsGridContainerFrame*>(FirstContinuation());
+ if (f != this) {
+ return f->GetPrefISize(aRC);
+ }
+
+ DISPLAY_PREF_INLINE_SIZE(this, mCachedPrefISize);
+ if (mCachedPrefISize == NS_INTRINSIC_ISIZE_UNKNOWN) {
+ Maybe<nscoord> containISize = ContainIntrinsicISize();
+ mCachedPrefISize = containISize
+ ? *containISize
+ : IntrinsicISize(aRC, IntrinsicISizeType::PrefISize);
+ }
+ return mCachedPrefISize;
+}
+
+void nsGridContainerFrame::MarkIntrinsicISizesDirty() {
+ mCachedMinISize = NS_INTRINSIC_ISIZE_UNKNOWN;
+ mCachedPrefISize = NS_INTRINSIC_ISIZE_UNKNOWN;
+ for (auto& perAxisBaseline : mBaseline) {
+ for (auto& baseline : perAxisBaseline) {
+ baseline = NS_INTRINSIC_ISIZE_UNKNOWN;
+ }
+ }
+ nsContainerFrame::MarkIntrinsicISizesDirty();
+}
+
+void nsGridContainerFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
+ const nsDisplayListSet& aLists) {
+ DisplayBorderBackgroundOutline(aBuilder, aLists);
+ if (GetPrevInFlow()) {
+ DisplayOverflowContainers(aBuilder, aLists);
+ }
+
+ // Our children are all grid-level boxes, which behave the same as
+ // inline-blocks in painting, so their borders/backgrounds all go on
+ // the BlockBorderBackgrounds list.
+ typedef CSSOrderAwareFrameIterator::OrderState OrderState;
+ OrderState order =
+ HasAnyStateBits(NS_STATE_GRID_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER)
+ ? OrderState::Ordered
+ : OrderState::Unordered;
+ CSSOrderAwareFrameIterator iter(
+ this, FrameChildListID::Principal,
+ CSSOrderAwareFrameIterator::ChildFilter::IncludeAll, order);
+ const auto flags = DisplayFlagsForFlexOrGridItem();
+ for (; !iter.AtEnd(); iter.Next()) {
+ nsIFrame* child = *iter;
+ BuildDisplayListForChild(aBuilder, child, aLists, flags);
+ }
+}
+
+bool nsGridContainerFrame::DrainSelfOverflowList() {
+ return DrainAndMergeSelfOverflowList();
+}
+
+void nsGridContainerFrame::AppendFrames(ChildListID aListID,
+ nsFrameList&& aFrameList) {
+ NoteNewChildren(aListID, aFrameList);
+ nsContainerFrame::AppendFrames(aListID, std::move(aFrameList));
+}
+
+void nsGridContainerFrame::InsertFrames(
+ ChildListID aListID, nsIFrame* aPrevFrame,
+ const nsLineList::iterator* aPrevFrameLine, nsFrameList&& aFrameList) {
+ NoteNewChildren(aListID, aFrameList);
+ nsContainerFrame::InsertFrames(aListID, aPrevFrame, aPrevFrameLine,
+ std::move(aFrameList));
+}
+
+void nsGridContainerFrame::RemoveFrame(DestroyContext& aContext,
+ ChildListID aListID,
+ nsIFrame* aOldFrame) {
+ MOZ_ASSERT(aListID == FrameChildListID::Principal, "unexpected child list");
+
+#ifdef DEBUG
+ SetDidPushItemsBitIfNeeded(aListID, aOldFrame);
+#endif
+
+ nsContainerFrame::RemoveFrame(aContext, aListID, aOldFrame);
+}
+
+StyleAlignFlags nsGridContainerFrame::CSSAlignmentForAbsPosChild(
+ const ReflowInput& aChildRI, LogicalAxis aLogicalAxis) const {
+ MOZ_ASSERT(aChildRI.mFrame->IsAbsolutelyPositioned(),
+ "This method should only be called for abspos children");
+
+ StyleAlignFlags alignment =
+ (aLogicalAxis == eLogicalAxisInline)
+ ? aChildRI.mStylePosition->UsedJustifySelf(Style())._0
+ : aChildRI.mStylePosition->UsedAlignSelf(Style())._0;
+
+ // Extract and strip the flag bits
+ StyleAlignFlags alignmentFlags = alignment & StyleAlignFlags::FLAG_BITS;
+ alignment &= ~StyleAlignFlags::FLAG_BITS;
+
+ if (alignment == StyleAlignFlags::NORMAL) {
+ // "the 'normal' keyword behaves as 'start' on replaced
+ // absolutely-positioned boxes, and behaves as 'stretch' on all other
+ // absolutely-positioned boxes."
+ // https://drafts.csswg.org/css-align/#align-abspos
+ // https://drafts.csswg.org/css-align/#justify-abspos
+ alignment = aChildRI.mFrame->IsReplaced() ? StyleAlignFlags::START
+ : StyleAlignFlags::STRETCH;
+ } else if (alignment == StyleAlignFlags::FLEX_START) {
+ alignment = StyleAlignFlags::START;
+ } else if (alignment == StyleAlignFlags::FLEX_END) {
+ alignment = StyleAlignFlags::END;
+ } else if (alignment == StyleAlignFlags::LEFT ||
+ alignment == StyleAlignFlags::RIGHT) {
+ if (aLogicalAxis == eLogicalAxisInline) {
+ const bool isLeft = (alignment == StyleAlignFlags::LEFT);
+ WritingMode wm = GetWritingMode();
+ alignment = (isLeft == wm.IsBidiLTR()) ? StyleAlignFlags::START
+ : StyleAlignFlags::END;
+ } else {
+ alignment = StyleAlignFlags::START;
+ }
+ } else if (alignment == StyleAlignFlags::BASELINE) {
+ alignment = StyleAlignFlags::START;
+ } else if (alignment == StyleAlignFlags::LAST_BASELINE) {
+ alignment = StyleAlignFlags::END;
+ }
+
+ return (alignment | alignmentFlags);
+}
+
+nscoord nsGridContainerFrame::SynthesizeBaseline(
+ const FindItemInGridOrderResult& aGridOrderItem, LogicalAxis aAxis,
+ BaselineSharingGroup aGroup, const nsSize& aCBPhysicalSize, nscoord aCBSize,
+ WritingMode aCBWM) {
+ if (MOZ_UNLIKELY(!aGridOrderItem.mItem)) {
+ // No item in this fragment - synthesize a baseline from our border-box.
+ return ::SynthesizeBaselineFromBorderBox(aGroup, aCBWM, aAxis, aCBSize);
+ }
+
+ nsIFrame* child = aGridOrderItem.mItem->mFrame;
+ nsGridContainerFrame* grid = do_QueryFrame(child);
+ auto childWM = child->GetWritingMode();
+ bool isOrthogonal = aCBWM.IsOrthogonalTo(childWM);
+ const LogicalAxis childAxis = isOrthogonal ? GetOrthogonalAxis(aAxis) : aAxis;
+ nscoord baseline;
+ nscoord start;
+ nscoord size;
+
+ if (aAxis == eLogicalAxisBlock) {
+ start = child->GetLogicalNormalPosition(aCBWM, aCBPhysicalSize).B(aCBWM);
+ size = child->BSize(aCBWM);
+ if (grid && aGridOrderItem.mIsInEdgeTrack) {
+ baseline = isOrthogonal ? grid->GetIBaseline(aGroup)
+ : grid->GetBBaseline(aGroup);
+ } else if (!isOrthogonal && aGridOrderItem.mIsInEdgeTrack) {
+ // This assertion is mostly for documentation purposes; it must hold,
+ // given the checks in our 'if' statements. (We know aAxis is
+ // eLogicalAxisBlock, and isOrthogonal is false, which means childAxis
+ // must be eLogicalAxisBlock). If instead we got here with a childAxis of
+ // eLogicalAxisInline, then our call to
+ // Baseline::SynthesizeBaselineFromBorderBox might incorrectly think
+ // it makes sense to use a central baseline, in an axis where that
+ // doesn't make sense.
+ MOZ_ASSERT(childAxis == eLogicalAxisBlock, "unexpected childAxis");
+ baseline = child
+ ->GetNaturalBaselineBOffset(childWM, aGroup,
+ BaselineExportContext::Other)
+ .valueOrFrom([aGroup, child, childWM]() {
+ return Baseline::SynthesizeBOffsetFromBorderBox(
+ child, childWM, aGroup);
+ });
+ } else {
+ baseline =
+ ::SynthesizeBaselineFromBorderBox(aGroup, childWM, childAxis, size);
+ }
+ } else {
+ start = child->GetLogicalNormalPosition(aCBWM, aCBPhysicalSize).I(aCBWM);
+ size = child->ISize(aCBWM);
+ if (grid && aGridOrderItem.mIsInEdgeTrack) {
+ baseline = isOrthogonal ? grid->GetBBaseline(aGroup)
+ : grid->GetIBaseline(aGroup);
+ } else if (isOrthogonal && aGridOrderItem.mIsInEdgeTrack) {
+ baseline = child
+ ->GetNaturalBaselineBOffset(childWM, aGroup,
+ BaselineExportContext::Other)
+ .valueOrFrom([aGroup, childWM, childAxis, size]() {
+ return ::SynthesizeBaselineFromBorderBox(
+ aGroup, childWM, childAxis, size);
+ });
+ } else {
+ baseline =
+ ::SynthesizeBaselineFromBorderBox(aGroup, childWM, childAxis, size);
+ }
+ }
+ return aGroup == BaselineSharingGroup::First
+ ? start + baseline
+ : aCBSize - start - size + baseline;
+}
+
+void nsGridContainerFrame::CalculateBaselines(
+ BaselineSet aBaselineSet, CSSOrderAwareFrameIterator* aIter,
+ const nsTArray<GridItemInfo>* aGridItems, const Tracks& aTracks,
+ uint32_t aFragmentStartTrack, uint32_t aFirstExcludedTrack, WritingMode aWM,
+ const nsSize& aCBPhysicalSize, nscoord aCBBorderPaddingStart,
+ nscoord aCBBorderPaddingEnd, nscoord aCBSize) {
+ const auto axis = aTracks.mAxis;
+ auto firstBaseline = aTracks.mBaseline[BaselineSharingGroup::First];
+ if (!(aBaselineSet & BaselineSet::eFirst)) {
+ mBaseline[axis][BaselineSharingGroup::First] =
+ ::SynthesizeBaselineFromBorderBox(BaselineSharingGroup::First, aWM,
+ axis, aCBSize);
+ } else if (firstBaseline == NS_INTRINSIC_ISIZE_UNKNOWN) {
+ FindItemInGridOrderResult gridOrderFirstItem = FindFirstItemInGridOrder(
+ *aIter, *aGridItems,
+ axis == eLogicalAxisBlock ? &GridArea::mRows : &GridArea::mCols,
+ axis == eLogicalAxisBlock ? &GridArea::mCols : &GridArea::mRows,
+ aFragmentStartTrack);
+ mBaseline[axis][BaselineSharingGroup::First] = SynthesizeBaseline(
+ gridOrderFirstItem, axis, BaselineSharingGroup::First, aCBPhysicalSize,
+ aCBSize, aWM);
+ } else {
+ // We have a 'first baseline' group in the start track in this fragment.
+ // Convert it from track to grid container border-box coordinates.
+ MOZ_ASSERT(!aGridItems->IsEmpty());
+ nscoord gapBeforeStartTrack =
+ aFragmentStartTrack == 0
+ ? aTracks.GridLineEdge(aFragmentStartTrack,
+ GridLineSide::AfterGridGap)
+ : nscoord(0); // no content gap at start of fragment
+ mBaseline[axis][BaselineSharingGroup::First] =
+ aCBBorderPaddingStart + gapBeforeStartTrack + firstBaseline;
+ }
+
+ auto lastBaseline = aTracks.mBaseline[BaselineSharingGroup::Last];
+ if (!(aBaselineSet & BaselineSet::eLast)) {
+ mBaseline[axis][BaselineSharingGroup::Last] =
+ ::SynthesizeBaselineFromBorderBox(BaselineSharingGroup::Last, aWM, axis,
+ aCBSize);
+ } else if (lastBaseline == NS_INTRINSIC_ISIZE_UNKNOWN) {
+ // For finding items for the 'last baseline' we need to create a reverse
+ // iterator ('aIter' is the forward iterator from the GridReflowInput).
+ using Iter = ReverseCSSOrderAwareFrameIterator;
+ auto orderState = aIter->ItemsAreAlreadyInOrder()
+ ? Iter::OrderState::Ordered
+ : Iter::OrderState::Unordered;
+ Iter iter(this, FrameChildListID::Principal,
+ Iter::ChildFilter::SkipPlaceholders, orderState);
+ iter.SetItemCount(aGridItems->Length());
+ FindItemInGridOrderResult gridOrderLastItem = FindLastItemInGridOrder(
+ iter, *aGridItems,
+ axis == eLogicalAxisBlock ? &GridArea::mRows : &GridArea::mCols,
+ axis == eLogicalAxisBlock ? &GridArea::mCols : &GridArea::mRows,
+ aFragmentStartTrack, aFirstExcludedTrack);
+ mBaseline[axis][BaselineSharingGroup::Last] =
+ SynthesizeBaseline(gridOrderLastItem, axis, BaselineSharingGroup::Last,
+ aCBPhysicalSize, aCBSize, aWM);
+ } else {
+ // We have a 'last baseline' group in the end track in this fragment.
+ // Convert it from track to grid container border-box coordinates.
+ MOZ_ASSERT(!aGridItems->IsEmpty());
+ auto borderBoxStartToEndOfEndTrack =
+ aCBBorderPaddingStart +
+ aTracks.GridLineEdge(aFirstExcludedTrack, GridLineSide::BeforeGridGap) -
+ aTracks.GridLineEdge(aFragmentStartTrack, GridLineSide::BeforeGridGap);
+ mBaseline[axis][BaselineSharingGroup::Last] =
+ (aCBSize - borderBoxStartToEndOfEndTrack) + lastBaseline;
+ }
+}
+
+#ifdef DEBUG_FRAME_DUMP
+nsresult nsGridContainerFrame::GetFrameName(nsAString& aResult) const {
+ return MakeFrameName(u"GridContainer"_ns, aResult);
+}
+
+void nsGridContainerFrame::ExtraContainerFrameInfo(nsACString& aTo) const {
+ if (const void* const subgrid = GetProperty(Subgrid::Prop())) {
+ aTo += nsPrintfCString(" [subgrid=%p]", subgrid);
+ }
+}
+
+#endif
+
+/* static */ nsGridContainerFrame::FindItemInGridOrderResult
+nsGridContainerFrame::FindFirstItemInGridOrder(
+ CSSOrderAwareFrameIterator& aIter, const nsTArray<GridItemInfo>& aGridItems,
+ LineRange GridArea::*aMajor, LineRange GridArea::*aMinor,
+ uint32_t aFragmentStartTrack) {
+ FindItemInGridOrderResult result = {nullptr, false};
+ uint32_t minMajor = kTranslatedMaxLine + 1;
+ uint32_t minMinor = kTranslatedMaxLine + 1;
+ aIter.Reset();
+ for (; !aIter.AtEnd(); aIter.Next()) {
+ const GridItemInfo& item = aGridItems[aIter.ItemIndex()];
+ if ((item.mArea.*aMajor).mEnd <= aFragmentStartTrack) {
+ continue; // item doesn't span any track in this fragment
+ }
+ uint32_t major = (item.mArea.*aMajor).mStart;
+ uint32_t minor = (item.mArea.*aMinor).mStart;
+ if (major < minMajor || (major == minMajor && minor < minMinor)) {
+ minMajor = major;
+ minMinor = minor;
+ result.mItem = &item;
+ result.mIsInEdgeTrack = major == 0U;
+ }
+ }
+ return result;
+}
+
+/* static */ nsGridContainerFrame::FindItemInGridOrderResult
+nsGridContainerFrame::FindLastItemInGridOrder(
+ ReverseCSSOrderAwareFrameIterator& aIter,
+ const nsTArray<GridItemInfo>& aGridItems, LineRange GridArea::*aMajor,
+ LineRange GridArea::*aMinor, uint32_t aFragmentStartTrack,
+ uint32_t aFirstExcludedTrack) {
+ FindItemInGridOrderResult result = {nullptr, false};
+ int32_t maxMajor = -1;
+ int32_t maxMinor = -1;
+ aIter.Reset();
+ int32_t lastMajorTrack = int32_t(aFirstExcludedTrack) - 1;
+ for (; !aIter.AtEnd(); aIter.Next()) {
+ const GridItemInfo& item = aGridItems[aIter.ItemIndex()];
+ // Subtract 1 from the end line to get the item's last track index.
+ int32_t major = (item.mArea.*aMajor).mEnd - 1;
+ // Currently, this method is only called with aFirstExcludedTrack ==
+ // the first track in the next fragment, so we take the opportunity
+ // to assert this item really belongs to this fragment.
+ MOZ_ASSERT((item.mArea.*aMajor).mStart < aFirstExcludedTrack,
+ "found an item that belongs to some later fragment");
+ if (major < int32_t(aFragmentStartTrack)) {
+ continue; // item doesn't span any track in this fragment
+ }
+ int32_t minor = (item.mArea.*aMinor).mEnd - 1;
+ MOZ_ASSERT(minor >= 0 && major >= 0, "grid item must have span >= 1");
+ if (major > maxMajor || (major == maxMajor && minor > maxMinor)) {
+ maxMajor = major;
+ maxMinor = minor;
+ result.mItem = &item;
+ result.mIsInEdgeTrack = major == lastMajorTrack;
+ }
+ }
+ return result;
+}
+
+nsGridContainerFrame::UsedTrackSizes* nsGridContainerFrame::GetUsedTrackSizes()
+ const {
+ return GetProperty(UsedTrackSizes::Prop());
+}
+
+void nsGridContainerFrame::StoreUsedTrackSizes(
+ LogicalAxis aAxis, const nsTArray<TrackSize>& aSizes) {
+ auto* uts = GetUsedTrackSizes();
+ if (!uts) {
+ uts = new UsedTrackSizes();
+ SetProperty(UsedTrackSizes::Prop(), uts);
+ }
+ uts->mSizes[aAxis] = aSizes.Clone();
+ uts->mCanResolveLineRangeSize[aAxis] = true;
+ // XXX is resetting these bits necessary?
+ for (auto& sz : uts->mSizes[aAxis]) {
+ sz.mState &= ~(TrackSize::eFrozen | TrackSize::eSkipGrowUnlimited |
+ TrackSize::eInfinitelyGrowable);
+ }
+}
+
+#ifdef DEBUG
+void nsGridContainerFrame::SetInitialChildList(ChildListID aListID,
+ nsFrameList&& aChildList) {
+ ChildListIDs supportedLists = {FrameChildListID::Principal};
+ // We don't handle the FrameChildListID::Backdrop frames in any way, but it
+ // only contains a placeholder for ::backdrop which is OK to not reflow (for
+ // now anyway).
+ supportedLists += FrameChildListID::Backdrop;
+ MOZ_ASSERT(supportedLists.contains(aListID), "unexpected child list");
+
+ return nsContainerFrame::SetInitialChildList(aListID, std::move(aChildList));
+}
+
+void nsGridContainerFrame::TrackSize::DumpStateBits(StateBits aState) {
+ printf("min:");
+ if (aState & eAutoMinSizing) {
+ printf("auto-min ");
+ } else if (aState & eMinContentMinSizing) {
+ printf("min-content ");
+ } else if (aState & eMaxContentMinSizing) {
+ printf("max-content ");
+ }
+ printf(" max:");
+ if (aState & eAutoMaxSizing) {
+ printf("auto ");
+ } else if (aState & eMinContentMaxSizing) {
+ printf("min-content ");
+ } else if (aState & eMaxContentMaxSizing) {
+ printf("max-content ");
+ } else if (aState & eFlexMaxSizing) {
+ printf("flex ");
+ }
+ if (aState & eFrozen) {
+ printf("frozen ");
+ }
+ if (aState & eModified) {
+ printf("modified ");
+ }
+ if (aState & eBreakBefore) {
+ printf("break-before ");
+ }
+}
+
+void nsGridContainerFrame::TrackSize::Dump() const {
+ printf("mPosition=%d mBase=%d mLimit=%d ", mPosition, mBase, mLimit);
+ DumpStateBits(mState);
+}
+
+#endif // DEBUG
+
+bool nsGridContainerFrame::GridItemShouldStretch(const nsIFrame* aChild,
+ LogicalAxis aAxis) const {
+ MOZ_ASSERT(aChild->IsGridItem());
+
+ if (aChild->IsGridContainerFrame()) {
+ // The subgrid is always stretched in its subgridded dimensions.
+ // https://drafts.csswg.org/css-grid/#subgrid-box-alignment
+ const auto* gridContainer =
+ static_cast<const nsGridContainerFrame*>(aChild);
+ if (gridContainer->IsSubgrid(aAxis)) {
+ return true;
+ }
+ }
+
+ const auto wm = aChild->GetWritingMode();
+ if (aChild->StyleMargin()->HasAuto(aAxis, wm)) {
+ // Per https://drafts.csswg.org/css-grid/#auto-margins, any 'auto' margin in
+ // an axis disables the alignment property in that axis.
+ return false;
+ }
+
+ const auto cbwm = GetWritingMode();
+ const bool isOrthogonal = wm.IsOrthogonalTo(cbwm);
+ if (IsMasonry(isOrthogonal ? GetOrthogonalAxis(aAxis) : aAxis)) {
+ // The child is in the container's masonry-axis.
+ // AlignJustifyTracksInMasonryAxis will stretch it, so we don't report that
+ // here.
+ return false;
+ }
+
+ const auto* pos = aChild->StylePosition();
+ const auto alignment = (aAxis == eLogicalAxisInline) == !isOrthogonal
+ ? pos->UsedJustifySelf(Style())._0
+ : pos->UsedAlignSelf(Style())._0;
+ return alignment == StyleAlignFlags::NORMAL ||
+ alignment == StyleAlignFlags::STRETCH;
+}
+
+bool nsGridContainerFrame::ShouldInhibitSubgridDueToIFC(
+ const nsIFrame* aFrame) {
+ // Just checking for things that make us establish an independent formatting
+ // context (IFC) and hence prevent us from being a subgrid:
+ // * Out-of-flow (e.g. abspos) frames also establish an IFC. Note, our
+ // NS_FRAME_OUT_OF_FLOW bit potentially isn't set yet, so we check our style.
+ // * contain:layout and contain:paint each make us establish an IFC.
+ const auto* display = aFrame->StyleDisplay();
+ return display->IsAbsolutelyPositionedStyle() || display->IsContainLayout() ||
+ display->IsContainPaint();
+}
+
+nsGridContainerFrame* nsGridContainerFrame::GetGridContainerFrame(
+ nsIFrame* aFrame) {
+ nsGridContainerFrame* gridFrame = nullptr;
+
+ if (aFrame) {
+ nsIFrame* inner = aFrame;
+ if (MOZ_UNLIKELY(aFrame->IsFieldSetFrame())) {
+ inner = static_cast<nsFieldSetFrame*>(aFrame)->GetInner();
+ }
+ // Since "Get" methods like GetInner and GetContentInsertionFrame can
+ // return null, we check the return values before dereferencing. Our
+ // calling pattern makes this unlikely, but we're being careful.
+ nsIFrame* insertionFrame =
+ inner ? inner->GetContentInsertionFrame() : nullptr;
+ nsIFrame* possibleGridFrame = insertionFrame ? insertionFrame : aFrame;
+ gridFrame = possibleGridFrame->IsGridContainerFrame()
+ ? static_cast<nsGridContainerFrame*>(possibleGridFrame)
+ : nullptr;
+ }
+ return gridFrame;
+}
+
+nsGridContainerFrame* nsGridContainerFrame::GetGridFrameWithComputedInfo(
+ nsIFrame* aFrame) {
+ nsGridContainerFrame* gridFrame = GetGridContainerFrame(aFrame);
+ if (!gridFrame) {
+ return nullptr;
+ }
+
+ auto HasComputedInfo = [](const nsGridContainerFrame& aFrame) -> bool {
+ return aFrame.HasProperty(GridColTrackInfo()) &&
+ aFrame.HasProperty(GridRowTrackInfo()) &&
+ aFrame.HasProperty(GridColumnLineInfo()) &&
+ aFrame.HasProperty(GridRowLineInfo());
+ };
+
+ if (HasComputedInfo(*gridFrame)) {
+ return gridFrame;
+ }
+
+ // Trigger a reflow that generates additional grid property data.
+ // Hold onto aFrame while we do this, in case reflow destroys it.
+ AutoWeakFrame weakFrameRef(gridFrame);
+
+ RefPtr<mozilla::PresShell> presShell = gridFrame->PresShell();
+ gridFrame->AddStateBits(NS_STATE_GRID_COMPUTED_INFO);
+ presShell->FrameNeedsReflow(gridFrame, IntrinsicDirty::None,
+ NS_FRAME_IS_DIRTY);
+ presShell->FlushPendingNotifications(FlushType::Layout);
+
+ // If the weakFrameRef is no longer valid, then we must bail out.
+ if (!weakFrameRef.IsAlive()) {
+ return nullptr;
+ }
+
+ // This can happen if for some reason we ended up not reflowing, like in print
+ // preview under some circumstances.
+ if (MOZ_UNLIKELY(!HasComputedInfo(*gridFrame))) {
+ return nullptr;
+ }
+
+ return gridFrame;
+}
+
+// TODO: This is a rather dumb implementation of nsILineIterator, but it's
+// better than our pre-existing behavior. Ideally, we should probably use the
+// grid information to return a meaningful number of lines etc.
+bool nsGridContainerFrame::IsLineIteratorFlowRTL() { return false; }
+
+int32_t nsGridContainerFrame::GetNumLines() const {
+ return mFrames.GetLength();
+}
+
+Result<nsILineIterator::LineInfo, nsresult> nsGridContainerFrame::GetLine(
+ int32_t aLineNumber) {
+ if (aLineNumber < 0 || aLineNumber >= GetNumLines()) {
+ return Err(NS_ERROR_FAILURE);
+ }
+ LineInfo rv;
+ nsIFrame* f = mFrames.FrameAt(aLineNumber);
+ rv.mLineBounds = f->GetRect();
+ rv.mFirstFrameOnLine = f;
+ rv.mNumFramesOnLine = 1;
+ return rv;
+}
+
+int32_t nsGridContainerFrame::FindLineContaining(nsIFrame* aFrame,
+ int32_t aStartLine) {
+ const int32_t index = mFrames.IndexOf(aFrame);
+ if (index < 0) {
+ return -1;
+ }
+ if (index < aStartLine) {
+ return -1;
+ }
+ return index;
+}
+
+NS_IMETHODIMP
+nsGridContainerFrame::CheckLineOrder(int32_t aLine, bool* aIsReordered,
+ nsIFrame** aFirstVisual,
+ nsIFrame** aLastVisual) {
+ *aIsReordered = false;
+ *aFirstVisual = nullptr;
+ *aLastVisual = nullptr;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsGridContainerFrame::FindFrameAt(int32_t aLineNumber, nsPoint aPos,
+ nsIFrame** aFrameFound,
+ bool* aPosIsBeforeFirstFrame,
+ bool* aPosIsAfterLastFrame) {
+ const auto wm = GetWritingMode();
+ const LogicalPoint pos(wm, aPos, GetSize());
+
+ *aFrameFound = nullptr;
+ *aPosIsBeforeFirstFrame = true;
+ *aPosIsAfterLastFrame = false;
+
+ nsIFrame* f = mFrames.FrameAt(aLineNumber);
+ if (!f) {
+ return NS_OK;
+ }
+
+ auto rect = f->GetLogicalRect(wm, GetSize());
+ *aFrameFound = f;
+ *aPosIsBeforeFirstFrame = pos.I(wm) < rect.IStart(wm);
+ *aPosIsAfterLastFrame = pos.I(wm) > rect.IEnd(wm);
+ return NS_OK;
+}