summaryrefslogtreecommitdiffstats
path: root/layout/generic/nsFlexContainerFrame.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /layout/generic/nsFlexContainerFrame.cpp
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'layout/generic/nsFlexContainerFrame.cpp')
-rw-r--r--layout/generic/nsFlexContainerFrame.cpp6019
1 files changed, 6019 insertions, 0 deletions
diff --git a/layout/generic/nsFlexContainerFrame.cpp b/layout/generic/nsFlexContainerFrame.cpp
new file mode 100644
index 0000000000..b4fad5cbd8
--- /dev/null
+++ b/layout/generic/nsFlexContainerFrame.cpp
@@ -0,0 +1,6019 @@
+/* -*- 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: flex" */
+
+#include "nsFlexContainerFrame.h"
+
+#include <algorithm>
+
+#include "gfxContext.h"
+#include "mozilla/Baseline.h"
+#include "mozilla/ComputedStyle.h"
+#include "mozilla/CSSOrderAwareFrameIterator.h"
+#include "mozilla/FloatingPoint.h"
+#include "mozilla/Logging.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "mozilla/WritingModes.h"
+#include "nsBlockFrame.h"
+#include "nsContentUtils.h"
+#include "nsCSSAnonBoxes.h"
+#include "nsDebug.h"
+#include "nsDisplayList.h"
+#include "nsFieldSetFrame.h"
+#include "nsIFrameInlines.h"
+#include "nsLayoutUtils.h"
+#include "nsPlaceholderFrame.h"
+#include "nsPresContext.h"
+
+using namespace mozilla;
+using namespace mozilla::layout;
+
+// Convenience typedefs for helper classes that we forward-declare in .h file
+// (so that nsFlexContainerFrame methods can use them as parameters):
+using FlexItem = nsFlexContainerFrame::FlexItem;
+using FlexLine = nsFlexContainerFrame::FlexLine;
+using FlexboxAxisTracker = nsFlexContainerFrame::FlexboxAxisTracker;
+using StrutInfo = nsFlexContainerFrame::StrutInfo;
+using CachedBAxisMeasurement = nsFlexContainerFrame::CachedBAxisMeasurement;
+
+static mozilla::LazyLogModule gFlexContainerLog("FlexContainer");
+#define FLEX_LOG(...) \
+ MOZ_LOG(gFlexContainerLog, LogLevel::Debug, (__VA_ARGS__));
+#define FLEX_LOGV(...) \
+ MOZ_LOG(gFlexContainerLog, LogLevel::Verbose, (__VA_ARGS__));
+
+// Returns true if aFlexContainer is a frame for some element that has
+// display:-webkit-{inline-}box (or -moz-{inline-}box). aFlexContainer is
+// expected to be an instance of nsFlexContainerFrame (enforced with an assert);
+// otherwise, this function's state-bit-check here is bogus.
+static bool IsLegacyBox(const nsIFrame* aFlexContainer) {
+ MOZ_ASSERT(aFlexContainer->IsFlexContainerFrame(),
+ "only flex containers may be passed to this function");
+ return aFlexContainer->HasAnyStateBits(
+ NS_STATE_FLEX_IS_EMULATING_LEGACY_WEBKIT_BOX);
+}
+
+// Returns the OrderState enum we should pass to CSSOrderAwareFrameIterator
+// (depending on whether aFlexContainer has
+// NS_STATE_FLEX_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER state bit).
+static CSSOrderAwareFrameIterator::OrderState OrderStateForIter(
+ const nsFlexContainerFrame* aFlexContainer) {
+ return aFlexContainer->HasAnyStateBits(
+ NS_STATE_FLEX_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER)
+ ? CSSOrderAwareFrameIterator::OrderState::Ordered
+ : CSSOrderAwareFrameIterator::OrderState::Unordered;
+}
+
+// Returns the OrderingProperty enum that we should pass to
+// CSSOrderAwareFrameIterator (depending on whether it's a legacy box).
+static CSSOrderAwareFrameIterator::OrderingProperty OrderingPropertyForIter(
+ const nsFlexContainerFrame* aFlexContainer) {
+ return IsLegacyBox(aFlexContainer)
+ ? CSSOrderAwareFrameIterator::OrderingProperty::BoxOrdinalGroup
+ : CSSOrderAwareFrameIterator::OrderingProperty::Order;
+}
+
+// Returns the "align-items" value that's equivalent to the legacy "box-align"
+// value in the given style struct.
+static StyleAlignFlags ConvertLegacyStyleToAlignItems(
+ const nsStyleXUL* aStyleXUL) {
+ // -[moz|webkit]-box-align corresponds to modern "align-items"
+ switch (aStyleXUL->mBoxAlign) {
+ case StyleBoxAlign::Stretch:
+ return StyleAlignFlags::STRETCH;
+ case StyleBoxAlign::Start:
+ return StyleAlignFlags::FLEX_START;
+ case StyleBoxAlign::Center:
+ return StyleAlignFlags::CENTER;
+ case StyleBoxAlign::Baseline:
+ return StyleAlignFlags::BASELINE;
+ case StyleBoxAlign::End:
+ return StyleAlignFlags::FLEX_END;
+ }
+
+ MOZ_ASSERT_UNREACHABLE("Unrecognized mBoxAlign enum value");
+ // Fall back to default value of "align-items" property:
+ return StyleAlignFlags::STRETCH;
+}
+
+// Returns the "justify-content" value that's equivalent to the legacy
+// "box-pack" value in the given style struct.
+static StyleContentDistribution ConvertLegacyStyleToJustifyContent(
+ const nsStyleXUL* aStyleXUL) {
+ // -[moz|webkit]-box-pack corresponds to modern "justify-content"
+ switch (aStyleXUL->mBoxPack) {
+ case StyleBoxPack::Start:
+ return {StyleAlignFlags::FLEX_START};
+ case StyleBoxPack::Center:
+ return {StyleAlignFlags::CENTER};
+ case StyleBoxPack::End:
+ return {StyleAlignFlags::FLEX_END};
+ case StyleBoxPack::Justify:
+ return {StyleAlignFlags::SPACE_BETWEEN};
+ }
+
+ MOZ_ASSERT_UNREACHABLE("Unrecognized mBoxPack enum value");
+ // Fall back to default value of "justify-content" property:
+ return {StyleAlignFlags::FLEX_START};
+}
+
+/**
+ * Converts a "flex-relative" coordinate in a single axis (a main- or cross-axis
+ * coordinate) into a coordinate in the corresponding physical (x or y) axis. If
+ * the flex-relative axis in question already maps *directly* to a physical
+ * axis (i.e. if it's LTR or TTB), then the physical coordinate has the same
+ * numeric value as the provided flex-relative coordinate. Otherwise, we have to
+ * subtract the flex-relative coordinate from the flex container's size in that
+ * axis, to flip the polarity. (So e.g. a main-axis position of 2px in a RTL
+ * 20px-wide container would correspond to a physical coordinate (x-value) of
+ * 18px.)
+ */
+static nscoord PhysicalCoordFromFlexRelativeCoord(nscoord aFlexRelativeCoord,
+ nscoord aContainerSize,
+ mozilla::Side aStartSide) {
+ if (aStartSide == eSideLeft || aStartSide == eSideTop) {
+ return aFlexRelativeCoord;
+ }
+ return aContainerSize - aFlexRelativeCoord;
+}
+
+// Check if the size is auto or it is a keyword in the block axis.
+// |aIsInline| should represent whether aSize is in the inline axis, from the
+// perspective of the writing mode of the flex item that the size comes from.
+//
+// max-content and min-content should behave as property's initial value.
+// Bug 567039: We treat -moz-fit-content and -moz-available as property's
+// initial value for now.
+static inline bool IsAutoOrEnumOnBSize(const StyleSize& aSize, bool aIsInline) {
+ return aSize.IsAuto() || (!aIsInline && !aSize.IsLengthPercentage());
+}
+
+// Encapsulates our flex container's main & cross axes. This class is backed by
+// a FlexboxAxisInfo helper member variable, and it adds some convenience APIs
+// on top of what that struct offers.
+class MOZ_STACK_CLASS nsFlexContainerFrame::FlexboxAxisTracker {
+ public:
+ explicit FlexboxAxisTracker(const nsFlexContainerFrame* aFlexContainer);
+
+ // Accessors:
+ LogicalAxis MainAxis() const {
+ return IsRowOriented() ? eLogicalAxisInline : eLogicalAxisBlock;
+ }
+ LogicalAxis CrossAxis() const {
+ return IsRowOriented() ? eLogicalAxisBlock : eLogicalAxisInline;
+ }
+
+ LogicalSide MainAxisStartSide() const;
+ LogicalSide MainAxisEndSide() const {
+ return GetOppositeSide(MainAxisStartSide());
+ }
+
+ LogicalSide CrossAxisStartSide() const;
+ LogicalSide CrossAxisEndSide() const {
+ return GetOppositeSide(CrossAxisStartSide());
+ }
+
+ mozilla::Side MainAxisPhysicalStartSide() const {
+ return mWM.PhysicalSide(MainAxisStartSide());
+ }
+ mozilla::Side MainAxisPhysicalEndSide() const {
+ return mWM.PhysicalSide(MainAxisEndSide());
+ }
+
+ mozilla::Side CrossAxisPhysicalStartSide() const {
+ return mWM.PhysicalSide(CrossAxisStartSide());
+ }
+ mozilla::Side CrossAxisPhysicalEndSide() const {
+ return mWM.PhysicalSide(CrossAxisEndSide());
+ }
+
+ // Returns the flex container's writing mode.
+ WritingMode GetWritingMode() const { return mWM; }
+
+ // Returns true if our main axis is in the reverse direction of our
+ // writing mode's corresponding axis. (From 'flex-direction: *-reverse')
+ bool IsMainAxisReversed() const { return mAxisInfo.mIsMainAxisReversed; }
+ // Returns true if our cross axis is in the reverse direction of our
+ // writing mode's corresponding axis. (From 'flex-wrap: *-reverse')
+ bool IsCrossAxisReversed() const { return mAxisInfo.mIsCrossAxisReversed; }
+
+ bool IsRowOriented() const { return mAxisInfo.mIsRowOriented; }
+ bool IsColumnOriented() const { return !IsRowOriented(); }
+
+ // aSize is expected to match the flex container's WritingMode.
+ nscoord MainComponent(const LogicalSize& aSize) const {
+ return IsRowOriented() ? aSize.ISize(mWM) : aSize.BSize(mWM);
+ }
+ int32_t MainComponent(const LayoutDeviceIntSize& aIntSize) const {
+ return IsMainAxisHorizontal() ? aIntSize.width : aIntSize.height;
+ }
+
+ // aSize is expected to match the flex container's WritingMode.
+ nscoord CrossComponent(const LogicalSize& aSize) const {
+ return IsRowOriented() ? aSize.BSize(mWM) : aSize.ISize(mWM);
+ }
+ int32_t CrossComponent(const LayoutDeviceIntSize& aIntSize) const {
+ return IsMainAxisHorizontal() ? aIntSize.height : aIntSize.width;
+ }
+
+ // NOTE: aMargin is expected to use the flex container's WritingMode.
+ nscoord MarginSizeInMainAxis(const LogicalMargin& aMargin) const {
+ // If we're row-oriented, our main axis is the inline axis.
+ return IsRowOriented() ? aMargin.IStartEnd(mWM) : aMargin.BStartEnd(mWM);
+ }
+ nscoord MarginSizeInCrossAxis(const LogicalMargin& aMargin) const {
+ // If we're row-oriented, our cross axis is the block axis.
+ return IsRowOriented() ? aMargin.BStartEnd(mWM) : aMargin.IStartEnd(mWM);
+ }
+
+ /**
+ * Converts a "flex-relative" point (a main-axis & cross-axis coordinate)
+ * into a LogicalPoint, using the flex container's writing mode.
+ *
+ * @arg aMainCoord The main-axis coordinate -- i.e an offset from the
+ * main-start edge of the flex container's content box.
+ * @arg aCrossCoord The cross-axis coordinate -- i.e an offset from the
+ * cross-start edge of the flex container's content box.
+ * @arg aContainerMainSize The main size of flex container's content box.
+ * @arg aContainerCrossSize The cross size of flex container's content box.
+ * @return A LogicalPoint, with the flex container's writing mode, that
+ * represents the same position. The logical coordinates are
+ * relative to the flex container's content box.
+ */
+ LogicalPoint LogicalPointFromFlexRelativePoint(
+ nscoord aMainCoord, nscoord aCrossCoord, nscoord aContainerMainSize,
+ nscoord aContainerCrossSize) const {
+ nscoord logicalCoordInMainAxis =
+ IsMainAxisReversed() ? aContainerMainSize - aMainCoord : aMainCoord;
+ nscoord logicalCoordInCrossAxis =
+ IsCrossAxisReversed() ? aContainerCrossSize - aCrossCoord : aCrossCoord;
+
+ return IsRowOriented() ? LogicalPoint(mWM, logicalCoordInMainAxis,
+ logicalCoordInCrossAxis)
+ : LogicalPoint(mWM, logicalCoordInCrossAxis,
+ logicalCoordInMainAxis);
+ }
+
+ /**
+ * Converts a "flex-relative" size (a main-axis & cross-axis size)
+ * into a LogicalSize, using the flex container's writing mode.
+ *
+ * @arg aMainSize The main-axis size.
+ * @arg aCrossSize The cross-axis size.
+ * @return A LogicalSize, with the flex container's writing mode, that
+ * represents the same size.
+ */
+ LogicalSize LogicalSizeFromFlexRelativeSizes(nscoord aMainSize,
+ nscoord aCrossSize) const {
+ return IsRowOriented() ? LogicalSize(mWM, aMainSize, aCrossSize)
+ : LogicalSize(mWM, aCrossSize, aMainSize);
+ }
+
+ bool IsMainAxisHorizontal() const {
+ // If we're row-oriented, and our writing mode is NOT vertical,
+ // or we're column-oriented and our writing mode IS vertical,
+ // then our main axis is horizontal. This handles all cases:
+ return IsRowOriented() != mWM.IsVertical();
+ }
+
+ // Returns true if this flex item's inline axis in aItemWM is parallel (or
+ // antiparallel) to the container's main axis. Returns false, otherwise.
+ //
+ // Note: this is a helper used before constructing FlexItem. Inside of flex
+ // reflow code, FlexItem::IsInlineAxisMainAxis() is equivalent & more optimal.
+ bool IsInlineAxisMainAxis(WritingMode aItemWM) const {
+ return IsRowOriented() != GetWritingMode().IsOrthogonalTo(aItemWM);
+ }
+
+ // Maps justify-*: 'left' or 'right' to 'start' or 'end'.
+ StyleAlignFlags ResolveJustifyLeftRight(const StyleAlignFlags& aFlags) const {
+ MOZ_ASSERT(
+ aFlags == StyleAlignFlags::LEFT || aFlags == StyleAlignFlags::RIGHT,
+ "This helper accepts only 'LEFT' or 'RIGHT' flags!");
+
+ const auto wm = GetWritingMode();
+ const bool isJustifyLeft = aFlags == StyleAlignFlags::LEFT;
+ if (IsColumnOriented()) {
+ if (!wm.IsVertical()) {
+ // Container's alignment axis (main axis) is *not* parallel to the
+ // line-left <-> line-right axis or the physical left <-> physical right
+ // axis, so we map both 'left' and 'right' to 'start'.
+ return StyleAlignFlags::START;
+ }
+
+ MOZ_ASSERT(wm.PhysicalAxis(MainAxis()) == eAxisHorizontal,
+ "Vertical column-oriented flex container's main axis should "
+ "be parallel to physical left <-> right axis!");
+ // Map 'left' or 'right' to 'start' or 'end', depending on its block flow
+ // direction.
+ return isJustifyLeft == wm.IsVerticalLR() ? StyleAlignFlags::START
+ : StyleAlignFlags::END;
+ }
+
+ MOZ_ASSERT(MainAxis() == eLogicalAxisInline,
+ "Row-oriented flex container's main axis should be parallel to "
+ "line-left <-> line-right axis!");
+
+ // If we get here, we're operating on the flex container's inline axis,
+ // so we map 'left' to whichever of 'start' or 'end' corresponds to the
+ // *line-relative* left side; and similar for 'right'.
+ return isJustifyLeft == wm.IsBidiLTR() ? StyleAlignFlags::START
+ : StyleAlignFlags::END;
+ }
+
+ // Delete copy-constructor & reassignment operator, to prevent accidental
+ // (unnecessary) copying.
+ FlexboxAxisTracker(const FlexboxAxisTracker&) = delete;
+ FlexboxAxisTracker& operator=(const FlexboxAxisTracker&) = delete;
+
+ private:
+ const WritingMode mWM; // The flex container's writing mode.
+ const FlexboxAxisInfo mAxisInfo;
+};
+
+/**
+ * Represents a flex item.
+ * Includes the various pieces of input that the Flexbox Layout Algorithm uses
+ * to resolve a flexible width.
+ */
+class nsFlexContainerFrame::FlexItem final {
+ public:
+ // Normal constructor:
+ FlexItem(ReflowInput& aFlexItemReflowInput, float aFlexGrow,
+ float aFlexShrink, nscoord aFlexBaseSize, nscoord aMainMinSize,
+ nscoord aMainMaxSize, nscoord aTentativeCrossSize,
+ nscoord aCrossMinSize, nscoord aCrossMaxSize,
+ const FlexboxAxisTracker& aAxisTracker);
+
+ // Simplified constructor, to be used only for generating "struts":
+ // (NOTE: This "strut" constructor uses the *container's* writing mode, which
+ // we'll use on this FlexItem instead of the child frame's real writing mode.
+ // This is fine - it doesn't matter what writing mode we use for a
+ // strut, since it won't render any content and we already know its size.)
+ FlexItem(nsIFrame* aChildFrame, nscoord aCrossSize, WritingMode aContainerWM,
+ const FlexboxAxisTracker& aAxisTracker);
+
+ // Clone existing FlexItem for its underlying frame's continuation.
+ // @param aContinuation a continuation in our next-in-flow chain.
+ FlexItem CloneFor(nsIFrame* const aContinuation) const {
+ MOZ_ASSERT(Frame() == aContinuation->FirstInFlow(),
+ "aContinuation should be in aItem's continuation chain!");
+ FlexItem item(*this);
+ item.mFrame = aContinuation;
+ item.mHadMeasuringReflow = false;
+ return item;
+ }
+
+ // Accessors
+ nsIFrame* Frame() const { return mFrame; }
+ nscoord FlexBaseSize() const { return mFlexBaseSize; }
+
+ nscoord MainMinSize() const {
+ MOZ_ASSERT(!mNeedsMinSizeAutoResolution,
+ "Someone's using an unresolved 'auto' main min-size");
+ return mMainMinSize;
+ }
+ nscoord MainMaxSize() const { return mMainMaxSize; }
+
+ // Note: These return the main-axis position and size of our *content box*.
+ nscoord MainSize() const { return mMainSize; }
+ nscoord MainPosition() const { return mMainPosn; }
+
+ nscoord CrossMinSize() const { return mCrossMinSize; }
+ nscoord CrossMaxSize() const { return mCrossMaxSize; }
+
+ // Note: These return the cross-axis position and size of our *content box*.
+ nscoord CrossSize() const { return mCrossSize; }
+ nscoord CrossPosition() const { return mCrossPosn; }
+
+ // Lazy getter for mAscent.
+ nscoord ResolvedAscent(bool aUseFirstBaseline) const {
+ // XXXdholbert Two concerns to follow up on here:
+ // (1) We probably should be checking and reacting to aUseFirstBaseline
+ // for all of the cases here (e.g. this first one). Maybe we need to store
+ // two versions of mAscent and choose the appropriate one based on
+ // aUseFirstBaseline? This is roughly bug 1480850, I think.
+ // (2) We should be using the *container's* writing-mode (mCBWM) here,
+ // instead of the item's (mWM). This is essentially bug 1155322.
+ if (mAscent != ReflowOutput::ASK_FOR_BASELINE) {
+ return mAscent;
+ }
+
+ // Use GetFirstLineBaseline() or GetLastLineBaseline() as appropriate:
+ bool found =
+ aUseFirstBaseline
+ ? nsLayoutUtils::GetFirstLineBaseline(mWM, mFrame, &mAscent)
+ : nsLayoutUtils::GetLastLineBaseline(mWM, mFrame, &mAscent);
+ if (found) {
+ return mAscent;
+ }
+
+ // If the nsLayoutUtils getter fails, then ask the frame directly:
+ auto baselineGroup = aUseFirstBaseline ? BaselineSharingGroup::First
+ : BaselineSharingGroup::Last;
+ if (auto baseline = mFrame->GetNaturalBaselineBOffset(
+ mWM, baselineGroup, BaselineExportContext::Other)) {
+ // Offset for last baseline from `GetNaturalBaselineBOffset` originates
+ // from the frame's block end, so convert it back.
+ mAscent = baselineGroup == BaselineSharingGroup::First
+ ? *baseline
+ : mFrame->BSize(mWM) - *baseline;
+ return mAscent;
+ }
+
+ // We couldn't determine a baseline, so we synthesize one from border box:
+ mAscent = Baseline::SynthesizeBOffsetFromBorderBox(
+ mFrame, mWM, BaselineSharingGroup::First);
+ return mAscent;
+ }
+
+ // Convenience methods to compute the main & cross size of our *margin-box*.
+ nscoord OuterMainSize() const {
+ return mMainSize + MarginBorderPaddingSizeInMainAxis();
+ }
+
+ nscoord OuterCrossSize() const {
+ return mCrossSize + MarginBorderPaddingSizeInCrossAxis();
+ }
+
+ // Convenience methods to synthesize a style main size or a style cross size
+ // with box-size considered, to provide the size overrides when constructing
+ // ReflowInput for flex items.
+ StyleSize StyleMainSize() const {
+ nscoord mainSize = MainSize();
+ if (Frame()->StylePosition()->mBoxSizing == StyleBoxSizing::Border) {
+ mainSize += BorderPaddingSizeInMainAxis();
+ }
+ return StyleSize::LengthPercentage(
+ LengthPercentage::FromAppUnits(mainSize));
+ }
+
+ StyleSize StyleCrossSize() const {
+ nscoord crossSize = CrossSize();
+ if (Frame()->StylePosition()->mBoxSizing == StyleBoxSizing::Border) {
+ crossSize += BorderPaddingSizeInCrossAxis();
+ }
+ return StyleSize::LengthPercentage(
+ LengthPercentage::FromAppUnits(crossSize));
+ }
+
+ // Returns the distance between this FlexItem's baseline and the cross-start
+ // edge of its margin-box. Used in baseline alignment.
+ //
+ // (This function needs to be told which physical start side we're measuring
+ // the baseline from, so that it can look up the appropriate components from
+ // margin.)
+ nscoord BaselineOffsetFromOuterCrossEdge(mozilla::Side aStartSide,
+ bool aUseFirstLineBaseline) const;
+
+ double ShareOfWeightSoFar() const { return mShareOfWeightSoFar; }
+
+ bool IsFrozen() const { return mIsFrozen; }
+
+ bool HadMinViolation() const {
+ MOZ_ASSERT(!mIsFrozen, "min violation has no meaning for frozen items.");
+ return mHadMinViolation;
+ }
+
+ bool HadMaxViolation() const {
+ MOZ_ASSERT(!mIsFrozen, "max violation has no meaning for frozen items.");
+ return mHadMaxViolation;
+ }
+
+ bool WasMinClamped() const {
+ MOZ_ASSERT(mIsFrozen, "min clamping has no meaning for unfrozen items.");
+ return mHadMinViolation;
+ }
+
+ bool WasMaxClamped() const {
+ MOZ_ASSERT(mIsFrozen, "max clamping has no meaning for unfrozen items.");
+ return mHadMaxViolation;
+ }
+
+ // Indicates whether this item received a preliminary "measuring" reflow
+ // before its actual reflow.
+ bool HadMeasuringReflow() const { return mHadMeasuringReflow; }
+
+ // Indicates whether this item's computed cross-size property is 'auto'.
+ bool IsCrossSizeAuto() const;
+
+ // Indicates whether the cross-size property is set to something definite,
+ // for the purpose of preferred aspect ratio calculations.
+ bool IsCrossSizeDefinite(const ReflowInput& aItemReflowInput) const;
+
+ // Indicates whether this item's cross-size has been stretched (from having
+ // "align-self: stretch" with an auto cross-size and no auto margins in the
+ // cross axis).
+ bool IsStretched() const { return mIsStretched; }
+
+ // Indicates whether we need to resolve an 'auto' value for the main-axis
+ // min-[width|height] property.
+ bool NeedsMinSizeAutoResolution() const {
+ return mNeedsMinSizeAutoResolution;
+ }
+
+ bool HasAnyAutoMargin() const { return mHasAnyAutoMargin; }
+
+ // Indicates whether this item is a "strut" left behind by an element with
+ // visibility:collapse.
+ bool IsStrut() const { return mIsStrut; }
+
+ // The main axis and cross axis are relative to mCBWM.
+ LogicalAxis MainAxis() const { return mMainAxis; }
+ LogicalAxis CrossAxis() const { return GetOrthogonalAxis(mMainAxis); }
+
+ // IsInlineAxisMainAxis() returns true if this item's inline axis is parallel
+ // (or antiparallel) to the container's main axis. Otherwise (i.e. if this
+ // item's inline axis is orthogonal to the container's main axis), this
+ // function returns false. The next 3 methods are all other ways of asking
+ // the same question, and only exist for readability at callsites (depending
+ // on which axes those callsites are reasoning about).
+ bool IsInlineAxisMainAxis() const { return mIsInlineAxisMainAxis; }
+ bool IsInlineAxisCrossAxis() const { return !mIsInlineAxisMainAxis; }
+ bool IsBlockAxisMainAxis() const { return !mIsInlineAxisMainAxis; }
+ bool IsBlockAxisCrossAxis() const { return mIsInlineAxisMainAxis; }
+
+ WritingMode GetWritingMode() const { return mWM; }
+ WritingMode ContainingBlockWM() const { return mCBWM; }
+ StyleAlignSelf AlignSelf() const { return mAlignSelf; }
+ StyleAlignFlags AlignSelfFlags() const { return mAlignSelfFlags; }
+
+ // Returns the flex factor (flex-grow or flex-shrink), depending on
+ // 'aIsUsingFlexGrow'.
+ //
+ // Asserts fatally if called on a frozen item (since frozen items are not
+ // flexible).
+ float GetFlexFactor(bool aIsUsingFlexGrow) {
+ MOZ_ASSERT(!IsFrozen(), "shouldn't need flex factor after item is frozen");
+
+ return aIsUsingFlexGrow ? mFlexGrow : mFlexShrink;
+ }
+
+ // Returns the weight that we should use in the "resolving flexible lengths"
+ // algorithm. If we're using the flex grow factor, we just return that;
+ // otherwise, we return the "scaled flex shrink factor" (scaled by our flex
+ // base size, so that when both large and small items are shrinking, the large
+ // items shrink more).
+ //
+ // I'm calling this a "weight" instead of a "[scaled] flex-[grow|shrink]
+ // factor", to more clearly distinguish it from the actual flex-grow &
+ // flex-shrink factors.
+ //
+ // Asserts fatally if called on a frozen item (since frozen items are not
+ // flexible).
+ float GetWeight(bool aIsUsingFlexGrow) {
+ MOZ_ASSERT(!IsFrozen(), "shouldn't need weight after item is frozen");
+
+ if (aIsUsingFlexGrow) {
+ return mFlexGrow;
+ }
+
+ // We're using flex-shrink --> return mFlexShrink * mFlexBaseSize
+ if (mFlexBaseSize == 0) {
+ // Special-case for mFlexBaseSize == 0 -- we have no room to shrink, so
+ // regardless of mFlexShrink, we should just return 0.
+ // (This is really a special-case for when mFlexShrink is infinity, to
+ // avoid performing mFlexShrink * mFlexBaseSize = inf * 0 = undefined.)
+ return 0.0f;
+ }
+ return mFlexShrink * mFlexBaseSize;
+ }
+
+ bool TreatBSizeAsIndefinite() const { return mTreatBSizeAsIndefinite; }
+
+ const AspectRatio& GetAspectRatio() const { return mAspectRatio; }
+ bool HasAspectRatio() const { return !!mAspectRatio; }
+
+ // Getters for margin:
+ // ===================
+ LogicalMargin Margin() const { return mMargin; }
+ nsMargin PhysicalMargin() const { return mMargin.GetPhysicalMargin(mCBWM); }
+
+ // Returns the margin component for a given LogicalSide in flex container's
+ // writing-mode.
+ nscoord GetMarginComponentForSide(LogicalSide aSide) const {
+ return mMargin.Side(aSide, mCBWM);
+ }
+
+ // Returns the total space occupied by this item's margins in the given axis
+ nscoord MarginSizeInMainAxis() const {
+ return mMargin.StartEnd(MainAxis(), mCBWM);
+ }
+ nscoord MarginSizeInCrossAxis() const {
+ return mMargin.StartEnd(CrossAxis(), mCBWM);
+ }
+
+ // Getters for border/padding
+ // ==========================
+ // Returns the total space occupied by this item's borders and padding in
+ // the given axis
+ LogicalMargin BorderPadding() const { return mBorderPadding; }
+ nscoord BorderPaddingSizeInMainAxis() const {
+ return mBorderPadding.StartEnd(MainAxis(), mCBWM);
+ }
+ nscoord BorderPaddingSizeInCrossAxis() const {
+ return mBorderPadding.StartEnd(CrossAxis(), mCBWM);
+ }
+
+ // Getter for combined margin/border/padding
+ // =========================================
+ // Returns the total space occupied by this item's margins, borders and
+ // padding in the given axis
+ nscoord MarginBorderPaddingSizeInMainAxis() const {
+ return MarginSizeInMainAxis() + BorderPaddingSizeInMainAxis();
+ }
+ nscoord MarginBorderPaddingSizeInCrossAxis() const {
+ return MarginSizeInCrossAxis() + BorderPaddingSizeInCrossAxis();
+ }
+
+ // Setters
+ // =======
+ // Helper to set the resolved value of min-[width|height]:auto for the main
+ // axis. (Should only be used if NeedsMinSizeAutoResolution() returns true.)
+ void UpdateMainMinSize(nscoord aNewMinSize) {
+ NS_ASSERTION(aNewMinSize >= 0,
+ "How did we end up with a negative min-size?");
+ MOZ_ASSERT(
+ mMainMaxSize == NS_UNCONSTRAINEDSIZE || mMainMaxSize >= aNewMinSize,
+ "Should only use this function for resolving min-size:auto, "
+ "and main max-size should be an upper-bound for resolved val");
+ MOZ_ASSERT(
+ mNeedsMinSizeAutoResolution &&
+ (mMainMinSize == 0 || mFrame->IsThemed(mFrame->StyleDisplay())),
+ "Should only use this function for resolving min-size:auto, "
+ "so we shouldn't already have a nonzero min-size established "
+ "(unless it's a themed-widget-imposed minimum size)");
+
+ if (aNewMinSize > mMainMinSize) {
+ mMainMinSize = aNewMinSize;
+ // Also clamp main-size to be >= new min-size:
+ mMainSize = std::max(mMainSize, aNewMinSize);
+ }
+ mNeedsMinSizeAutoResolution = false;
+ }
+
+ // This sets our flex base size, and then sets our main size to the
+ // resulting "hypothetical main size" (the base size clamped to our
+ // main-axis [min,max] sizing constraints).
+ void SetFlexBaseSizeAndMainSize(nscoord aNewFlexBaseSize) {
+ MOZ_ASSERT(!mIsFrozen || mFlexBaseSize == NS_UNCONSTRAINEDSIZE,
+ "flex base size shouldn't change after we're frozen "
+ "(unless we're just resolving an intrinsic size)");
+ mFlexBaseSize = aNewFlexBaseSize;
+
+ // Before we've resolved flexible lengths, we keep mMainSize set to
+ // the 'hypothetical main size', which is the flex base size, clamped
+ // to the [min,max] range:
+ mMainSize = NS_CSS_MINMAX(mFlexBaseSize, mMainMinSize, mMainMaxSize);
+
+ FLEX_LOGV(
+ "Set flex base size: %d, hypothetical main size: %d for flex item %p",
+ mFlexBaseSize, mMainSize, mFrame);
+ }
+
+ // Setters used while we're resolving flexible lengths
+ // ---------------------------------------------------
+
+ // Sets the main-size of our flex item's content-box.
+ void SetMainSize(nscoord aNewMainSize) {
+ MOZ_ASSERT(!mIsFrozen, "main size shouldn't change after we're frozen");
+ mMainSize = aNewMainSize;
+ }
+
+ void SetShareOfWeightSoFar(double aNewShare) {
+ MOZ_ASSERT(!mIsFrozen || aNewShare == 0.0,
+ "shouldn't be giving this item any share of the weight "
+ "after it's frozen");
+ mShareOfWeightSoFar = aNewShare;
+ }
+
+ void Freeze() {
+ mIsFrozen = true;
+ // Now that we are frozen, the meaning of mHadMinViolation and
+ // mHadMaxViolation changes to indicate min and max clamping. Clear
+ // both of the member variables so that they are ready to be set
+ // as clamping state later, if necessary.
+ mHadMinViolation = false;
+ mHadMaxViolation = false;
+ }
+
+ void SetHadMinViolation() {
+ MOZ_ASSERT(!mIsFrozen,
+ "shouldn't be changing main size & having violations "
+ "after we're frozen");
+ mHadMinViolation = true;
+ }
+ void SetHadMaxViolation() {
+ MOZ_ASSERT(!mIsFrozen,
+ "shouldn't be changing main size & having violations "
+ "after we're frozen");
+ mHadMaxViolation = true;
+ }
+ void ClearViolationFlags() {
+ MOZ_ASSERT(!mIsFrozen,
+ "shouldn't be altering violation flags after we're "
+ "frozen");
+ mHadMinViolation = mHadMaxViolation = false;
+ }
+
+ void SetWasMinClamped() {
+ MOZ_ASSERT(!mHadMinViolation && !mHadMaxViolation, "only clamp once");
+ // This reuses the mHadMinViolation member variable to track clamping
+ // events. This is allowable because mHadMinViolation only reflects
+ // a violation up until the item is frozen.
+ MOZ_ASSERT(mIsFrozen, "shouldn't set clamping state when we are unfrozen");
+ mHadMinViolation = true;
+ }
+ void SetWasMaxClamped() {
+ MOZ_ASSERT(!mHadMinViolation && !mHadMaxViolation, "only clamp once");
+ // This reuses the mHadMaxViolation member variable to track clamping
+ // events. This is allowable because mHadMaxViolation only reflects
+ // a violation up until the item is frozen.
+ MOZ_ASSERT(mIsFrozen, "shouldn't set clamping state when we are unfrozen");
+ mHadMaxViolation = true;
+ }
+
+ // Setters for values that are determined after we've resolved our main size
+ // -------------------------------------------------------------------------
+
+ // Sets the main-axis position of our flex item's content-box.
+ // (This is the distance between the main-start edge of the flex container
+ // and the main-start edge of the flex item's content-box.)
+ void SetMainPosition(nscoord aPosn) {
+ MOZ_ASSERT(mIsFrozen, "main size should be resolved before this");
+ mMainPosn = aPosn;
+ }
+
+ // Sets the cross-size of our flex item's content-box.
+ void SetCrossSize(nscoord aCrossSize) {
+ MOZ_ASSERT(!mIsStretched,
+ "Cross size shouldn't be modified after it's been stretched");
+ mCrossSize = aCrossSize;
+ }
+
+ // Sets the cross-axis position of our flex item's content-box.
+ // (This is the distance between the cross-start edge of the flex container
+ // and the cross-start edge of the flex item.)
+ void SetCrossPosition(nscoord aPosn) {
+ MOZ_ASSERT(mIsFrozen, "main size should be resolved before this");
+ mCrossPosn = aPosn;
+ }
+
+ // After a FlexItem has had a reflow, this method can be used to cache its
+ // (possibly-unresolved) ascent, in case it's needed later for
+ // baseline-alignment or to establish the container's baseline.
+ // (NOTE: This can be marked 'const' even though it's modifying mAscent,
+ // because mAscent is mutable. It's nice for this to be 'const', because it
+ // means our final reflow can iterate over const FlexItem pointers, and we
+ // can be sure it's not modifying those FlexItems, except via this method.)
+ void SetAscent(nscoord aAscent) const {
+ mAscent = aAscent; // NOTE: this may be ASK_FOR_BASELINE
+ }
+
+ void SetHadMeasuringReflow() { mHadMeasuringReflow = true; }
+
+ void SetIsStretched() {
+ MOZ_ASSERT(mIsFrozen, "main size should be resolved before this");
+ mIsStretched = true;
+ }
+
+ // Setter for margin components (for resolving "auto" margins)
+ void SetMarginComponentForSide(LogicalSide aSide, nscoord aLength) {
+ MOZ_ASSERT(mIsFrozen, "main size should be resolved before this");
+ mMargin.Side(aSide, mCBWM) = aLength;
+ }
+
+ void ResolveStretchedCrossSize(nscoord aLineCrossSize);
+
+ // Resolves flex base size if flex-basis' used value is 'content', using this
+ // item's preferred aspect ratio and cross size.
+ void ResolveFlexBaseSizeFromAspectRatio(const ReflowInput& aItemReflowInput);
+
+ uint32_t NumAutoMarginsInMainAxis() const {
+ return NumAutoMarginsInAxis(MainAxis());
+ };
+
+ uint32_t NumAutoMarginsInCrossAxis() const {
+ return NumAutoMarginsInAxis(CrossAxis());
+ };
+
+ // Once the main size has been resolved, should we bother doing layout to
+ // establish the cross size?
+ bool CanMainSizeInfluenceCrossSize() const;
+
+ // Returns a main size, clamped by any definite min and max cross size
+ // converted through the preferred aspect ratio. The caller is responsible for
+ // ensuring that the flex item's preferred aspect ratio is not zero.
+ nscoord ClampMainSizeViaCrossAxisConstraints(
+ nscoord aMainSize, const ReflowInput& aItemReflowInput) const;
+
+ // Indicates whether we think this flex item needs a "final" reflow
+ // (after its final flexed size & final position have been determined).
+ //
+ // @param aParentReflowInput the flex container's reflow input.
+ // @return true if such a reflow is needed, or false if we believe it can
+ // simply be moved to its final position and skip the reflow.
+ bool NeedsFinalReflow(const ReflowInput& aParentReflowInput) const;
+
+ // Gets the block frame that contains the flex item's content. This is
+ // Frame() itself or one of its descendants.
+ nsBlockFrame* BlockFrame() const;
+
+ protected:
+ bool IsMinSizeAutoResolutionNeeded() const;
+
+ uint32_t NumAutoMarginsInAxis(LogicalAxis aAxis) const;
+
+ // Values that we already know in constructor, and remain unchanged:
+ // The flex item's frame.
+ nsIFrame* mFrame = nullptr;
+ float mFlexGrow = 0.0f;
+ float mFlexShrink = 0.0f;
+ AspectRatio mAspectRatio;
+
+ // The flex item's writing mode.
+ WritingMode mWM;
+
+ // The flex container's writing mode.
+ WritingMode mCBWM;
+
+ // The flex container's main axis in flex container's writing mode.
+ LogicalAxis mMainAxis;
+
+ // Stored in flex container's writing mode.
+ LogicalMargin mBorderPadding;
+
+ // Stored in flex container's writing mode. Its value can change when we
+ // resolve "auto" marigns.
+ LogicalMargin mMargin;
+
+ // These are non-const so that we can lazily update them with the item's
+ // intrinsic size (obtained via a "measuring" reflow), when necessary.
+ // (e.g. for "flex-basis:auto;height:auto" & "min-height:auto")
+ nscoord mFlexBaseSize = 0;
+ nscoord mMainMinSize = 0;
+ nscoord mMainMaxSize = 0;
+
+ // mCrossMinSize and mCrossMaxSize are not changed after constructor.
+ nscoord mCrossMinSize = 0;
+ nscoord mCrossMaxSize = 0;
+
+ // Values that we compute after constructor:
+ nscoord mMainSize = 0;
+ nscoord mMainPosn = 0;
+ nscoord mCrossSize = 0;
+ nscoord mCrossPosn = 0;
+
+ // Mutable b/c it's set & resolved lazily, sometimes via const pointer. See
+ // comment above SetAscent().
+ // We initialize this to ASK_FOR_BASELINE, and opportunistically fill it in
+ // with a real value if we end up reflowing this flex item. (But if we don't
+ // reflow this flex item, then this sentinel tells us that we don't know it
+ // yet & anyone who cares will need to explicitly request it.)
+ mutable nscoord mAscent = ReflowOutput::ASK_FOR_BASELINE;
+
+ // Temporary state, while we're resolving flexible widths (for our main size)
+ // XXXdholbert To save space, we could use a union to make these variables
+ // overlay the same memory as some other member vars that aren't touched
+ // until after main-size has been resolved. In particular, these could share
+ // memory with mMainPosn through mAscent, and mIsStretched.
+ double mShareOfWeightSoFar = 0.0;
+
+ bool mIsFrozen = false;
+ bool mHadMinViolation = false;
+ bool mHadMaxViolation = false;
+
+ // Did this item get a preliminary reflow, to measure its desired height?
+ bool mHadMeasuringReflow = false;
+
+ // See IsStretched() documentation.
+ bool mIsStretched = false;
+
+ // Is this item a "strut" left behind by an element with visibility:collapse?
+ bool mIsStrut = false;
+
+ // See IsInlineAxisMainAxis() documentation. This is not changed after
+ // constructor.
+ bool mIsInlineAxisMainAxis = true;
+
+ // Does this item need to resolve a min-[width|height]:auto (in main-axis)?
+ //
+ // Note: mNeedsMinSizeAutoResolution needs to be declared towards the end of
+ // the member variables since it's initialized in a method that depends on
+ // other members declared above such as mCBWM, mMainAxis, and
+ // mIsInlineAxisMainAxis.
+ bool mNeedsMinSizeAutoResolution = false;
+
+ // Should we take care to treat this item's resolved BSize as indefinite?
+ bool mTreatBSizeAsIndefinite = false;
+
+ // Does this item have an auto margin in either main or cross axis?
+ bool mHasAnyAutoMargin = false;
+
+ // My "align-self" computed value (with "auto" swapped out for parent"s
+ // "align-items" value, in our constructor).
+ StyleAlignSelf mAlignSelf{StyleAlignFlags::AUTO};
+
+ // Flags for 'align-self' (safe/unsafe/legacy).
+ StyleAlignFlags mAlignSelfFlags{0};
+};
+
+/**
+ * Represents a single flex line in a flex container.
+ * Manages an array of the FlexItems that are in the line.
+ */
+class nsFlexContainerFrame::FlexLine final {
+ public:
+ explicit FlexLine(nscoord aMainGapSize) : mMainGapSize(aMainGapSize) {}
+
+ nscoord SumOfGaps() const {
+ return NumItems() > 0 ? (NumItems() - 1) * mMainGapSize : 0;
+ }
+
+ // Returns the sum of our FlexItems' outer hypothetical main sizes plus the
+ // sum of main axis {row,column}-gaps between items.
+ // ("outer" = margin-box, and "hypothetical" = before flexing)
+ AuCoord64 TotalOuterHypotheticalMainSize() const {
+ return mTotalOuterHypotheticalMainSize;
+ }
+
+ // Accessors for our FlexItems & information about them:
+ //
+ // Note: Using IsEmpty() to ensure that the FlexLine is non-empty before
+ // calling FirstItem() or LastItem().
+ FlexItem& FirstItem() { return mItems[0]; }
+ const FlexItem& FirstItem() const { return mItems[0]; }
+
+ FlexItem& LastItem() { return mItems.LastElement(); }
+ const FlexItem& LastItem() const { return mItems.LastElement(); }
+
+ bool IsEmpty() const { return mItems.IsEmpty(); }
+
+ uint32_t NumItems() const { return mItems.Length(); }
+
+ nsTArray<FlexItem>& Items() { return mItems; }
+ const nsTArray<FlexItem>& Items() const { return mItems; }
+
+ // Adds the last flex item's hypothetical outer main-size and
+ // margin/border/padding to our totals. This should be called exactly once for
+ // each flex item, after we've determined that this line is the correct home
+ // for that item.
+ void AddLastItemToMainSizeTotals() {
+ const FlexItem& lastItem = Items().LastElement();
+
+ // Update our various bookkeeping member-vars:
+ if (lastItem.IsFrozen()) {
+ mNumFrozenItems++;
+ }
+
+ mTotalItemMBP += lastItem.MarginBorderPaddingSizeInMainAxis();
+ mTotalOuterHypotheticalMainSize += lastItem.OuterMainSize();
+
+ // If the item added was not the first item in the line, we add in any gap
+ // space as needed.
+ if (NumItems() >= 2) {
+ mTotalOuterHypotheticalMainSize += mMainGapSize;
+ }
+ }
+
+ // Computes the cross-size and baseline position of this FlexLine, based on
+ // its FlexItems.
+ void ComputeCrossSizeAndBaseline(const FlexboxAxisTracker& aAxisTracker);
+
+ // Returns the cross-size of this line.
+ nscoord LineCrossSize() const { return mLineCrossSize; }
+
+ // Setter for line cross-size -- needed for cases where the flex container
+ // imposes a cross-size on the line. (e.g. for single-line flexbox, or for
+ // multi-line flexbox with 'align-content: stretch')
+ void SetLineCrossSize(nscoord aLineCrossSize) {
+ mLineCrossSize = aLineCrossSize;
+ }
+
+ /**
+ * Returns the offset within this line where any baseline-aligned FlexItems
+ * should place their baseline. The return value represents a distance from
+ * the line's cross-start edge.
+ *
+ * If there are no baseline-aligned FlexItems, returns nscoord_MIN.
+ */
+ nscoord FirstBaselineOffset() const { return mFirstBaselineOffset; }
+
+ /**
+ * Returns the offset within this line where any last baseline-aligned
+ * FlexItems should place their baseline. Opposite the case of the first
+ * baseline offset, this represents a distance from the line's cross-end
+ * edge (since last baseline-aligned items are flush to the cross-end edge).
+ * If we're internally reversing the axes, this instead represents the
+ * distance from the line's cross-start edge.
+ *
+ * If there are no last baseline-aligned FlexItems, returns nscoord_MIN.
+ */
+ nscoord LastBaselineOffset() const { return mLastBaselineOffset; }
+
+ /**
+ * Returns the gap size in the main axis for this line. Used for gap
+ * calculations.
+ */
+ nscoord MainGapSize() const { return mMainGapSize; }
+
+ // Runs the "Resolving Flexible Lengths" algorithm from section 9.7 of the
+ // CSS flexbox spec to distribute aFlexContainerMainSize among our flex items.
+ // https://drafts.csswg.org/css-flexbox-1/#resolve-flexible-lengths
+ void ResolveFlexibleLengths(nscoord aFlexContainerMainSize,
+ ComputedFlexLineInfo* aLineInfo);
+
+ void PositionItemsInMainAxis(const StyleContentDistribution& aJustifyContent,
+ nscoord aContentBoxMainSize,
+ const FlexboxAxisTracker& aAxisTracker);
+
+ void PositionItemsInCrossAxis(nscoord aLineStartPosition,
+ const FlexboxAxisTracker& aAxisTracker);
+
+ private:
+ // Helpers for ResolveFlexibleLengths():
+ void FreezeItemsEarly(bool aIsUsingFlexGrow, ComputedFlexLineInfo* aLineInfo);
+
+ void FreezeOrRestoreEachFlexibleSize(const nscoord aTotalViolation,
+ bool aIsFinalIteration);
+
+ // Stores this line's flex items.
+ nsTArray<FlexItem> mItems;
+
+ // Number of *frozen* FlexItems in this line, based on FlexItem::IsFrozen().
+ // Mostly used for optimization purposes, e.g. to bail out early from loops
+ // when we can tell they have nothing left to do.
+ uint32_t mNumFrozenItems = 0;
+
+ // Sum of margin/border/padding for the FlexItems in this FlexLine.
+ nscoord mTotalItemMBP = 0;
+
+ // Sum of FlexItems' outer hypothetical main sizes and all main-axis
+ // {row,columnm}-gaps between items.
+ // (i.e. their flex base sizes, clamped via their min/max-size properties,
+ // plus their main-axis margin/border/padding, plus the sum of the gaps.)
+ //
+ // This variable uses a 64-bit coord type to avoid integer overflow in case
+ // several of the individual items have huge hypothetical main sizes, which
+ // can happen with percent-width table-layout:fixed descendants. We have to
+ // avoid integer overflow in order to shrink items properly in that scenario.
+ AuCoord64 mTotalOuterHypotheticalMainSize = 0;
+
+ nscoord mLineCrossSize = 0;
+ nscoord mFirstBaselineOffset = nscoord_MIN;
+ nscoord mLastBaselineOffset = nscoord_MIN;
+
+ // Maintain size of each {row,column}-gap in the main axis
+ const nscoord mMainGapSize;
+};
+
+// Information about a strut left behind by a FlexItem that's been collapsed
+// using "visibility:collapse".
+struct nsFlexContainerFrame::StrutInfo {
+ StrutInfo(uint32_t aItemIdx, nscoord aStrutCrossSize)
+ : mItemIdx(aItemIdx), mStrutCrossSize(aStrutCrossSize) {}
+
+ uint32_t mItemIdx; // Index in the child list.
+ nscoord mStrutCrossSize; // The cross-size of this strut.
+};
+
+// Flex data shared by the flex container frames in a continuation chain, owned
+// by the first-in-flow. The data is initialized at the end of the
+// first-in-flow's Reflow().
+struct nsFlexContainerFrame::SharedFlexData final {
+ // The flex lines generated in DoFlexLayout() by our first-in-flow.
+ nsTArray<FlexLine> mLines;
+
+ // The final content main/cross size computed by DoFlexLayout.
+ nscoord mContentBoxMainSize = NS_UNCONSTRAINEDSIZE;
+ nscoord mContentBoxCrossSize = NS_UNCONSTRAINEDSIZE;
+
+ // Update this struct. Called by the first-in-flow.
+ void Update(FlexLayoutResult&& aFlr) {
+ mLines = std::move(aFlr.mLines);
+ mContentBoxMainSize = aFlr.mContentBoxMainSize;
+ mContentBoxCrossSize = aFlr.mContentBoxCrossSize;
+ }
+
+ // The frame property under which this struct is stored. Set only on the
+ // first-in-flow.
+ NS_DECLARE_FRAME_PROPERTY_DELETABLE(Prop, SharedFlexData)
+};
+
+// Flex data stored in every flex container's in-flow fragment (continuation).
+//
+// It's intended to prevent quadratic operations resulting from each fragment
+// having to walk its full prev-in-flow chain, and also serves as an argument to
+// the flex container next-in-flow's ReflowChildren(), to compute the position
+// offset for each flex item.
+struct nsFlexContainerFrame::PerFragmentFlexData final {
+ // Suppose D is the distance from a flex container fragment's content-box
+ // block-start edge to whichever is larger of either (a) the block-end edge of
+ // its children, or (b) the available space's block-end edge. (Note: in case
+ // (b), D is conceptually the sum of the block-size of the children, the
+ // packing space before & in between them, and part of the packing space after
+ // them.)
+ //
+ // This variable stores the sum of the D values for the current flex container
+ // fragments and for all its previous fragments
+ nscoord mCumulativeContentBoxBSize = 0;
+
+ // This variable accumulates FirstLineOrFirstItemBAxisMetrics::mBEndEdgeShift,
+ // for the current flex container fragment and for all its previous fragments.
+ // See the comment of mBEndEdgeShift for its computation details. In short,
+ // this value is the net block-end edge shift, accumulated for the children in
+ // all the previous fragments. This number is non-negative.
+ //
+ // This value is also used to grow a flex container's block-size if the
+ // container's computed block-size is unconstrained. For example: a tall item
+ // may be pushed to the next page/column, which leaves some wasted area at the
+ // bottom of the current flex container fragment, and causes the flex
+ // container fragments to be (collectively) larger than the hypothetical
+ // unfragmented size. Another example: a tall flex item may be broken into
+ // multiple fragments, and those fragments may have a larger collective
+ // block-size as compared to the item's original unfragmented size; the
+ // container would need to increase its block-size to account for this.
+ nscoord mCumulativeBEndEdgeShift = 0;
+
+ // The frame property under which this struct is stored. Cached on every
+ // in-flow fragment (continuation) at the end of the flex container's
+ // Reflow().
+ NS_DECLARE_FRAME_PROPERTY_DELETABLE(Prop, PerFragmentFlexData)
+};
+
+static void BuildStrutInfoFromCollapsedItems(const nsTArray<FlexLine>& aLines,
+ nsTArray<StrutInfo>& aStruts) {
+ MOZ_ASSERT(aStruts.IsEmpty(),
+ "We should only build up StrutInfo once per reflow, so "
+ "aStruts should be empty when this is called");
+
+ uint32_t itemIdxInContainer = 0;
+ for (const FlexLine& line : aLines) {
+ for (const FlexItem& item : line.Items()) {
+ if (item.Frame()->StyleVisibility()->IsCollapse()) {
+ // Note the cross size of the line as the item's strut size.
+ aStruts.AppendElement(
+ StrutInfo(itemIdxInContainer, line.LineCrossSize()));
+ }
+ itemIdxInContainer++;
+ }
+ }
+}
+
+static mozilla::StyleAlignFlags SimplifyAlignOrJustifyContentForOneItem(
+ const StyleContentDistribution& aAlignmentVal, bool aIsAlign) {
+ // Mask away any explicit fallback, to get the main (non-fallback) part of
+ // the specified value:
+ StyleAlignFlags specified = aAlignmentVal.primary;
+
+ // XXX strip off <overflow-position> bits until we implement it (bug 1311892)
+ specified &= ~StyleAlignFlags::FLAG_BITS;
+
+ // FIRST: handle a special-case for "justify-content:stretch" (or equivalent),
+ // which requires that we ignore any author-provided explicit fallback value.
+ if (specified == StyleAlignFlags::NORMAL) {
+ // In a flex container, *-content: "'normal' behaves as 'stretch'".
+ // Do that conversion early, so it benefits from our 'stretch' special-case.
+ // https://drafts.csswg.org/css-align-3/#distribution-flex
+ specified = StyleAlignFlags::STRETCH;
+ }
+ if (!aIsAlign && specified == StyleAlignFlags::STRETCH) {
+ // In a flex container, in "justify-content Axis: [...] 'stretch' behaves
+ // as 'flex-start' (ignoring the specified fallback alignment, if any)."
+ // https://drafts.csswg.org/css-align-3/#distribution-flex
+ // So, we just directly return 'flex-start', & ignore explicit fallback..
+ return StyleAlignFlags::FLEX_START;
+ }
+
+ // TODO: Check for an explicit fallback value (and if it's present, use it)
+ // here once we parse it, see https://github.com/w3c/csswg-drafts/issues/1002.
+
+ // If there's no explicit fallback, use the implied fallback values for
+ // space-{between,around,evenly} (since those values only make sense with
+ // multiple alignment subjects), and otherwise just use the specified value:
+ if (specified == StyleAlignFlags::SPACE_BETWEEN) {
+ return StyleAlignFlags::FLEX_START;
+ }
+ if (specified == StyleAlignFlags::SPACE_AROUND ||
+ specified == StyleAlignFlags::SPACE_EVENLY) {
+ return StyleAlignFlags::CENTER;
+ }
+ return specified;
+}
+
+bool nsFlexContainerFrame::DrainSelfOverflowList() {
+ return DrainAndMergeSelfOverflowList();
+}
+
+void nsFlexContainerFrame::AppendFrames(ChildListID aListID,
+ nsFrameList&& aFrameList) {
+ NoteNewChildren(aListID, aFrameList);
+ nsContainerFrame::AppendFrames(aListID, std::move(aFrameList));
+}
+
+void nsFlexContainerFrame::InsertFrames(
+ ChildListID aListID, nsIFrame* aPrevFrame,
+ const nsLineList::iterator* aPrevFrameLine, nsFrameList&& aFrameList) {
+ NoteNewChildren(aListID, aFrameList);
+ nsContainerFrame::InsertFrames(aListID, aPrevFrame, aPrevFrameLine,
+ std::move(aFrameList));
+}
+
+void nsFlexContainerFrame::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 nsFlexContainerFrame::CSSAlignmentForAbsPosChild(
+ const ReflowInput& aChildRI, LogicalAxis aLogicalAxis) const {
+ const FlexboxAxisTracker axisTracker(this);
+
+ // If we're row-oriented and the caller is asking about our inline axis (or
+ // alternately, if we're column-oriented and the caller is asking about our
+ // block axis), then the caller is really asking about our *main* axis.
+ // Otherwise, the caller is asking about our cross axis.
+ const bool isMainAxis =
+ (axisTracker.IsRowOriented() == (aLogicalAxis == eLogicalAxisInline));
+ const nsStylePosition* containerStylePos = StylePosition();
+ const bool isAxisReversed = isMainAxis ? axisTracker.IsMainAxisReversed()
+ : axisTracker.IsCrossAxisReversed();
+
+ StyleAlignFlags alignment{0};
+ StyleAlignFlags alignmentFlags{0};
+ if (isMainAxis) {
+ // We're aligning in the main axis: align according to 'justify-content'.
+ // (We don't care about justify-self; it has no effect on children of flex
+ // containers, unless https://github.com/w3c/csswg-drafts/issues/7644
+ // changes that.)
+ alignment = SimplifyAlignOrJustifyContentForOneItem(
+ containerStylePos->mJustifyContent,
+ /*aIsAlign = */ false);
+ } else {
+ // We're aligning in the cross axis: align according to 'align-self'.
+ // (We don't care about align-content; it has no effect on abspos flex
+ // children, per https://github.com/w3c/csswg-drafts/issues/7596 )
+ alignment = aChildRI.mStylePosition->UsedAlignSelf(Style())._0;
+ // Extract and strip align flag bits
+ 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
+ alignment = aChildRI.mFrame->IsFrameOfType(nsIFrame::eReplaced)
+ ? StyleAlignFlags::START
+ : StyleAlignFlags::STRETCH;
+ }
+ }
+
+ if (alignment == StyleAlignFlags::STRETCH) {
+ // The default fallback alignment for 'stretch' is 'flex-start'.
+ alignment = StyleAlignFlags::FLEX_START;
+ }
+
+ // Resolve flex-start, flex-end, auto, left, right, baseline, last baseline;
+ if (alignment == StyleAlignFlags::FLEX_START) {
+ alignment = isAxisReversed ? StyleAlignFlags::END : StyleAlignFlags::START;
+ } else if (alignment == StyleAlignFlags::FLEX_END) {
+ alignment = isAxisReversed ? StyleAlignFlags::START : StyleAlignFlags::END;
+ } else if (alignment == StyleAlignFlags::LEFT ||
+ alignment == StyleAlignFlags::RIGHT) {
+ MOZ_ASSERT(isMainAxis, "Only justify-* can have 'left' and 'right'!");
+ alignment = axisTracker.ResolveJustifyLeftRight(alignment);
+ } else if (alignment == StyleAlignFlags::BASELINE) {
+ alignment = StyleAlignFlags::START;
+ } else if (alignment == StyleAlignFlags::LAST_BASELINE) {
+ alignment = StyleAlignFlags::END;
+ }
+
+ MOZ_ASSERT(alignment != StyleAlignFlags::STRETCH,
+ "We should've converted 'stretch' to the fallback alignment!");
+ MOZ_ASSERT(alignment != StyleAlignFlags::FLEX_START &&
+ alignment != StyleAlignFlags::FLEX_END,
+ "nsAbsoluteContainingBlock doesn't know how to handle "
+ "flex-relative axis for flex containers!");
+
+ return (alignment | alignmentFlags);
+}
+
+void nsFlexContainerFrame::GenerateFlexItemForChild(
+ FlexLine& aLine, nsIFrame* aChildFrame,
+ const ReflowInput& aParentReflowInput,
+ const FlexboxAxisTracker& aAxisTracker,
+ const nscoord aTentativeContentBoxCrossSize) {
+ const auto flexWM = aAxisTracker.GetWritingMode();
+ const auto childWM = aChildFrame->GetWritingMode();
+
+ // Note: we use GetStyleFrame() to access the sizing & flex properties here.
+ // This lets us correctly handle table wrapper frames as flex items since
+ // their inline-size and block-size properties are always 'auto'. In order for
+ // 'flex-basis:auto' to actually resolve to the author's specified inline-size
+ // or block-size, we need to dig through to the inner table.
+ const auto* stylePos =
+ nsLayoutUtils::GetStyleFrame(aChildFrame)->StylePosition();
+
+ // Construct a StyleSizeOverrides for this flex item so that its ReflowInput
+ // below will use and resolve its flex base size rather than its corresponding
+ // preferred main size property (only for modern CSS flexbox).
+ StyleSizeOverrides sizeOverrides;
+ if (!IsLegacyBox(this)) {
+ Maybe<StyleSize> styleFlexBaseSize;
+
+ // When resolving flex base size, flex items use their 'flex-basis' property
+ // in place of their preferred main size (e.g. 'width') for sizing purposes,
+ // *unless* they have 'flex-basis:auto' in which case they use their
+ // preferred main size after all.
+ const auto& flexBasis = stylePos->mFlexBasis;
+ const auto& styleMainSize = stylePos->Size(aAxisTracker.MainAxis(), flexWM);
+ if (IsUsedFlexBasisContent(flexBasis, styleMainSize)) {
+ // If we get here, we're resolving the flex base size for a flex item, and
+ // we fall into the flexbox spec section 9.2 step 3, substep C (if we have
+ // a definite cross size) or E (if not).
+ styleFlexBaseSize.emplace(StyleSize::MaxContent());
+ } else if (flexBasis.IsSize() && !flexBasis.IsAuto()) {
+ // For all other non-'auto' flex-basis values, we just swap in the
+ // flex-basis itself for the preferred main-size property.
+ styleFlexBaseSize.emplace(flexBasis.AsSize());
+ } else {
+ // else: flex-basis is 'auto', which is deferring to some explicit value
+ // in the preferred main size.
+ MOZ_ASSERT(flexBasis.IsAuto());
+ styleFlexBaseSize.emplace(styleMainSize);
+ }
+
+ MOZ_ASSERT(styleFlexBaseSize, "We should've emplace styleFlexBaseSize!");
+
+ // Provide the size override for the preferred main size property.
+ if (aAxisTracker.IsInlineAxisMainAxis(childWM)) {
+ sizeOverrides.mStyleISize = std::move(styleFlexBaseSize);
+ } else {
+ sizeOverrides.mStyleBSize = std::move(styleFlexBaseSize);
+ }
+
+ // 'flex-basis' should works on the inner table frame for a table flex item,
+ // just like how 'height' works on a table element.
+ sizeOverrides.mApplyOverridesVerbatim = true;
+ }
+
+ // Create temporary reflow input just for sizing -- to get hypothetical
+ // main-size and the computed values of min / max main-size property.
+ // (This reflow input will _not_ be used for reflow.)
+ ReflowInput childRI(PresContext(), aParentReflowInput, aChildFrame,
+ aParentReflowInput.ComputedSize(childWM), Nothing(), {},
+ sizeOverrides);
+
+ // FLEX GROW & SHRINK WEIGHTS
+ // --------------------------
+ float flexGrow, flexShrink;
+ if (IsLegacyBox(this)) {
+ flexGrow = flexShrink = aChildFrame->StyleXUL()->mBoxFlex;
+ } else {
+ flexGrow = stylePos->mFlexGrow;
+ flexShrink = stylePos->mFlexShrink;
+ }
+
+ // MAIN SIZES (flex base size, min/max size)
+ // -----------------------------------------
+ const LogicalSize computedSizeInFlexWM = childRI.ComputedSize(flexWM);
+ const LogicalSize computedMinSizeInFlexWM = childRI.ComputedMinSize(flexWM);
+ const LogicalSize computedMaxSizeInFlexWM = childRI.ComputedMaxSize(flexWM);
+
+ const nscoord flexBaseSize = aAxisTracker.MainComponent(computedSizeInFlexWM);
+ const nscoord mainMinSize =
+ aAxisTracker.MainComponent(computedMinSizeInFlexWM);
+ const nscoord mainMaxSize =
+ aAxisTracker.MainComponent(computedMaxSizeInFlexWM);
+
+ // This is enforced by the ReflowInput where these values come from:
+ MOZ_ASSERT(mainMinSize <= mainMaxSize, "min size is larger than max size");
+
+ // CROSS SIZES (tentative cross size, min/max cross size)
+ // ------------------------------------------------------
+ // Grab the cross size from the reflow input. This might be the right value,
+ // or we might resolve it to something else in SizeItemInCrossAxis(); hence,
+ // it's tentative. See comment under "Cross Size Determination" for more.
+ const nscoord tentativeCrossSize =
+ aAxisTracker.CrossComponent(computedSizeInFlexWM);
+ const nscoord crossMinSize =
+ aAxisTracker.CrossComponent(computedMinSizeInFlexWM);
+ const nscoord crossMaxSize =
+ aAxisTracker.CrossComponent(computedMaxSizeInFlexWM);
+
+ // Construct the flex item!
+ FlexItem& item = *aLine.Items().EmplaceBack(
+ childRI, flexGrow, flexShrink, flexBaseSize, mainMinSize, mainMaxSize,
+ tentativeCrossSize, crossMinSize, crossMaxSize, aAxisTracker);
+
+ // We may be about to do computations based on our item's cross-size
+ // (e.g. using it as a constraint when measuring our content in the
+ // main axis, or using it with the preferred aspect ratio to obtain a main
+ // size). BEFORE WE DO THAT, we need let the item "pre-stretch" its cross size
+ // (if it's got 'align-self:stretch'), for a certain case where the spec says
+ // the stretched cross size is considered "definite". That case is if we
+ // have a single-line (nowrap) flex container which itself has a definite
+ // cross-size. Otherwise, we'll wait to do stretching, since (in other
+ // cases) we don't know how much the item should stretch yet.
+ const bool isSingleLine =
+ StyleFlexWrap::Nowrap == aParentReflowInput.mStylePosition->mFlexWrap;
+ if (isSingleLine) {
+ // Is container's cross size "definite"?
+ // - If it's column-oriented, then "yes", because its cross size is its
+ // inline-size which is always definite from its descendants' perspective.
+ // - Otherwise (if it's row-oriented), then we check the actual size
+ // and call it definite if it's not NS_UNCONSTRAINEDSIZE.
+ if (aAxisTracker.IsColumnOriented() ||
+ aTentativeContentBoxCrossSize != NS_UNCONSTRAINEDSIZE) {
+ // Container's cross size is "definite", so we can resolve the item's
+ // stretched cross size using that.
+ item.ResolveStretchedCrossSize(aTentativeContentBoxCrossSize);
+ }
+ }
+
+ // Before thinking about freezing the item at its base size, we need to give
+ // it a chance to recalculate the base size from its cross size and aspect
+ // ratio (since its cross size might've *just* now become definite due to
+ // 'stretch' above)
+ item.ResolveFlexBaseSizeFromAspectRatio(childRI);
+
+ // If we're inflexible, we can just freeze to our hypothetical main-size
+ // up-front.
+ if (flexGrow == 0.0f && flexShrink == 0.0f) {
+ item.Freeze();
+ if (flexBaseSize < mainMinSize) {
+ item.SetWasMinClamped();
+ } else if (flexBaseSize > mainMaxSize) {
+ item.SetWasMaxClamped();
+ }
+ }
+
+ // Resolve "flex-basis:auto" and/or "min-[width|height]:auto" (which might
+ // require us to reflow the item to measure content height)
+ ResolveAutoFlexBasisAndMinSize(item, childRI, aAxisTracker);
+}
+
+// Static helper-functions for ResolveAutoFlexBasisAndMinSize():
+// -------------------------------------------------------------
+// Partially resolves "min-[width|height]:auto" and returns the resulting value.
+// By "partially", I mean we don't consider the min-content size (but we do
+// consider the main-size and main max-size properties, and the preferred aspect
+// ratio). The caller is responsible for computing & considering the min-content
+// size in combination with the partially-resolved value that this function
+// returns.
+//
+// Basically, this function gets the specified size suggestion; if not, the
+// transferred size suggestion; if both sizes do not exist, return nscoord_MAX.
+//
+// Spec reference: https://drafts.csswg.org/css-flexbox-1/#min-size-auto
+static nscoord PartiallyResolveAutoMinSize(
+ const FlexItem& aFlexItem, const ReflowInput& aItemReflowInput,
+ const FlexboxAxisTracker& aAxisTracker) {
+ MOZ_ASSERT(aFlexItem.NeedsMinSizeAutoResolution(),
+ "only call for FlexItems that need min-size auto resolution");
+
+ const auto itemWM = aFlexItem.GetWritingMode();
+ const auto cbWM = aAxisTracker.GetWritingMode();
+ const auto& mainStyleSize =
+ aItemReflowInput.mStylePosition->Size(aAxisTracker.MainAxis(), cbWM);
+ const auto& maxMainStyleSize =
+ aItemReflowInput.mStylePosition->MaxSize(aAxisTracker.MainAxis(), cbWM);
+ const auto boxSizingAdjust =
+ aItemReflowInput.mStylePosition->mBoxSizing == StyleBoxSizing::Border
+ ? aFlexItem.BorderPadding().Size(cbWM)
+ : LogicalSize(cbWM);
+
+ // If this flex item is a compressible replaced element list in CSS Sizing 3
+ // §5.2.2, CSS Sizing 3 §5.2.1c requires us to resolve the percentage part of
+ // the preferred main size property against zero, yielding a definite
+ // specified size suggestion. Here we can use a zero percentage basis to
+ // fulfill this requirement.
+ const auto percentBasis =
+ aFlexItem.Frame()->IsPercentageResolvedAgainstZero(mainStyleSize,
+ maxMainStyleSize)
+ ? LogicalSize(cbWM, 0, 0)
+ : aItemReflowInput.mContainingBlockSize.ConvertTo(cbWM, itemWM);
+
+ // Compute the specified size suggestion, which is the main-size property if
+ // it's definite.
+ nscoord specifiedSizeSuggestion = nscoord_MAX;
+
+ if (aAxisTracker.IsRowOriented()) {
+ if (mainStyleSize.IsLengthPercentage()) {
+ // NOTE: We ignore extremum inline-size. This is OK because the caller is
+ // responsible for computing the min-content inline-size and min()'ing it
+ // with the value we return.
+ specifiedSizeSuggestion = aFlexItem.Frame()->ComputeISizeValue(
+ cbWM, percentBasis, boxSizingAdjust,
+ mainStyleSize.AsLengthPercentage());
+ }
+ } else {
+ if (!nsLayoutUtils::IsAutoBSize(mainStyleSize, percentBasis.BSize(cbWM))) {
+ // NOTE: We ignore auto and extremum block-size. This is OK because the
+ // caller is responsible for computing the min-content block-size and
+ // min()'ing it with the value we return.
+ specifiedSizeSuggestion = nsLayoutUtils::ComputeBSizeValue(
+ percentBasis.BSize(cbWM), boxSizingAdjust.BSize(cbWM),
+ mainStyleSize.AsLengthPercentage());
+ }
+ }
+
+ if (specifiedSizeSuggestion != nscoord_MAX) {
+ // We have the specified size suggestion. Return it now since we don't need
+ // to consider transferred size suggestion.
+ FLEX_LOGV(" Specified size suggestion: %d", specifiedSizeSuggestion);
+ return specifiedSizeSuggestion;
+ }
+
+ // Compute the transferred size suggestion, which is the cross size converted
+ // through the aspect ratio (if the item is replaced, and it has an aspect
+ // ratio and a definite cross size).
+ if (const auto& aspectRatio = aFlexItem.GetAspectRatio();
+ aFlexItem.Frame()->IsFrameOfType(nsIFrame::eReplaced) && aspectRatio &&
+ aFlexItem.IsCrossSizeDefinite(aItemReflowInput)) {
+ // We have a usable aspect ratio. (not going to divide by 0)
+ nscoord transferredSizeSuggestion = aspectRatio.ComputeRatioDependentSize(
+ aFlexItem.MainAxis(), cbWM, aFlexItem.CrossSize(), boxSizingAdjust);
+
+ // Clamp the transferred size suggestion by any definite min and max
+ // cross size converted through the aspect ratio.
+ transferredSizeSuggestion = aFlexItem.ClampMainSizeViaCrossAxisConstraints(
+ transferredSizeSuggestion, aItemReflowInput);
+
+ FLEX_LOGV(" Transferred size suggestion: %d", transferredSizeSuggestion);
+ return transferredSizeSuggestion;
+ }
+
+ return nscoord_MAX;
+}
+
+// Note: If & when we handle "min-height: min-content" for flex items,
+// we may want to resolve that in this function, too.
+void nsFlexContainerFrame::ResolveAutoFlexBasisAndMinSize(
+ FlexItem& aFlexItem, const ReflowInput& aItemReflowInput,
+ const FlexboxAxisTracker& aAxisTracker) {
+ // (Note: We can guarantee that the flex-basis will have already been
+ // resolved if the main axis is the same as the item's inline
+ // axis. Inline-axis values should always be resolvable without reflow.)
+ const bool isMainSizeAuto =
+ (!aFlexItem.IsInlineAxisMainAxis() &&
+ NS_UNCONSTRAINEDSIZE == aFlexItem.FlexBaseSize());
+
+ const bool isMainMinSizeAuto = aFlexItem.NeedsMinSizeAutoResolution();
+
+ if (!isMainSizeAuto && !isMainMinSizeAuto) {
+ // Nothing to do; this function is only needed for flex items
+ // with a used flex-basis of "auto" or a min-main-size of "auto".
+ return;
+ }
+
+ FLEX_LOGV("Resolving auto main size or auto min main size for flex item %p",
+ aFlexItem.Frame());
+
+ nscoord resolvedMinSize; // (only set/used if isMainMinSizeAuto==true)
+ bool minSizeNeedsToMeasureContent = false; // assume the best
+ if (isMainMinSizeAuto) {
+ // Resolve the min-size, except for considering the min-content size.
+ // (We'll consider that later, if we need to.)
+ resolvedMinSize =
+ PartiallyResolveAutoMinSize(aFlexItem, aItemReflowInput, aAxisTracker);
+ if (resolvedMinSize > 0) {
+ // If resolvedMinSize were already at 0, we could skip calculating content
+ // size suggestion because it can't go any lower.
+ minSizeNeedsToMeasureContent = true;
+ }
+ }
+
+ const bool flexBasisNeedsToMeasureContent = isMainSizeAuto;
+
+ // Measure content, if needed (w/ intrinsic-width method or a reflow)
+ if (minSizeNeedsToMeasureContent || flexBasisNeedsToMeasureContent) {
+ // Compute the content size suggestion, which is the min-content size in the
+ // main axis.
+ nscoord contentSizeSuggestion = nscoord_MAX;
+
+ if (aFlexItem.IsInlineAxisMainAxis()) {
+ if (minSizeNeedsToMeasureContent) {
+ // Compute the flex item's content size suggestion, which is the
+ // 'min-content' size on the main axis.
+ // https://drafts.csswg.org/css-flexbox-1/#content-size-suggestion
+ const auto cbWM = aAxisTracker.GetWritingMode();
+ const auto itemWM = aFlexItem.GetWritingMode();
+ const nscoord availISize = 0; // for min-content size
+ StyleSizeOverrides sizeOverrides;
+ sizeOverrides.mStyleISize.emplace(StyleSize::Auto());
+ const auto sizeInItemWM = aFlexItem.Frame()->ComputeSize(
+ aItemReflowInput.mRenderingContext, itemWM,
+ aItemReflowInput.mContainingBlockSize, availISize,
+ aItemReflowInput.ComputedLogicalMargin(itemWM).Size(itemWM),
+ aItemReflowInput.ComputedLogicalBorderPadding(itemWM).Size(itemWM),
+ sizeOverrides, {ComputeSizeFlag::ShrinkWrap});
+
+ contentSizeSuggestion = aAxisTracker.MainComponent(
+ sizeInItemWM.mLogicalSize.ConvertTo(cbWM, itemWM));
+ }
+ NS_ASSERTION(!flexBasisNeedsToMeasureContent,
+ "flex-basis:auto should have been resolved in the "
+ "reflow input, for horizontal flexbox. It shouldn't need "
+ "special handling here");
+ } else {
+ // If this item is flexible (in its block axis)...
+ // OR if we're measuring its 'auto' min-BSize, with its main-size (in its
+ // block axis) being something non-"auto"...
+ // THEN: we assume that the computed BSize that we're reflowing with now
+ // could be different from the one we'll use for this flex item's
+ // "actual" reflow later on. In that case, we need to be sure the flex
+ // item treats this as a block-axis resize (regardless of whether there
+ // are actually any ancestors being resized in that axis).
+ // (Note: We don't have to do this for the inline axis, because
+ // InitResizeFlags will always turn on mIsIResize on when it sees that
+ // the computed ISize is different from current ISize, and that's all we
+ // need.)
+ bool forceBResizeForMeasuringReflow =
+ !aFlexItem.IsFrozen() || // Is the item flexible?
+ !flexBasisNeedsToMeasureContent; // Are we *only* measuring it for
+ // 'min-block-size:auto'?
+
+ const ReflowInput& flexContainerRI = *aItemReflowInput.mParentReflowInput;
+ nscoord contentBSize = MeasureFlexItemContentBSize(
+ aFlexItem, forceBResizeForMeasuringReflow, flexContainerRI);
+ if (minSizeNeedsToMeasureContent) {
+ contentSizeSuggestion = contentBSize;
+ }
+ if (flexBasisNeedsToMeasureContent) {
+ aFlexItem.SetFlexBaseSizeAndMainSize(contentBSize);
+ }
+ }
+
+ if (minSizeNeedsToMeasureContent) {
+ // Clamp the content size suggestion by any definite min and max cross
+ // size converted through the aspect ratio.
+ if (aFlexItem.HasAspectRatio()) {
+ contentSizeSuggestion = aFlexItem.ClampMainSizeViaCrossAxisConstraints(
+ contentSizeSuggestion, aItemReflowInput);
+ }
+
+ FLEX_LOGV(" Content size suggestion: %d", contentSizeSuggestion);
+ resolvedMinSize = std::min(resolvedMinSize, contentSizeSuggestion);
+
+ // Clamp the resolved min main size by the max main size if it's definite.
+ if (aFlexItem.MainMaxSize() != NS_UNCONSTRAINEDSIZE) {
+ resolvedMinSize = std::min(resolvedMinSize, aFlexItem.MainMaxSize());
+ } else if (MOZ_UNLIKELY(resolvedMinSize > nscoord_MAX)) {
+ NS_WARNING("Bogus resolved auto min main size!");
+ // Our resolved min-size is bogus, probably due to some huge sizes in
+ // the content. Clamp it to the valid nscoord range, so that we can at
+ // least depend on it being <= the max-size (which is also the
+ // nscoord_MAX sentinel value if we reach this point).
+ resolvedMinSize = nscoord_MAX;
+ }
+ FLEX_LOGV(" Resolved auto min main size: %d", resolvedMinSize);
+ }
+ }
+
+ if (isMainMinSizeAuto) {
+ aFlexItem.UpdateMainMinSize(resolvedMinSize);
+ }
+}
+
+/**
+ * A cached result for a flex item's block-axis measuring reflow. This cache
+ * prevents us from doing exponential reflows in cases of deeply nested flex
+ * and scroll frames.
+ *
+ * We store the cached value in the flex item's frame property table, for
+ * simplicity.
+ *
+ * Right now, we cache the following as a "key", from the item's ReflowInput:
+ * - its ComputedSize
+ * - its min/max block size (in case its ComputedBSize is unconstrained)
+ * - its AvailableBSize
+ * ...and we cache the following as the "value", from the item's ReflowOutput:
+ * - its final content-box BSize
+ *
+ * The assumption here is that a given flex item measurement from our "value"
+ * won't change unless one of the pieces of the "key" change, or the flex
+ * item's intrinsic size is marked as dirty (due to a style or DOM change).
+ * (The latter will cause the cached value to be discarded, in
+ * nsIFrame::MarkIntrinsicISizesDirty.)
+ *
+ * Note that the components of "Key" (mComputed{MinB,MaxB,}Size and
+ * mAvailableBSize) are sufficient to catch any changes to the flex container's
+ * size that the item may care about for its measuring reflow. Specifically:
+ * - If the item cares about the container's size (e.g. if it has a percent
+ * height and the container's height changes, in a horizontal-WM container)
+ * then that'll be detectable via the item's ReflowInput's "ComputedSize()"
+ * differing from the value in our Key. And the same applies for the
+ * inline axis.
+ * - If the item is fragmentable (pending bug 939897) and its measured BSize
+ * depends on where it gets fragmented, then that sort of change can be
+ * detected due to the item's ReflowInput's "AvailableBSize()" differing
+ * from the value in our Key.
+ *
+ * One particular case to consider (& need to be sure not to break when
+ * changing this class): the flex item's computed BSize may change between
+ * measuring reflows due to how the mIsFlexContainerMeasuringBSize flag affects
+ * size computation (see bug 1336708). This is one reason we need to use the
+ * computed BSize as part of the key.
+ */
+class nsFlexContainerFrame::CachedBAxisMeasurement {
+ struct Key {
+ const LogicalSize mComputedSize;
+ const nscoord mComputedMinBSize;
+ const nscoord mComputedMaxBSize;
+ const nscoord mAvailableBSize;
+
+ explicit Key(const ReflowInput& aRI)
+ : mComputedSize(aRI.ComputedSize()),
+ mComputedMinBSize(aRI.ComputedMinBSize()),
+ mComputedMaxBSize(aRI.ComputedMaxBSize()),
+ mAvailableBSize(aRI.AvailableBSize()) {}
+
+ bool operator==(const Key& aOther) const {
+ return mComputedSize == aOther.mComputedSize &&
+ mComputedMinBSize == aOther.mComputedMinBSize &&
+ mComputedMaxBSize == aOther.mComputedMaxBSize &&
+ mAvailableBSize == aOther.mAvailableBSize;
+ }
+ };
+
+ const Key mKey;
+
+ // This could/should be const, but it's non-const for now just because it's
+ // assigned via a series of steps in the constructor body:
+ nscoord mBSize;
+
+ public:
+ CachedBAxisMeasurement(const ReflowInput& aReflowInput,
+ const ReflowOutput& aReflowOutput)
+ : mKey(aReflowInput) {
+ // To get content-box bsize, we have to subtract off border & padding
+ // (and floor at 0 in case the border/padding are too large):
+ WritingMode itemWM = aReflowInput.GetWritingMode();
+ nscoord borderBoxBSize = aReflowOutput.BSize(itemWM);
+ mBSize =
+ borderBoxBSize -
+ aReflowInput.ComputedLogicalBorderPadding(itemWM).BStartEnd(itemWM);
+ mBSize = std::max(0, mBSize);
+ }
+
+ /**
+ * Returns true if this cached flex item measurement is valid for (i.e. can
+ * be expected to match the output of) a measuring reflow whose input
+ * parameters are given via aReflowInput.
+ */
+ bool IsValidFor(const ReflowInput& aReflowInput) const {
+ return mKey == Key(aReflowInput);
+ }
+
+ nscoord BSize() const { return mBSize; }
+};
+
+/**
+ * A cached copy of various metrics from a flex item's most recent final reflow.
+ * It can be used to determine whether we can optimize away the flex item's
+ * final reflow, when we perform an incremental reflow of its flex container.
+ */
+class CachedFinalReflowMetrics final {
+ public:
+ CachedFinalReflowMetrics(const ReflowInput& aReflowInput,
+ const ReflowOutput& aReflowOutput)
+ : CachedFinalReflowMetrics(aReflowInput.GetWritingMode(), aReflowInput,
+ aReflowOutput) {}
+
+ CachedFinalReflowMetrics(const FlexItem& aItem, const LogicalSize& aSize)
+ : mBorderPadding(aItem.BorderPadding().ConvertTo(
+ aItem.GetWritingMode(), aItem.ContainingBlockWM())),
+ mSize(aSize),
+ mTreatBSizeAsIndefinite(aItem.TreatBSizeAsIndefinite()) {}
+
+ const LogicalSize& Size() const { return mSize; }
+ const LogicalMargin& BorderPadding() const { return mBorderPadding; }
+ bool TreatBSizeAsIndefinite() const { return mTreatBSizeAsIndefinite; }
+
+ private:
+ // A convenience constructor with a WritingMode argument.
+ CachedFinalReflowMetrics(WritingMode aWM, const ReflowInput& aReflowInput,
+ const ReflowOutput& aReflowOutput)
+ : mBorderPadding(aReflowInput.ComputedLogicalBorderPadding(aWM)),
+ mSize(aReflowOutput.Size(aWM) - mBorderPadding.Size(aWM)),
+ mTreatBSizeAsIndefinite(aReflowInput.mFlags.mTreatBSizeAsIndefinite) {}
+
+ // The flex item's border and padding, in its own writing-mode, that it used
+ // used during its most recent "final reflow".
+ LogicalMargin mBorderPadding;
+
+ // The flex item's content-box size, in its own writing-mode, that it used
+ // during its most recent "final reflow".
+ LogicalSize mSize;
+
+ // True if the flex item's BSize was considered "indefinite" in its most
+ // recent "final reflow". (For a flex item "final reflow", this is fully
+ // determined by the mTreatBSizeAsIndefinite flag in ReflowInput. See the
+ // flag's documentation for more information.)
+ bool mTreatBSizeAsIndefinite;
+};
+
+/**
+ * When we instantiate/update a CachedFlexItemData, this enum must be used to
+ * indicate the sort of reflow whose results we're capturing. This impacts
+ * what we cache & how we use the cached information.
+ */
+enum class FlexItemReflowType {
+ // A reflow to measure the block-axis size of a flex item (as an input to the
+ // flex layout algorithm).
+ Measuring,
+
+ // A reflow with the flex item's "final" size at the end of the flex layout
+ // algorithm.
+ Final,
+};
+
+/**
+ * This class stores information about the conditions and results for the most
+ * recent ReflowChild call that we made on a given flex item. This information
+ * helps us reason about whether we can assume that a subsequent ReflowChild()
+ * invocation is unnecessary & skippable.
+ */
+class nsFlexContainerFrame::CachedFlexItemData {
+ public:
+ CachedFlexItemData(const ReflowInput& aReflowInput,
+ const ReflowOutput& aReflowOutput,
+ FlexItemReflowType aType) {
+ Update(aReflowInput, aReflowOutput, aType);
+ }
+
+ // This method is intended to be called after we perform either a "measuring
+ // reflow" or a "final reflow" for a given flex item.
+ void Update(const ReflowInput& aReflowInput,
+ const ReflowOutput& aReflowOutput, FlexItemReflowType aType) {
+ if (aType == FlexItemReflowType::Measuring) {
+ mBAxisMeasurement.reset();
+ mBAxisMeasurement.emplace(aReflowInput, aReflowOutput);
+ // Clear any cached "last final reflow metrics", too, because now the most
+ // recent reflow was *not* a "final reflow".
+ mFinalReflowMetrics.reset();
+ return;
+ }
+
+ MOZ_ASSERT(aType == FlexItemReflowType::Final);
+ mFinalReflowMetrics.reset();
+ mFinalReflowMetrics.emplace(aReflowInput, aReflowOutput);
+ }
+
+ // This method is intended to be called for situations where we decide to
+ // skip a final reflow because we've just done a measuring reflow which left
+ // us (and our descendants) with the correct sizes. In this scenario, we
+ // still want to cache the size as if we did a final reflow (because we've
+ // determined that the recent measuring reflow was sufficient). That way,
+ // our flex container can still skip a final reflow for this item in the
+ // future as long as conditions are right.
+ void Update(const FlexItem& aItem, const LogicalSize& aSize) {
+ MOZ_ASSERT(!mFinalReflowMetrics,
+ "This version of the method is only intended to be called when "
+ "the most recent reflow was a 'measuring reflow'; and that "
+ "should have cleared out mFinalReflowMetrics");
+
+ mFinalReflowMetrics.reset(); // Just in case this assert^ fails.
+ mFinalReflowMetrics.emplace(aItem, aSize);
+ }
+
+ // If the flex container needs a measuring reflow for the flex item, then the
+ // resulting block-axis measurements can be cached here. If no measurement
+ // has been needed so far, then this member will be Nothing().
+ Maybe<CachedBAxisMeasurement> mBAxisMeasurement;
+
+ // The metrics that the corresponding flex item used in its most recent
+ // "final reflow". (Note: the assumption here is that this reflow was this
+ // item's most recent reflow of any type. If the item ends up undergoing a
+ // subsequent measuring reflow, then this value needs to be cleared, because
+ // at that point it's no longer an accurate way of reasoning about the
+ // current state of the frame tree.)
+ Maybe<CachedFinalReflowMetrics> mFinalReflowMetrics;
+
+ // Instances of this class are stored under this frame property, on
+ // frames that are flex items:
+ NS_DECLARE_FRAME_PROPERTY_DELETABLE(Prop, CachedFlexItemData)
+};
+
+void nsFlexContainerFrame::MarkCachedFlexMeasurementsDirty(
+ nsIFrame* aItemFrame) {
+ MOZ_ASSERT(aItemFrame->IsFlexItem());
+ if (auto* cache = aItemFrame->GetProperty(CachedFlexItemData::Prop())) {
+ cache->mBAxisMeasurement.reset();
+ cache->mFinalReflowMetrics.reset();
+ }
+}
+
+const CachedBAxisMeasurement& nsFlexContainerFrame::MeasureBSizeForFlexItem(
+ FlexItem& aItem, ReflowInput& aChildReflowInput) {
+ auto* cachedData = aItem.Frame()->GetProperty(CachedFlexItemData::Prop());
+
+ if (cachedData && cachedData->mBAxisMeasurement) {
+ if (!aItem.Frame()->IsSubtreeDirty() &&
+ cachedData->mBAxisMeasurement->IsValidFor(aChildReflowInput)) {
+ FLEX_LOG("[perf] MeasureBSizeForFlexItem accepted cached value");
+ return *(cachedData->mBAxisMeasurement);
+ }
+ FLEX_LOG("[perf] MeasureBSizeForFlexItem rejected cached value");
+ } else {
+ FLEX_LOG("[perf] MeasureBSizeForFlexItem didn't have a cached value");
+ }
+
+ // CachedFlexItemData is stored in item's writing mode, so we pass
+ // aChildReflowInput into ReflowOutput's constructor.
+ ReflowOutput childReflowOutput(aChildReflowInput);
+ nsReflowStatus childReflowStatus;
+
+ const ReflowChildFlags flags = ReflowChildFlags::NoMoveFrame;
+ const WritingMode outerWM = GetWritingMode();
+ const LogicalPoint dummyPosition(outerWM);
+ const nsSize dummyContainerSize;
+
+ // We use NoMoveFrame, so the position and container size used here are
+ // unimportant.
+ ReflowChild(aItem.Frame(), PresContext(), childReflowOutput,
+ aChildReflowInput, outerWM, dummyPosition, dummyContainerSize,
+ flags, childReflowStatus);
+ aItem.SetHadMeasuringReflow();
+
+ // We always use unconstrained available block-size to measure flex items,
+ // which means they should always complete.
+ MOZ_ASSERT(childReflowStatus.IsComplete(),
+ "We gave flex item unconstrained available block-size, so it "
+ "should be complete");
+
+ // Tell the child we're done with its initial reflow.
+ // (Necessary for e.g. GetBaseline() to work below w/out asserting)
+ FinishReflowChild(aItem.Frame(), PresContext(), childReflowOutput,
+ &aChildReflowInput, outerWM, dummyPosition,
+ dummyContainerSize, flags);
+
+ aItem.SetAscent(childReflowOutput.BlockStartAscent());
+
+ // Update (or add) our cached measurement, so that we can hopefully skip this
+ // measuring reflow the next time around:
+ if (cachedData) {
+ cachedData->Update(aChildReflowInput, childReflowOutput,
+ FlexItemReflowType::Measuring);
+ } else {
+ cachedData = new CachedFlexItemData(aChildReflowInput, childReflowOutput,
+ FlexItemReflowType::Measuring);
+ aItem.Frame()->SetProperty(CachedFlexItemData::Prop(), cachedData);
+ }
+ return *(cachedData->mBAxisMeasurement);
+}
+
+/* virtual */
+void nsFlexContainerFrame::MarkIntrinsicISizesDirty() {
+ mCachedMinISize = NS_INTRINSIC_ISIZE_UNKNOWN;
+ mCachedPrefISize = NS_INTRINSIC_ISIZE_UNKNOWN;
+
+ nsContainerFrame::MarkIntrinsicISizesDirty();
+}
+
+nscoord nsFlexContainerFrame::MeasureFlexItemContentBSize(
+ FlexItem& aFlexItem, bool aForceBResizeForMeasuringReflow,
+ const ReflowInput& aParentReflowInput) {
+ FLEX_LOG("Measuring flex item's content block-size");
+
+ // Set up a reflow input for measuring the flex item's content block-size:
+ WritingMode wm = aFlexItem.Frame()->GetWritingMode();
+ LogicalSize availSize = aParentReflowInput.ComputedSize(wm);
+ availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
+
+ StyleSizeOverrides sizeOverrides;
+ if (aFlexItem.IsStretched()) {
+ sizeOverrides.mStyleISize.emplace(aFlexItem.StyleCrossSize());
+ // Suppress any AspectRatio that we might have to prevent ComputeSize() from
+ // transferring our inline-size override through the aspect-ratio to set the
+ // block-size, because that would prevent us from measuring the content
+ // block-size.
+ sizeOverrides.mAspectRatio.emplace(AspectRatio());
+ FLEX_LOGV(" Cross size override: %d", aFlexItem.CrossSize());
+ }
+ sizeOverrides.mStyleBSize.emplace(StyleSize::Auto());
+
+ ReflowInput childRIForMeasuringBSize(
+ PresContext(), aParentReflowInput, aFlexItem.Frame(), availSize,
+ Nothing(), ReflowInput::InitFlag::CallerWillInit, sizeOverrides);
+ childRIForMeasuringBSize.Init(PresContext());
+
+ // When measuring flex item's content block-size, disregard the item's
+ // min-block-size and max-block-size by resetting both to to their
+ // unconstraining (extreme) values. The flexbox layout algorithm does still
+ // explicitly clamp both sizes when resolving the target main size.
+ childRIForMeasuringBSize.SetComputedMinBSize(0);
+ childRIForMeasuringBSize.SetComputedMaxBSize(NS_UNCONSTRAINEDSIZE);
+
+ if (aForceBResizeForMeasuringReflow) {
+ childRIForMeasuringBSize.SetBResize(true);
+ // Not 100% sure this is needed, but be conservative for now:
+ childRIForMeasuringBSize.mFlags.mIsBResizeForPercentages = true;
+ }
+
+ const CachedBAxisMeasurement& measurement =
+ MeasureBSizeForFlexItem(aFlexItem, childRIForMeasuringBSize);
+
+ return measurement.BSize();
+}
+
+FlexItem::FlexItem(ReflowInput& aFlexItemReflowInput, float aFlexGrow,
+ float aFlexShrink, nscoord aFlexBaseSize,
+ nscoord aMainMinSize, nscoord aMainMaxSize,
+ nscoord aTentativeCrossSize, nscoord aCrossMinSize,
+ nscoord aCrossMaxSize,
+ const FlexboxAxisTracker& aAxisTracker)
+ : mFrame(aFlexItemReflowInput.mFrame),
+ mFlexGrow(aFlexGrow),
+ mFlexShrink(aFlexShrink),
+ mAspectRatio(mFrame->GetAspectRatio()),
+ mWM(aFlexItemReflowInput.GetWritingMode()),
+ mCBWM(aAxisTracker.GetWritingMode()),
+ mMainAxis(aAxisTracker.MainAxis()),
+ mBorderPadding(aFlexItemReflowInput.ComputedLogicalBorderPadding(mCBWM)),
+ mMargin(aFlexItemReflowInput.ComputedLogicalMargin(mCBWM)),
+ mMainMinSize(aMainMinSize),
+ mMainMaxSize(aMainMaxSize),
+ mCrossMinSize(aCrossMinSize),
+ mCrossMaxSize(aCrossMaxSize),
+ mCrossSize(aTentativeCrossSize),
+ mIsInlineAxisMainAxis(aAxisTracker.IsInlineAxisMainAxis(mWM)),
+ mNeedsMinSizeAutoResolution(IsMinSizeAutoResolutionNeeded())
+// mAlignSelf, mHasAnyAutoMargin see below
+{
+ MOZ_ASSERT(mFrame, "expecting a non-null child frame");
+ MOZ_ASSERT(!mFrame->IsPlaceholderFrame(),
+ "placeholder frames should not be treated as flex items");
+ MOZ_ASSERT(!mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW),
+ "out-of-flow frames should not be treated as flex items");
+ MOZ_ASSERT(mIsInlineAxisMainAxis ==
+ nsFlexContainerFrame::IsItemInlineAxisMainAxis(mFrame),
+ "public API should be consistent with internal state (about "
+ "whether flex item's inline axis is flex container's main axis)");
+
+ const ReflowInput* containerRS = aFlexItemReflowInput.mParentReflowInput;
+ if (IsLegacyBox(containerRS->mFrame)) {
+ // For -webkit-{inline-}box and -moz-{inline-}box, we need to:
+ // (1) Use prefixed "box-align" instead of "align-items" to determine the
+ // container's cross-axis alignment behavior.
+ // (2) Suppress the ability for flex items to override that with their own
+ // cross-axis alignment. (The legacy box model doesn't support this.)
+ // So, each FlexItem simply copies the container's converted "align-items"
+ // value and disregards their own "align-self" property.
+ const nsStyleXUL* containerStyleXUL = containerRS->mFrame->StyleXUL();
+ mAlignSelf = {ConvertLegacyStyleToAlignItems(containerStyleXUL)};
+ mAlignSelfFlags = {0};
+ } else {
+ mAlignSelf = aFlexItemReflowInput.mStylePosition->UsedAlignSelf(
+ containerRS->mFrame->Style());
+ if (MOZ_LIKELY(mAlignSelf._0 == StyleAlignFlags::NORMAL)) {
+ mAlignSelf = {StyleAlignFlags::STRETCH};
+ }
+
+ // Store and strip off the <overflow-position> bits
+ mAlignSelfFlags = mAlignSelf._0 & StyleAlignFlags::FLAG_BITS;
+ mAlignSelf._0 &= ~StyleAlignFlags::FLAG_BITS;
+ }
+
+ // Our main-size is considered definite if any of these are true:
+ // (a) main axis is the item's inline axis.
+ // (b) flex container has definite main size.
+ // (c) flex item has a definite flex basis.
+ //
+ // Hence, we need to take care to treat the final main-size as *indefinite*
+ // if none of these conditions are satisfied.
+ if (mIsInlineAxisMainAxis) {
+ // The item's block-axis is the flex container's cross axis. We don't need
+ // any special handling to treat cross sizes as indefinite, because the
+ // cases where we stomp on the cross size with a definite value are all...
+ // - situations where the spec requires us to treat the cross size as
+ // definite; specifically, `align-self:stretch` whose cross size is
+ // definite.
+ // - situations where definiteness doesn't matter (e.g. for an element with
+ // an aspect ratio, which for now are all leaf nodes and hence
+ // can't have any percent-height descendants that would care about the
+ // definiteness of its size. (Once bug 1528375 is fixed, we might need to
+ // be more careful about definite vs. indefinite sizing on flex items with
+ // aspect ratios.)
+ mTreatBSizeAsIndefinite = false;
+ } else {
+ // The item's block-axis is the flex container's main axis. So, the flex
+ // item's main size is its BSize, and is considered definite under certain
+ // conditions laid out for definite flex-item main-sizes in the spec.
+ if (aAxisTracker.IsRowOriented() ||
+ (containerRS->ComputedBSize() != NS_UNCONSTRAINEDSIZE &&
+ !containerRS->mFlags.mTreatBSizeAsIndefinite)) {
+ // The flex *container* has a definite main-size (either by being
+ // row-oriented [and using its own inline size which is by definition
+ // definite, or by being column-oriented and having a definite
+ // block-size). The spec says this means all of the flex items'
+ // post-flexing main sizes should *also* be treated as definite.
+ mTreatBSizeAsIndefinite = false;
+ } else if (aFlexBaseSize != NS_UNCONSTRAINEDSIZE) {
+ // The flex item has a definite flex basis, which we'll treat as making
+ // its main-size definite.
+ mTreatBSizeAsIndefinite = false;
+ } else {
+ // Otherwise, we have to treat the item's BSize as indefinite.
+ mTreatBSizeAsIndefinite = true;
+ }
+ }
+
+ SetFlexBaseSizeAndMainSize(aFlexBaseSize);
+
+ const nsStyleMargin* styleMargin = aFlexItemReflowInput.mStyleMargin;
+ mHasAnyAutoMargin = styleMargin->HasInlineAxisAuto(mCBWM) ||
+ styleMargin->HasBlockAxisAuto(mCBWM);
+
+ // Assert that any "auto" margin components are set to 0.
+ // (We'll resolve them later; until then, we want to treat them as 0-sized.)
+#ifdef DEBUG
+ {
+ for (const auto side : AllLogicalSides()) {
+ if (styleMargin->mMargin.Get(mCBWM, side).IsAuto()) {
+ MOZ_ASSERT(GetMarginComponentForSide(side) == 0,
+ "Someone else tried to resolve our auto margin");
+ }
+ }
+ }
+#endif // DEBUG
+
+ // Map align-self 'baseline' value to 'start' when baseline alignment
+ // is not possible because the FlexItem's block axis is orthogonal to
+ // the cross axis of the container. If that's the case, we just directly
+ // convert our align-self value here, so that we don't have to handle this
+ // with special cases elsewhere.
+ // We are treating this case as one where it is appropriate to use the
+ // fallback values defined at https://www.w3.org/TR/css-align/#baseline-values
+ if (!IsBlockAxisCrossAxis()) {
+ if (mAlignSelf._0 == StyleAlignFlags::BASELINE) {
+ mAlignSelf = {StyleAlignFlags::FLEX_START};
+ } else if (mAlignSelf._0 == StyleAlignFlags::LAST_BASELINE) {
+ mAlignSelf = {StyleAlignFlags::FLEX_END};
+ }
+ }
+}
+
+// Simplified constructor for creating a special "strut" FlexItem, for a child
+// with visibility:collapse. The strut has 0 main-size, and it only exists to
+// impose a minimum cross size on whichever FlexLine it ends up in.
+FlexItem::FlexItem(nsIFrame* aChildFrame, nscoord aCrossSize,
+ WritingMode aContainerWM,
+ const FlexboxAxisTracker& aAxisTracker)
+ : mFrame(aChildFrame),
+ mWM(aChildFrame->GetWritingMode()),
+ mCBWM(aContainerWM),
+ mMainAxis(aAxisTracker.MainAxis()),
+ mBorderPadding(mCBWM),
+ mMargin(mCBWM),
+ mCrossSize(aCrossSize),
+ // Struts don't do layout, so its WM doesn't matter at this point. So, we
+ // just share container's WM for simplicity:
+ mIsFrozen(true),
+ mIsStrut(true), // (this is the constructor for making struts, after all)
+ mAlignSelf({StyleAlignFlags::FLEX_START}) {
+ MOZ_ASSERT(mFrame, "expecting a non-null child frame");
+ MOZ_ASSERT(mFrame->StyleVisibility()->IsCollapse(),
+ "Should only make struts for children with 'visibility:collapse'");
+ MOZ_ASSERT(!mFrame->IsPlaceholderFrame(),
+ "placeholder frames should not be treated as flex items");
+ MOZ_ASSERT(!mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW),
+ "out-of-flow frames should not be treated as flex items");
+}
+
+bool FlexItem::IsMinSizeAutoResolutionNeeded() const {
+ // We'll need special behavior for "min-[width|height]:auto" (whichever is in
+ // the flex container's main axis) iff:
+ // (a) its computed value is "auto", and
+ // (b) the item is *not* a scroll container. (A scroll container's automatic
+ // minimum size is zero.)
+ // https://drafts.csswg.org/css-flexbox-1/#min-size-auto
+ const auto& mainMinSize =
+ Frame()->StylePosition()->MinSize(MainAxis(), ContainingBlockWM());
+
+ return IsAutoOrEnumOnBSize(mainMinSize, IsInlineAxisMainAxis()) &&
+ !Frame()->StyleDisplay()->IsScrollableOverflow();
+}
+
+nscoord FlexItem::BaselineOffsetFromOuterCrossEdge(
+ mozilla::Side aStartSide, bool aUseFirstLineBaseline) const {
+ // NOTE:
+ // * We only use baselines for aligning in the flex container's cross axis.
+ // * Baselines are a measurement in the item's block axis.
+ // ...so we only expect to get here if the item's block axis is parallel (or
+ // antiparallel) to the container's cross axis. (Otherwise, the FlexItem
+ // constructor should've resolved mAlignSelf with a fallback value, which
+ // would prevent this function from being called.)
+ MOZ_ASSERT(IsBlockAxisCrossAxis(),
+ "Only expecting to be doing baseline computations when the "
+ "cross axis is the block axis");
+
+ mozilla::Side itemBlockStartSide = mWM.PhysicalSide(eLogicalSideBStart);
+
+ nscoord marginBStartToBaseline = ResolvedAscent(aUseFirstLineBaseline) +
+ PhysicalMargin().Side(itemBlockStartSide);
+
+ return (aStartSide == itemBlockStartSide)
+ ? marginBStartToBaseline
+ : OuterCrossSize() - marginBStartToBaseline;
+}
+
+bool FlexItem::IsCrossSizeAuto() const {
+ const nsStylePosition* stylePos =
+ nsLayoutUtils::GetStyleFrame(mFrame)->StylePosition();
+ // Check whichever component is in the flex container's cross axis.
+ // (IsInlineAxisCrossAxis() tells us whether that's our ISize or BSize, in
+ // terms of our own WritingMode, mWM.)
+ return IsInlineAxisCrossAxis() ? stylePos->ISize(mWM).IsAuto()
+ : stylePos->BSize(mWM).IsAuto();
+}
+
+bool FlexItem::IsCrossSizeDefinite(const ReflowInput& aItemReflowInput) const {
+ if (IsStretched()) {
+ // Definite cross-size, imposed via 'align-self:stretch' & flex container.
+ return true;
+ }
+
+ const nsStylePosition* pos = aItemReflowInput.mStylePosition;
+ const auto itemWM = GetWritingMode();
+
+ // The logic here should be similar to the logic for isAutoISize/isAutoBSize
+ // in nsContainerFrame::ComputeSizeWithIntrinsicDimensions().
+ if (IsInlineAxisCrossAxis()) {
+ return !pos->ISize(itemWM).IsAuto();
+ }
+
+ nscoord cbBSize = aItemReflowInput.mContainingBlockSize.BSize(itemWM);
+ return !nsLayoutUtils::IsAutoBSize(pos->BSize(itemWM), cbBSize);
+}
+
+void FlexItem::ResolveFlexBaseSizeFromAspectRatio(
+ const ReflowInput& aItemReflowInput) {
+ // This implements the Flex Layout Algorithm Step 3B:
+ // https://drafts.csswg.org/css-flexbox-1/#algo-main-item
+ // If the flex item has ...
+ // - an aspect ratio,
+ // - a [used] flex-basis of 'content', and
+ // - a definite cross size
+ // then the flex base size is calculated from its inner cross size and the
+ // flex item's preferred aspect ratio.
+ if (HasAspectRatio() &&
+ nsFlexContainerFrame::IsUsedFlexBasisContent(
+ aItemReflowInput.mStylePosition->mFlexBasis,
+ aItemReflowInput.mStylePosition->Size(MainAxis(), mCBWM)) &&
+ IsCrossSizeDefinite(aItemReflowInput)) {
+ const LogicalSize contentBoxSizeToBoxSizingAdjust =
+ aItemReflowInput.mStylePosition->mBoxSizing == StyleBoxSizing::Border
+ ? BorderPadding().Size(mCBWM)
+ : LogicalSize(mCBWM);
+ const nscoord mainSizeFromRatio = mAspectRatio.ComputeRatioDependentSize(
+ MainAxis(), mCBWM, CrossSize(), contentBoxSizeToBoxSizingAdjust);
+ SetFlexBaseSizeAndMainSize(mainSizeFromRatio);
+ }
+}
+
+uint32_t FlexItem::NumAutoMarginsInAxis(LogicalAxis aAxis) const {
+ uint32_t numAutoMargins = 0;
+ const auto& styleMargin = mFrame->StyleMargin()->mMargin;
+ for (const auto edge : {eLogicalEdgeStart, eLogicalEdgeEnd}) {
+ const auto side = MakeLogicalSide(aAxis, edge);
+ if (styleMargin.Get(mCBWM, side).IsAuto()) {
+ numAutoMargins++;
+ }
+ }
+
+ // Mostly for clarity:
+ MOZ_ASSERT(numAutoMargins <= 2,
+ "We're just looking at one item along one dimension, so we "
+ "should only have examined 2 margins");
+
+ return numAutoMargins;
+}
+
+bool FlexItem::CanMainSizeInfluenceCrossSize() const {
+ if (mIsStretched) {
+ // We've already had our cross-size stretched for "align-self:stretch").
+ // The container is imposing its cross size on us.
+ return false;
+ }
+
+ if (mIsStrut) {
+ // Struts (for visibility:collapse items) have a predetermined size;
+ // no need to measure anything.
+ return false;
+ }
+
+ if (HasAspectRatio()) {
+ // For flex items that have an aspect ratio (and maintain it, i.e. are
+ // not stretched, which we already checked above): changes to main-size
+ // *do* influence the cross size.
+ return true;
+ }
+
+ if (IsInlineAxisCrossAxis()) {
+ // If we get here, this function is really asking: "can changes to this
+ // item's block size have an influence on its inline size"? For blocks and
+ // tables, the answer is "no".
+ if (mFrame->IsBlockFrame() || mFrame->IsTableWrapperFrame()) {
+ // XXXdholbert (Maybe use an IsFrameOfType query or something more
+ // general to test this across all frame types? For now, I'm just
+ // optimizing for block and table, since those are common containers that
+ // can contain arbitrarily-large subtrees (and that reliably have ISize
+ // being unaffected by BSize, per CSS2). So optimizing away needless
+ // relayout is possible & especially valuable for these containers.)
+ return false;
+ }
+ // Other opt-outs can go here, as they're identified as being useful
+ // (particularly for containers where an extra reflow is expensive). But in
+ // general, we have to assume that a flexed BSize *could* influence the
+ // ISize. Some examples where this can definitely happen:
+ // * Intrinsically-sized multicol with fixed-ISize columns, which adds
+ // columns (i.e. grows in inline axis) depending on its block size.
+ // * Intrinsically-sized multi-line column-oriented flex container, which
+ // adds flex lines (i.e. grows in inline axis) depending on its block size.
+ }
+
+ // Default assumption, if we haven't proven otherwise: the resolved main size
+ // *can* change the cross size.
+ return true;
+}
+
+nscoord FlexItem::ClampMainSizeViaCrossAxisConstraints(
+ nscoord aMainSize, const ReflowInput& aItemReflowInput) const {
+ MOZ_ASSERT(HasAspectRatio(), "Caller should've checked the ratio is valid!");
+
+ const LogicalSize contentBoxSizeToBoxSizingAdjust =
+ aItemReflowInput.mStylePosition->mBoxSizing == StyleBoxSizing::Border
+ ? BorderPadding().Size(mCBWM)
+ : LogicalSize(mCBWM);
+
+ const nscoord mainMinSizeFromRatio = mAspectRatio.ComputeRatioDependentSize(
+ MainAxis(), mCBWM, CrossMinSize(), contentBoxSizeToBoxSizingAdjust);
+ nscoord clampedMainSize = std::max(aMainSize, mainMinSizeFromRatio);
+
+ if (CrossMaxSize() != NS_UNCONSTRAINEDSIZE) {
+ const nscoord mainMaxSizeFromRatio = mAspectRatio.ComputeRatioDependentSize(
+ MainAxis(), mCBWM, CrossMaxSize(), contentBoxSizeToBoxSizingAdjust);
+ clampedMainSize = std::min(clampedMainSize, mainMaxSizeFromRatio);
+ }
+
+ return clampedMainSize;
+}
+
+/**
+ * Returns true if aFrame or any of its children have the
+ * NS_FRAME_CONTAINS_RELATIVE_BSIZE flag set -- i.e. if any of these frames (or
+ * their descendants) might have a relative-BSize dependency on aFrame (or its
+ * ancestors).
+ */
+static bool FrameHasRelativeBSizeDependency(nsIFrame* aFrame) {
+ if (aFrame->HasAnyStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE)) {
+ return true;
+ }
+ for (const auto& childList : aFrame->ChildLists()) {
+ for (nsIFrame* childFrame : childList.mList) {
+ if (childFrame->HasAnyStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE)) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+bool FlexItem::NeedsFinalReflow(const ReflowInput& aParentReflowInput) const {
+ if (!StaticPrefs::layout_flexbox_item_final_reflow_optimization_enabled()) {
+ FLEX_LOG(
+ "[perf] Flex item %p needed a final reflow due to optimization being "
+ "disabled via the preference",
+ mFrame);
+ return true;
+ }
+
+ // NOTE: We can have continuations from an earlier constrained reflow.
+ if (mFrame->GetPrevInFlow() || mFrame->GetNextInFlow()) {
+ // This is an item has continuation(s). Reflow it.
+ FLEX_LOG("[frag] Flex item %p needed a final reflow due to continuation(s)",
+ mFrame);
+ return true;
+ }
+
+ // A flex item can grow its block-size in a fragmented context if there's any
+ // force break within it (bug 1663079), or if it has a repeated table header
+ // or footer (bug 1744363). We currently always reflow it.
+ //
+ // Bug 1815294: investigate if we can design a more specific condition to
+ // prevent triggering O(n^2) behavior when printing a deeply-nested flex
+ // container.
+ if (aParentReflowInput.IsInFragmentedContext()) {
+ FLEX_LOG(
+ "[frag] Flex item %p needed both a measuring reflow and a final "
+ "reflow due to being in a fragmented context.",
+ mFrame);
+ return true;
+ }
+
+ // Flex item's final content-box size (in terms of its own writing-mode):
+ const LogicalSize finalSize = mIsInlineAxisMainAxis
+ ? LogicalSize(mWM, mMainSize, mCrossSize)
+ : LogicalSize(mWM, mCrossSize, mMainSize);
+
+ if (HadMeasuringReflow()) {
+ // We've already reflowed this flex item once, to measure it. In that
+ // reflow, did its frame happen to end up with the correct final size
+ // that the flex container would like it to have?
+ if (finalSize != mFrame->ContentSize(mWM)) {
+ // The measuring reflow left the item with a different size than its
+ // final flexed size. So, we need to reflow to give it the correct size.
+ FLEX_LOG(
+ "[perf] Flex item %p needed both a measuring reflow and a final "
+ "reflow due to measured size disagreeing with final size",
+ mFrame);
+ return true;
+ }
+
+ if (FrameHasRelativeBSizeDependency(mFrame)) {
+ // This item has descendants with relative BSizes who may care that its
+ // size may now be considered "definite" in the final reflow (whereas it
+ // was indefinite during the measuring reflow).
+ FLEX_LOG(
+ "[perf] Flex item %p needed both a measuring reflow and a final "
+ "reflow due to BSize potentially becoming definite",
+ mFrame);
+ return true;
+ }
+
+ // If we get here, then this flex item had a measuring reflow, it left us
+ // with the correct size, none of its descendants care that its BSize may
+ // now be considered definite, and it can fit into the available block-size.
+ // So it doesn't need a final reflow.
+ //
+ // We now cache this size as if we had done a final reflow (because we've
+ // determined that the measuring reflow was effectively equivalent). This
+ // way, in our next time through flex layout, we may be able to skip both
+ // the measuring reflow *and* the final reflow (if conditions are the same
+ // as they are now).
+ if (auto* cache = mFrame->GetProperty(CachedFlexItemData::Prop())) {
+ cache->Update(*this, finalSize);
+ }
+
+ return false;
+ }
+
+ // This item didn't receive a measuring reflow (at least, not during this
+ // reflow of our flex container). We may still be able to skip reflowing it
+ // (i.e. return false from this function), if its subtree is clean & its most
+ // recent "final reflow" had it at the correct content-box size &
+ // definiteness.
+ // Let's check for each condition that would still require us to reflow:
+ if (mFrame->IsSubtreeDirty()) {
+ FLEX_LOG(
+ "[perf] Flex item %p needed a final reflow due to its subtree "
+ "being dirty",
+ mFrame);
+ return true;
+ }
+
+ // Cool; this item & its subtree haven't experienced any style/content
+ // changes that would automatically require a reflow.
+
+ // Did we cache the metrics from its most recent "final reflow"?
+ auto* cache = mFrame->GetProperty(CachedFlexItemData::Prop());
+ if (!cache || !cache->mFinalReflowMetrics) {
+ FLEX_LOG(
+ "[perf] Flex item %p needed a final reflow due to lacking a "
+ "cached mFinalReflowMetrics (maybe cache was cleared)",
+ mFrame);
+ return true;
+ }
+
+ // Does the cached size match our current size?
+ if (cache->mFinalReflowMetrics->Size() != finalSize) {
+ FLEX_LOG(
+ "[perf] Flex item %p needed a final reflow due to having a "
+ "different content box size vs. its most recent final reflow",
+ mFrame);
+ return true;
+ }
+
+ // Does the cached border and padding match our current ones?
+ //
+ // Note: this is just to detect cases where we have a percent padding whose
+ // basis has changed. Any other sort of change to BorderPadding() (e.g. a new
+ // specified value) should result in the frame being marked dirty via proper
+ // change hint (see nsStylePadding::CalcDifference()), which will force it to
+ // reflow.
+ if (cache->mFinalReflowMetrics->BorderPadding() !=
+ BorderPadding().ConvertTo(mWM, mCBWM)) {
+ FLEX_LOG(
+ "[perf] Flex item %p needed a final reflow due to having a "
+ "different border and padding vs. its most recent final reflow",
+ mFrame);
+ return true;
+ }
+
+ // The flex container is giving this flex item the same size that the item
+ // had on its most recent "final reflow". But if its definiteness changed and
+ // one of the descendants cares, then it would still need a reflow.
+ if (cache->mFinalReflowMetrics->TreatBSizeAsIndefinite() !=
+ mTreatBSizeAsIndefinite &&
+ FrameHasRelativeBSizeDependency(mFrame)) {
+ FLEX_LOG(
+ "[perf] Flex item %p needed a final reflow due to having "
+ "its BSize change definiteness & having a rel-BSize child",
+ mFrame);
+ return true;
+ }
+
+ // If we get here, we can skip the final reflow! (The item's subtree isn't
+ // dirty, and our current conditions are sufficiently similar to the most
+ // recent "final reflow" that it should have left our subtree in the correct
+ // state.)
+ FLEX_LOG("[perf] Flex item %p didn't need a final reflow", mFrame);
+ return false;
+}
+
+// Keeps track of our position along a particular axis (where a '0' position
+// corresponds to the 'start' edge of that axis).
+// This class shouldn't be instantiated directly -- rather, it should only be
+// instantiated via its subclasses defined below.
+class MOZ_STACK_CLASS PositionTracker {
+ public:
+ // Accessor for the current value of the position that we're tracking.
+ inline nscoord Position() const { return mPosition; }
+ inline LogicalAxis Axis() const { return mAxis; }
+
+ inline LogicalSide StartSide() {
+ return MakeLogicalSide(
+ mAxis, mIsAxisReversed ? eLogicalEdgeEnd : eLogicalEdgeStart);
+ }
+
+ inline LogicalSide EndSide() {
+ return MakeLogicalSide(
+ mAxis, mIsAxisReversed ? eLogicalEdgeStart : eLogicalEdgeEnd);
+ }
+
+ // Advances our position across the start edge of the given margin, in the
+ // axis we're tracking.
+ void EnterMargin(const LogicalMargin& aMargin) {
+ mPosition += aMargin.Side(StartSide(), mWM);
+ }
+
+ // Advances our position across the end edge of the given margin, in the axis
+ // we're tracking.
+ void ExitMargin(const LogicalMargin& aMargin) {
+ mPosition += aMargin.Side(EndSide(), mWM);
+ }
+
+ // Advances our current position from the start side of a child frame's
+ // border-box to the frame's upper or left edge (depending on our axis).
+ // (Note that this is a no-op if our axis grows in the same direction as
+ // the corresponding logical axis.)
+ void EnterChildFrame(nscoord aChildFrameSize) {
+ if (mIsAxisReversed) {
+ mPosition += aChildFrameSize;
+ }
+ }
+
+ // Advances our current position from a frame's upper or left border-box edge
+ // (whichever is in the axis we're tracking) to the 'end' side of the frame
+ // in the axis that we're tracking. (Note that this is a no-op if our axis
+ // is reversed with respect to the corresponding logical axis.)
+ void ExitChildFrame(nscoord aChildFrameSize) {
+ if (!mIsAxisReversed) {
+ mPosition += aChildFrameSize;
+ }
+ }
+
+ // Delete copy-constructor & reassignment operator, to prevent accidental
+ // (unnecessary) copying.
+ PositionTracker(const PositionTracker&) = delete;
+ PositionTracker& operator=(const PositionTracker&) = delete;
+
+ protected:
+ // Protected constructor, to be sure we're only instantiated via a subclass.
+ PositionTracker(WritingMode aWM, LogicalAxis aAxis, bool aIsAxisReversed)
+ : mWM(aWM), mAxis(aAxis), mIsAxisReversed(aIsAxisReversed) {}
+
+ // Member data:
+ // The position we're tracking.
+ nscoord mPosition = 0;
+
+ // The flex container's writing mode.
+ const WritingMode mWM;
+
+ // The axis along which we're moving.
+ const LogicalAxis mAxis = eLogicalAxisInline;
+
+ // Is the axis along which we're moving reversed (e.g. LTR vs RTL) with
+ // respect to the corresponding axis on the flex container's WM?
+ const bool mIsAxisReversed = false;
+};
+
+// Tracks our position in the main axis, when we're laying out flex items.
+// The "0" position represents the main-start edge of the flex container's
+// content-box.
+class MOZ_STACK_CLASS MainAxisPositionTracker : public PositionTracker {
+ public:
+ MainAxisPositionTracker(const FlexboxAxisTracker& aAxisTracker,
+ const FlexLine* aLine,
+ const StyleContentDistribution& aJustifyContent,
+ nscoord aContentBoxMainSize);
+
+ ~MainAxisPositionTracker() {
+ MOZ_ASSERT(mNumPackingSpacesRemaining == 0,
+ "miscounted the number of packing spaces");
+ MOZ_ASSERT(mNumAutoMarginsInMainAxis == 0,
+ "miscounted the number of auto margins");
+ }
+
+ // Advances past the gap space (if any) between two flex items
+ void TraverseGap(nscoord aGapSize) { mPosition += aGapSize; }
+
+ // Advances past the packing space (if any) between two flex items
+ void TraversePackingSpace();
+
+ // If aItem has any 'auto' margins in the main axis, this method updates the
+ // corresponding values in its margin.
+ void ResolveAutoMarginsInMainAxis(FlexItem& aItem);
+
+ private:
+ nscoord mPackingSpaceRemaining = 0;
+ uint32_t mNumAutoMarginsInMainAxis = 0;
+ uint32_t mNumPackingSpacesRemaining = 0;
+ StyleContentDistribution mJustifyContent = {StyleAlignFlags::AUTO};
+};
+
+// Utility class for managing our position along the cross axis along
+// the whole flex container (at a higher level than a single line).
+// The "0" position represents the cross-start edge of the flex container's
+// content-box.
+class MOZ_STACK_CLASS CrossAxisPositionTracker : public PositionTracker {
+ public:
+ CrossAxisPositionTracker(nsTArray<FlexLine>& aLines,
+ const ReflowInput& aReflowInput,
+ nscoord aContentBoxCrossSize,
+ bool aIsCrossSizeDefinite,
+ const FlexboxAxisTracker& aAxisTracker,
+ const nscoord aCrossGapSize);
+
+ // Advances past the gap (if any) between two flex lines
+ void TraverseGap() { mPosition += mCrossGapSize; }
+
+ // Advances past the packing space (if any) between two flex lines
+ void TraversePackingSpace();
+
+ // Advances past the given FlexLine
+ void TraverseLine(FlexLine& aLine) { mPosition += aLine.LineCrossSize(); }
+
+ // Redeclare the frame-related methods from PositionTracker with
+ // = delete, to be sure (at compile time) that no client code can invoke
+ // them. (Unlike the other PositionTracker derived classes, this class here
+ // deals with FlexLines, not with individual FlexItems or frames.)
+ void EnterMargin(const LogicalMargin& aMargin) = delete;
+ void ExitMargin(const LogicalMargin& aMargin) = delete;
+ void EnterChildFrame(nscoord aChildFrameSize) = delete;
+ void ExitChildFrame(nscoord aChildFrameSize) = delete;
+
+ private:
+ nscoord mPackingSpaceRemaining = 0;
+ uint32_t mNumPackingSpacesRemaining = 0;
+ StyleContentDistribution mAlignContent = {StyleAlignFlags::AUTO};
+
+ const nscoord mCrossGapSize;
+};
+
+// Utility class for managing our position along the cross axis, *within* a
+// single flex line.
+class MOZ_STACK_CLASS SingleLineCrossAxisPositionTracker
+ : public PositionTracker {
+ public:
+ explicit SingleLineCrossAxisPositionTracker(
+ const FlexboxAxisTracker& aAxisTracker);
+
+ void ResolveAutoMarginsInCrossAxis(const FlexLine& aLine, FlexItem& aItem);
+
+ void EnterAlignPackingSpace(const FlexLine& aLine, const FlexItem& aItem,
+ const FlexboxAxisTracker& aAxisTracker);
+
+ // Resets our position to the cross-start edge of this line.
+ inline void ResetPosition() { mPosition = 0; }
+};
+
+//----------------------------------------------------------------------
+
+// Frame class boilerplate
+// =======================
+
+NS_QUERYFRAME_HEAD(nsFlexContainerFrame)
+ NS_QUERYFRAME_ENTRY(nsFlexContainerFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
+
+NS_IMPL_FRAMEARENA_HELPERS(nsFlexContainerFrame)
+
+nsContainerFrame* NS_NewFlexContainerFrame(PresShell* aPresShell,
+ ComputedStyle* aStyle) {
+ return new (aPresShell)
+ nsFlexContainerFrame(aStyle, aPresShell->GetPresContext());
+}
+
+//----------------------------------------------------------------------
+
+// nsFlexContainerFrame Method Implementations
+// ===========================================
+
+/* virtual */
+nsFlexContainerFrame::~nsFlexContainerFrame() = default;
+
+/* virtual */
+void nsFlexContainerFrame::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);
+ }
+
+ auto displayInside = StyleDisplay()->DisplayInside();
+ // If this frame is for a scrollable element, then it will actually have
+ // "display:block", and its *parent frame* will have the real
+ // flex-flavored display value. So in that case, check the parent frame to
+ // find out if we're legacy.
+ //
+ // TODO(emilio): Maybe ::-moz-scrolled-content and co should inherit `display`
+ // (or a blockified version thereof, to not hit bug 456484).
+ if (displayInside == StyleDisplayInside::Flow) {
+ MOZ_ASSERT(StyleDisplay()->mDisplay == StyleDisplay::Block);
+ MOZ_ASSERT(Style()->GetPseudoType() == PseudoStyleType::buttonContent ||
+ Style()->GetPseudoType() == PseudoStyleType::scrolledContent,
+ "The only way a nsFlexContainerFrame can have 'display:block' "
+ "should be if it's the inner part of a scrollable or button "
+ "element");
+ displayInside = GetParent()->StyleDisplay()->DisplayInside();
+ }
+
+ // Figure out if we should set a frame state bit to indicate that this frame
+ // represents a legacy -moz-{inline-}box or -webkit-{inline-}box container.
+ if (displayInside == StyleDisplayInside::WebkitBox) {
+ AddStateBits(NS_STATE_FLEX_IS_EMULATING_LEGACY_WEBKIT_BOX);
+ }
+}
+
+#ifdef DEBUG_FRAME_DUMP
+nsresult nsFlexContainerFrame::GetFrameName(nsAString& aResult) const {
+ return MakeFrameName(u"FlexContainer"_ns, aResult);
+}
+#endif
+
+void nsFlexContainerFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
+ const nsDisplayListSet& aLists) {
+ nsDisplayListCollection tempLists(aBuilder);
+
+ DisplayBorderBackgroundOutline(aBuilder, tempLists);
+ if (GetPrevInFlow()) {
+ DisplayOverflowContainers(aBuilder, tempLists);
+ }
+
+ // Our children are all block-level, so their borders/backgrounds all go on
+ // the BlockBorderBackgrounds list.
+ nsDisplayListSet childLists(tempLists, tempLists.BlockBorderBackgrounds());
+
+ CSSOrderAwareFrameIterator iter(
+ this, FrameChildListID::Principal,
+ CSSOrderAwareFrameIterator::ChildFilter::IncludeAll,
+ OrderStateForIter(this), OrderingPropertyForIter(this));
+
+ const auto flags = DisplayFlagsForFlexOrGridItem();
+ for (; !iter.AtEnd(); iter.Next()) {
+ nsIFrame* childFrame = *iter;
+ BuildDisplayListForChild(aBuilder, childFrame, childLists, flags);
+ }
+
+ tempLists.MoveTo(aLists);
+}
+
+void FlexLine::FreezeItemsEarly(bool aIsUsingFlexGrow,
+ ComputedFlexLineInfo* aLineInfo) {
+ // After we've established the type of flexing we're doing (growing vs.
+ // shrinking), and before we try to flex any items, we freeze items that
+ // obviously *can't* flex.
+ //
+ // Quoting the spec:
+ // # Freeze, setting its target main size to its hypothetical main size...
+ // # - any item that has a flex factor of zero
+ // # - if using the flex grow factor: any item that has a flex base size
+ // # greater than its hypothetical main size
+ // # - if using the flex shrink factor: any item that has a flex base size
+ // # smaller than its hypothetical main size
+ // https://drafts.csswg.org/css-flexbox/#resolve-flexible-lengths
+ //
+ // (NOTE: At this point, item->MainSize() *is* the item's hypothetical
+ // main size, since SetFlexBaseSizeAndMainSize() sets it up that way, and the
+ // item hasn't had a chance to flex away from that yet.)
+
+ // Since this loop only operates on unfrozen flex items, we can break as
+ // soon as we have seen all of them.
+ uint32_t numUnfrozenItemsToBeSeen = NumItems() - mNumFrozenItems;
+ for (FlexItem& item : Items()) {
+ if (numUnfrozenItemsToBeSeen == 0) {
+ break;
+ }
+
+ if (!item.IsFrozen()) {
+ numUnfrozenItemsToBeSeen--;
+ bool shouldFreeze = (0.0f == item.GetFlexFactor(aIsUsingFlexGrow));
+ if (!shouldFreeze) {
+ if (aIsUsingFlexGrow) {
+ if (item.FlexBaseSize() > item.MainSize()) {
+ shouldFreeze = true;
+ }
+ } else { // using flex-shrink
+ if (item.FlexBaseSize() < item.MainSize()) {
+ shouldFreeze = true;
+ }
+ }
+ }
+ if (shouldFreeze) {
+ // Freeze item! (at its hypothetical main size)
+ item.Freeze();
+ if (item.FlexBaseSize() < item.MainSize()) {
+ item.SetWasMinClamped();
+ } else if (item.FlexBaseSize() > item.MainSize()) {
+ item.SetWasMaxClamped();
+ }
+ mNumFrozenItems++;
+ }
+ }
+ }
+
+ MOZ_ASSERT(numUnfrozenItemsToBeSeen == 0, "miscounted frozen items?");
+}
+
+// Based on the sign of aTotalViolation, this function freezes a subset of our
+// flexible sizes, and restores the remaining ones to their initial pref sizes.
+void FlexLine::FreezeOrRestoreEachFlexibleSize(const nscoord aTotalViolation,
+ bool aIsFinalIteration) {
+ enum FreezeType {
+ eFreezeEverything,
+ eFreezeMinViolations,
+ eFreezeMaxViolations
+ };
+
+ FreezeType freezeType;
+ if (aTotalViolation == 0) {
+ freezeType = eFreezeEverything;
+ } else if (aTotalViolation > 0) {
+ freezeType = eFreezeMinViolations;
+ } else { // aTotalViolation < 0
+ freezeType = eFreezeMaxViolations;
+ }
+
+ // Since this loop only operates on unfrozen flex items, we can break as
+ // soon as we have seen all of them.
+ uint32_t numUnfrozenItemsToBeSeen = NumItems() - mNumFrozenItems;
+ for (FlexItem& item : Items()) {
+ if (numUnfrozenItemsToBeSeen == 0) {
+ break;
+ }
+
+ if (!item.IsFrozen()) {
+ numUnfrozenItemsToBeSeen--;
+
+ MOZ_ASSERT(!item.HadMinViolation() || !item.HadMaxViolation(),
+ "Can have either min or max violation, but not both");
+
+ bool hadMinViolation = item.HadMinViolation();
+ bool hadMaxViolation = item.HadMaxViolation();
+ if (eFreezeEverything == freezeType ||
+ (eFreezeMinViolations == freezeType && hadMinViolation) ||
+ (eFreezeMaxViolations == freezeType && hadMaxViolation)) {
+ MOZ_ASSERT(item.MainSize() >= item.MainMinSize(),
+ "Freezing item at a size below its minimum");
+ MOZ_ASSERT(item.MainSize() <= item.MainMaxSize(),
+ "Freezing item at a size above its maximum");
+
+ item.Freeze();
+ if (hadMinViolation) {
+ item.SetWasMinClamped();
+ } else if (hadMaxViolation) {
+ item.SetWasMaxClamped();
+ }
+ mNumFrozenItems++;
+ } else if (MOZ_UNLIKELY(aIsFinalIteration)) {
+ // XXXdholbert If & when bug 765861 is fixed, we should upgrade this
+ // assertion to be fatal except in documents with enormous lengths.
+ NS_ERROR(
+ "Final iteration still has unfrozen items, this shouldn't"
+ " happen unless there was nscoord under/overflow.");
+ item.Freeze();
+ mNumFrozenItems++;
+ } // else, we'll reset this item's main size to its flex base size on the
+ // next iteration of this algorithm.
+
+ if (!item.IsFrozen()) {
+ // Clear this item's violation(s), now that we've dealt with them
+ item.ClearViolationFlags();
+ }
+ }
+ }
+
+ MOZ_ASSERT(numUnfrozenItemsToBeSeen == 0, "miscounted frozen items?");
+}
+
+void FlexLine::ResolveFlexibleLengths(nscoord aFlexContainerMainSize,
+ ComputedFlexLineInfo* aLineInfo) {
+ // In this function, we use 64-bit coord type to avoid integer overflow in
+ // case several of the individual items have huge hypothetical main sizes,
+ // which can happen with percent-width table-layout:fixed descendants. Here we
+ // promote the container's main size to 64-bit to make the arithmetic
+ // convenient.
+ AuCoord64 flexContainerMainSize(aFlexContainerMainSize);
+
+ // Before we start resolving sizes: if we have an aLineInfo structure to fill
+ // out, we inform it of each item's base size, and we initialize the "delta"
+ // for each item to 0. (And if the flex algorithm wants to grow or shrink the
+ // item, we'll update this delta further down.)
+ if (aLineInfo) {
+ uint32_t itemIndex = 0;
+ for (FlexItem& item : Items()) {
+ aLineInfo->mItems[itemIndex].mMainBaseSize = item.FlexBaseSize();
+ aLineInfo->mItems[itemIndex].mMainDeltaSize = 0;
+ ++itemIndex;
+ }
+ }
+
+ // Determine whether we're going to be growing or shrinking items.
+ const bool isUsingFlexGrow =
+ (mTotalOuterHypotheticalMainSize < flexContainerMainSize);
+
+ if (aLineInfo) {
+ aLineInfo->mGrowthState =
+ isUsingFlexGrow ? mozilla::dom::FlexLineGrowthState::Growing
+ : mozilla::dom::FlexLineGrowthState::Shrinking;
+ }
+
+ // Do an "early freeze" for flex items that obviously can't flex in the
+ // direction we've chosen:
+ FreezeItemsEarly(isUsingFlexGrow, aLineInfo);
+
+ if ((mNumFrozenItems == NumItems()) && !aLineInfo) {
+ // All our items are frozen, so we have no flexible lengths to resolve,
+ // and we aren't being asked to generate computed line info.
+ FLEX_LOG("No flexible length to resolve");
+ return;
+ }
+ MOZ_ASSERT(!IsEmpty() || aLineInfo,
+ "empty lines should take the early-return above");
+
+ FLEX_LOG("Resolving flexible lengths for items");
+
+ // Subtract space occupied by our items' margins/borders/padding/gaps, so
+ // we can just be dealing with the space available for our flex items' content
+ // boxes.
+ const AuCoord64 totalItemMBPAndGaps = mTotalItemMBP + SumOfGaps();
+ const AuCoord64 spaceAvailableForFlexItemsContentBoxes =
+ flexContainerMainSize - totalItemMBPAndGaps;
+
+ Maybe<AuCoord64> origAvailableFreeSpace;
+
+ // NOTE: I claim that this chunk of the algorithm (the looping part) needs to
+ // run the loop at MOST NumItems() times. This claim should hold up
+ // because we'll freeze at least one item on each loop iteration, and once
+ // we've run out of items to freeze, there's nothing left to do. However,
+ // in most cases, we'll break out of this loop long before we hit that many
+ // iterations.
+ for (uint32_t iterationCounter = 0; iterationCounter < NumItems();
+ iterationCounter++) {
+ // Set every not-yet-frozen item's used main size to its
+ // flex base size, and subtract all the used main sizes from our
+ // total amount of space to determine the 'available free space'
+ // (positive or negative) to be distributed among our flexible items.
+ AuCoord64 availableFreeSpace = spaceAvailableForFlexItemsContentBoxes;
+ for (FlexItem& item : Items()) {
+ if (!item.IsFrozen()) {
+ item.SetMainSize(item.FlexBaseSize());
+ }
+ availableFreeSpace -= item.MainSize();
+ }
+
+ FLEX_LOG(" available free space: %" PRId64 "; flex items should \"%s\"",
+ availableFreeSpace.value, isUsingFlexGrow ? "grow" : "shrink");
+
+ // The sign of our free space should agree with the type of flexing
+ // (grow/shrink) that we're doing. Any disagreement should've made us use
+ // the other type of flexing, or should've been resolved in
+ // FreezeItemsEarly.
+ //
+ // Note: it's possible that an individual flex item has huge
+ // margin/border/padding that makes either its
+ // MarginBorderPaddingSizeInMainAxis() or OuterMainSize() negative due to
+ // integer overflow. If that happens, the accumulated
+ // mTotalOuterHypotheticalMainSize or mTotalItemMBP could be negative due to
+ // that one item's negative (overflowed) size. Likewise, a huge main gap
+ // size between flex items can also make our accumulated SumOfGaps()
+ // negative. In these case, we throw up our hands and don't require
+ // isUsingFlexGrow to agree with availableFreeSpace. Luckily, we won't get
+ // stuck in the algorithm below, and just distribute the wrong
+ // availableFreeSpace with the wrong grow/shrink factors.
+ MOZ_ASSERT(!(mTotalOuterHypotheticalMainSize >= 0 && mTotalItemMBP >= 0 &&
+ totalItemMBPAndGaps >= 0) ||
+ (isUsingFlexGrow && availableFreeSpace >= 0) ||
+ (!isUsingFlexGrow && availableFreeSpace <= 0),
+ "availableFreeSpace's sign should match isUsingFlexGrow");
+
+ // If we have any free space available, give each flexible item a portion
+ // of availableFreeSpace.
+ if (availableFreeSpace != AuCoord64(0)) {
+ // The first time we do this, we initialize origAvailableFreeSpace.
+ if (!origAvailableFreeSpace) {
+ origAvailableFreeSpace.emplace(availableFreeSpace);
+ }
+
+ // STRATEGY: On each item, we compute & store its "share" of the total
+ // weight that we've seen so far:
+ // curWeight / weightSum
+ //
+ // Then, when we go to actually distribute the space (in the next loop),
+ // we can simply walk backwards through the elements and give each item
+ // its "share" multiplied by the remaining available space.
+ //
+ // SPECIAL CASE: If the sum of the weights is larger than the
+ // maximum representable double (overflowing to infinity), then we can't
+ // sensibly divide out proportional shares anymore. In that case, we
+ // simply treat the flex item(s) with the largest weights as if
+ // their weights were infinite (dwarfing all the others), and we
+ // distribute all of the available space among them.
+ double weightSum = 0.0;
+ double flexFactorSum = 0.0;
+ double largestWeight = 0.0;
+ uint32_t numItemsWithLargestWeight = 0;
+
+ // Since this loop only operates on unfrozen flex items, we can break as
+ // soon as we have seen all of them.
+ uint32_t numUnfrozenItemsToBeSeen = NumItems() - mNumFrozenItems;
+ for (FlexItem& item : Items()) {
+ if (numUnfrozenItemsToBeSeen == 0) {
+ break;
+ }
+
+ if (!item.IsFrozen()) {
+ numUnfrozenItemsToBeSeen--;
+
+ const double curWeight = item.GetWeight(isUsingFlexGrow);
+ const double curFlexFactor = item.GetFlexFactor(isUsingFlexGrow);
+ MOZ_ASSERT(curWeight >= 0.0, "weights are non-negative");
+ MOZ_ASSERT(curFlexFactor >= 0.0, "flex factors are non-negative");
+
+ weightSum += curWeight;
+ flexFactorSum += curFlexFactor;
+
+ if (std::isfinite(weightSum)) {
+ if (curWeight == 0.0) {
+ item.SetShareOfWeightSoFar(0.0);
+ } else {
+ item.SetShareOfWeightSoFar(curWeight / weightSum);
+ }
+ } // else, the sum of weights overflows to infinity, in which
+ // case we don't bother with "SetShareOfWeightSoFar" since
+ // we know we won't use it. (instead, we'll just give every
+ // item with the largest weight an equal share of space.)
+
+ // Update our largest-weight tracking vars
+ if (curWeight > largestWeight) {
+ largestWeight = curWeight;
+ numItemsWithLargestWeight = 1;
+ } else if (curWeight == largestWeight) {
+ numItemsWithLargestWeight++;
+ }
+ }
+ }
+
+ MOZ_ASSERT(numUnfrozenItemsToBeSeen == 0, "miscounted frozen items?");
+
+ if (weightSum != 0.0) {
+ MOZ_ASSERT(flexFactorSum != 0.0,
+ "flex factor sum can't be 0, if a weighted sum "
+ "of its components (weightSum) is nonzero");
+ if (flexFactorSum < 1.0) {
+ // Our unfrozen flex items don't want all of the original free space!
+ // (Their flex factors add up to something less than 1.)
+ // Hence, make sure we don't distribute any more than the portion of
+ // our original free space that these items actually want.
+ auto totalDesiredPortionOfOrigFreeSpace =
+ AuCoord64::FromRound(*origAvailableFreeSpace * flexFactorSum);
+
+ // Clamp availableFreeSpace to be no larger than that ^^.
+ // (using min or max, depending on sign).
+ // This should not change the sign of availableFreeSpace (except
+ // possibly by setting it to 0), as enforced by this assertion:
+ NS_ASSERTION(totalDesiredPortionOfOrigFreeSpace == AuCoord64(0) ||
+ ((totalDesiredPortionOfOrigFreeSpace > 0) ==
+ (availableFreeSpace > 0)),
+ "When we reduce available free space for flex "
+ "factors < 1, we shouldn't change the sign of the "
+ "free space...");
+
+ if (availableFreeSpace > 0) {
+ availableFreeSpace = std::min(availableFreeSpace,
+ totalDesiredPortionOfOrigFreeSpace);
+ } else {
+ availableFreeSpace = std::max(availableFreeSpace,
+ totalDesiredPortionOfOrigFreeSpace);
+ }
+ }
+
+ FLEX_LOG(" Distributing available space:");
+ // Since this loop only operates on unfrozen flex items, we can break as
+ // soon as we have seen all of them.
+ numUnfrozenItemsToBeSeen = NumItems() - mNumFrozenItems;
+
+ // NOTE: It's important that we traverse our items in *reverse* order
+ // here, for correct width distribution according to the items'
+ // "ShareOfWeightSoFar" progressively-calculated values.
+ for (FlexItem& item : Reversed(Items())) {
+ if (numUnfrozenItemsToBeSeen == 0) {
+ break;
+ }
+
+ if (!item.IsFrozen()) {
+ numUnfrozenItemsToBeSeen--;
+
+ // To avoid rounding issues, we compute the change in size for this
+ // item, and then subtract it from the remaining available space.
+ AuCoord64 sizeDelta = 0;
+ if (std::isfinite(weightSum)) {
+ double myShareOfRemainingSpace = item.ShareOfWeightSoFar();
+
+ MOZ_ASSERT(myShareOfRemainingSpace >= 0.0 &&
+ myShareOfRemainingSpace <= 1.0,
+ "my share should be nonnegative fractional amount");
+
+ if (myShareOfRemainingSpace == 1.0) {
+ // (We special-case 1.0 to avoid float error from converting
+ // availableFreeSpace from integer*1.0 --> double --> integer)
+ sizeDelta = availableFreeSpace;
+ } else if (myShareOfRemainingSpace > 0.0) {
+ sizeDelta = AuCoord64::FromRound(availableFreeSpace *
+ myShareOfRemainingSpace);
+ }
+ } else if (item.GetWeight(isUsingFlexGrow) == largestWeight) {
+ // Total flexibility is infinite, so we're just distributing
+ // the available space equally among the items that are tied for
+ // having the largest weight (and this is one of those items).
+ sizeDelta = AuCoord64::FromRound(
+ availableFreeSpace / double(numItemsWithLargestWeight));
+ numItemsWithLargestWeight--;
+ }
+
+ availableFreeSpace -= sizeDelta;
+
+ item.SetMainSize(item.MainSize() +
+ nscoord(sizeDelta.ToMinMaxClamped()));
+ FLEX_LOG(" flex item %p receives %" PRId64 ", for a total of %d",
+ item.Frame(), sizeDelta.value, item.MainSize());
+ }
+ }
+
+ MOZ_ASSERT(numUnfrozenItemsToBeSeen == 0, "miscounted frozen items?");
+
+ // If we have an aLineInfo structure to fill out, capture any
+ // size changes that may have occurred in the previous loop.
+ // We don't do this inside the previous loop, because we don't
+ // want to burden layout when aLineInfo is null.
+ if (aLineInfo) {
+ uint32_t itemIndex = 0;
+ for (FlexItem& item : Items()) {
+ if (!item.IsFrozen()) {
+ // Calculate a deltaSize that represents how much the flex sizing
+ // algorithm "wants" to stretch or shrink this item during this
+ // pass through the algorithm. Later passes through the algorithm
+ // may overwrite this, until this item is frozen. Note that this
+ // value may not reflect how much the size of the item is
+ // actually changed, since the size of the item will be clamped
+ // to min and max values later in this pass. That's intentional,
+ // since we want to report the value that the sizing algorithm
+ // tried to stretch or shrink the item.
+ nscoord deltaSize =
+ item.MainSize() - aLineInfo->mItems[itemIndex].mMainBaseSize;
+
+ aLineInfo->mItems[itemIndex].mMainDeltaSize = deltaSize;
+ }
+ ++itemIndex;
+ }
+ }
+ }
+ }
+
+ // Fix min/max violations:
+ nscoord totalViolation = 0; // keeps track of adjustments for min/max
+ FLEX_LOG(" Checking for violations:");
+
+ // Since this loop only operates on unfrozen flex items, we can break as
+ // soon as we have seen all of them.
+ uint32_t numUnfrozenItemsToBeSeen = NumItems() - mNumFrozenItems;
+ for (FlexItem& item : Items()) {
+ if (numUnfrozenItemsToBeSeen == 0) {
+ break;
+ }
+
+ if (!item.IsFrozen()) {
+ numUnfrozenItemsToBeSeen--;
+
+ if (item.MainSize() < item.MainMinSize()) {
+ // min violation
+ totalViolation += item.MainMinSize() - item.MainSize();
+ item.SetMainSize(item.MainMinSize());
+ item.SetHadMinViolation();
+ } else if (item.MainSize() > item.MainMaxSize()) {
+ // max violation
+ totalViolation += item.MainMaxSize() - item.MainSize();
+ item.SetMainSize(item.MainMaxSize());
+ item.SetHadMaxViolation();
+ }
+ }
+ }
+
+ MOZ_ASSERT(numUnfrozenItemsToBeSeen == 0, "miscounted frozen items?");
+
+ FreezeOrRestoreEachFlexibleSize(totalViolation,
+ iterationCounter + 1 == NumItems());
+
+ FLEX_LOG(" Total violation: %d", totalViolation);
+
+ if (mNumFrozenItems == NumItems()) {
+ break;
+ }
+
+ MOZ_ASSERT(totalViolation != 0,
+ "Zero violation should've made us freeze all items & break");
+ }
+
+#ifdef DEBUG
+ // Post-condition: all items should've been frozen.
+ // Make sure the counts match:
+ MOZ_ASSERT(mNumFrozenItems == NumItems(), "All items should be frozen");
+
+ // For good measure, check each item directly, in case our counts are busted:
+ for (const FlexItem& item : Items()) {
+ MOZ_ASSERT(item.IsFrozen(), "All items should be frozen");
+ }
+#endif // DEBUG
+}
+
+MainAxisPositionTracker::MainAxisPositionTracker(
+ const FlexboxAxisTracker& aAxisTracker, const FlexLine* aLine,
+ const StyleContentDistribution& aJustifyContent,
+ nscoord aContentBoxMainSize)
+ : PositionTracker(aAxisTracker.GetWritingMode(), aAxisTracker.MainAxis(),
+ aAxisTracker.IsMainAxisReversed()),
+ // we chip away at this below
+ mPackingSpaceRemaining(aContentBoxMainSize),
+ mJustifyContent(aJustifyContent) {
+ // Extract the flag portion of mJustifyContent and strip off the flag bits
+ // NOTE: This must happen before any assignment to mJustifyContent to
+ // avoid overwriting the flag bits.
+ StyleAlignFlags justifyContentFlags =
+ mJustifyContent.primary & StyleAlignFlags::FLAG_BITS;
+ mJustifyContent.primary &= ~StyleAlignFlags::FLAG_BITS;
+
+ // 'normal' behaves as 'stretch', and 'stretch' behaves as 'flex-start',
+ // in the main axis
+ // https://drafts.csswg.org/css-align-3/#propdef-justify-content
+ if (mJustifyContent.primary == StyleAlignFlags::NORMAL ||
+ mJustifyContent.primary == StyleAlignFlags::STRETCH) {
+ mJustifyContent.primary = StyleAlignFlags::FLEX_START;
+ }
+
+ // mPackingSpaceRemaining is initialized to the container's main size. Now
+ // we'll subtract out the main sizes of our flex items, so that it ends up
+ // with the *actual* amount of packing space.
+ for (const FlexItem& item : aLine->Items()) {
+ mPackingSpaceRemaining -= item.OuterMainSize();
+ mNumAutoMarginsInMainAxis += item.NumAutoMarginsInMainAxis();
+ }
+
+ // Subtract space required for row/col gap from the remaining packing space
+ mPackingSpaceRemaining -= aLine->SumOfGaps();
+
+ if (mPackingSpaceRemaining <= 0) {
+ // No available packing space to use for resolving auto margins.
+ mNumAutoMarginsInMainAxis = 0;
+ // If packing space is negative and <overflow-position> is set to 'safe'
+ // all justify options fall back to 'start'
+ if (justifyContentFlags & StyleAlignFlags::SAFE) {
+ mJustifyContent.primary = StyleAlignFlags::START;
+ }
+ }
+
+ // If packing space is negative or we only have one item, 'space-between'
+ // falls back to 'flex-start', and 'space-around' & 'space-evenly' fall back
+ // to 'center'. In those cases, it's simplest to just pretend we have a
+ // different 'justify-content' value and share code.
+ if (mPackingSpaceRemaining < 0 || aLine->NumItems() == 1) {
+ if (mJustifyContent.primary == StyleAlignFlags::SPACE_BETWEEN) {
+ mJustifyContent.primary = StyleAlignFlags::FLEX_START;
+ } else if (mJustifyContent.primary == StyleAlignFlags::SPACE_AROUND ||
+ mJustifyContent.primary == StyleAlignFlags::SPACE_EVENLY) {
+ mJustifyContent.primary = StyleAlignFlags::CENTER;
+ }
+ }
+
+ // Map 'left'/'right' to 'start'/'end'
+ if (mJustifyContent.primary == StyleAlignFlags::LEFT ||
+ mJustifyContent.primary == StyleAlignFlags::RIGHT) {
+ mJustifyContent.primary =
+ aAxisTracker.ResolveJustifyLeftRight(mJustifyContent.primary);
+ }
+
+ // Map 'start'/'end' to 'flex-start'/'flex-end'.
+ if (mJustifyContent.primary == StyleAlignFlags::START) {
+ mJustifyContent.primary = aAxisTracker.IsMainAxisReversed()
+ ? StyleAlignFlags::FLEX_END
+ : StyleAlignFlags::FLEX_START;
+ } else if (mJustifyContent.primary == StyleAlignFlags::END) {
+ mJustifyContent.primary = aAxisTracker.IsMainAxisReversed()
+ ? StyleAlignFlags::FLEX_START
+ : StyleAlignFlags::FLEX_END;
+ }
+
+ // Figure out how much space we'll set aside for auto margins or
+ // packing spaces, and advance past any leading packing-space.
+ if (mNumAutoMarginsInMainAxis == 0 && mPackingSpaceRemaining != 0 &&
+ !aLine->IsEmpty()) {
+ if (mJustifyContent.primary == StyleAlignFlags::FLEX_START) {
+ // All packing space should go at the end --> nothing to do here.
+ } else if (mJustifyContent.primary == StyleAlignFlags::FLEX_END) {
+ // All packing space goes at the beginning
+ mPosition += mPackingSpaceRemaining;
+ } else if (mJustifyContent.primary == StyleAlignFlags::CENTER) {
+ // Half the packing space goes at the beginning
+ mPosition += mPackingSpaceRemaining / 2;
+ } else if (mJustifyContent.primary == StyleAlignFlags::SPACE_BETWEEN ||
+ mJustifyContent.primary == StyleAlignFlags::SPACE_AROUND ||
+ mJustifyContent.primary == StyleAlignFlags::SPACE_EVENLY) {
+ nsFlexContainerFrame::CalculatePackingSpace(
+ aLine->NumItems(), mJustifyContent, &mPosition,
+ &mNumPackingSpacesRemaining, &mPackingSpaceRemaining);
+ } else {
+ MOZ_ASSERT_UNREACHABLE("Unexpected justify-content value");
+ }
+ }
+
+ MOZ_ASSERT(mNumPackingSpacesRemaining == 0 || mNumAutoMarginsInMainAxis == 0,
+ "extra space should either go to packing space or to "
+ "auto margins, but not to both");
+}
+
+void MainAxisPositionTracker::ResolveAutoMarginsInMainAxis(FlexItem& aItem) {
+ if (mNumAutoMarginsInMainAxis) {
+ const auto& styleMargin = aItem.Frame()->StyleMargin()->mMargin;
+ for (const auto side : {StartSide(), EndSide()}) {
+ if (styleMargin.Get(mWM, side).IsAuto()) {
+ // NOTE: This integer math will skew the distribution of remainder
+ // app-units towards the end, which is fine.
+ nscoord curAutoMarginSize =
+ mPackingSpaceRemaining / mNumAutoMarginsInMainAxis;
+
+ MOZ_ASSERT(aItem.GetMarginComponentForSide(side) == 0,
+ "Expecting auto margins to have value '0' before we "
+ "resolve them");
+ aItem.SetMarginComponentForSide(side, curAutoMarginSize);
+
+ mNumAutoMarginsInMainAxis--;
+ mPackingSpaceRemaining -= curAutoMarginSize;
+ }
+ }
+ }
+}
+
+void MainAxisPositionTracker::TraversePackingSpace() {
+ if (mNumPackingSpacesRemaining) {
+ MOZ_ASSERT(mJustifyContent.primary == StyleAlignFlags::SPACE_BETWEEN ||
+ mJustifyContent.primary == StyleAlignFlags::SPACE_AROUND ||
+ mJustifyContent.primary == StyleAlignFlags::SPACE_EVENLY,
+ "mNumPackingSpacesRemaining only applies for "
+ "space-between/space-around/space-evenly");
+
+ MOZ_ASSERT(mPackingSpaceRemaining >= 0,
+ "ran out of packing space earlier than we expected");
+
+ // NOTE: This integer math will skew the distribution of remainder
+ // app-units towards the end, which is fine.
+ nscoord curPackingSpace =
+ mPackingSpaceRemaining / mNumPackingSpacesRemaining;
+
+ mPosition += curPackingSpace;
+ mNumPackingSpacesRemaining--;
+ mPackingSpaceRemaining -= curPackingSpace;
+ }
+}
+
+CrossAxisPositionTracker::CrossAxisPositionTracker(
+ nsTArray<FlexLine>& aLines, const ReflowInput& aReflowInput,
+ nscoord aContentBoxCrossSize, bool aIsCrossSizeDefinite,
+ const FlexboxAxisTracker& aAxisTracker, const nscoord aCrossGapSize)
+ : PositionTracker(aAxisTracker.GetWritingMode(), aAxisTracker.CrossAxis(),
+ aAxisTracker.IsCrossAxisReversed()),
+ mAlignContent(aReflowInput.mStylePosition->mAlignContent),
+ mCrossGapSize(aCrossGapSize) {
+ // Extract and strip the flag bits from alignContent
+ StyleAlignFlags alignContentFlags =
+ mAlignContent.primary & StyleAlignFlags::FLAG_BITS;
+ mAlignContent.primary &= ~StyleAlignFlags::FLAG_BITS;
+
+ // 'normal' behaves as 'stretch'
+ if (mAlignContent.primary == StyleAlignFlags::NORMAL) {
+ mAlignContent.primary = StyleAlignFlags::STRETCH;
+ }
+
+ const bool isSingleLine =
+ StyleFlexWrap::Nowrap == aReflowInput.mStylePosition->mFlexWrap;
+ if (isSingleLine) {
+ MOZ_ASSERT(aLines.Length() == 1,
+ "If we're styled as single-line, we should only have 1 line");
+ // "If the flex container is single-line and has a definite cross size, the
+ // cross size of the flex line is the flex container's inner cross size."
+ //
+ // SOURCE: https://drafts.csswg.org/css-flexbox/#algo-cross-line
+ // NOTE: This means (by definition) that there's no packing space, which
+ // means we don't need to be concerned with "align-content" at all and we
+ // can return early. This is handy, because this is the usual case (for
+ // single-line flexbox).
+ if (aIsCrossSizeDefinite) {
+ aLines[0].SetLineCrossSize(aContentBoxCrossSize);
+ return;
+ }
+
+ // "If the flex container is single-line, then clamp the line's
+ // cross-size to be within the container's computed min and max cross-size
+ // properties."
+ aLines[0].SetLineCrossSize(NS_CSS_MINMAX(aLines[0].LineCrossSize(),
+ aReflowInput.ComputedMinBSize(),
+ aReflowInput.ComputedMaxBSize()));
+ }
+
+ // NOTE: The rest of this function should essentially match
+ // MainAxisPositionTracker's constructor, though with FlexLines instead of
+ // FlexItems, and with the additional value "stretch" (and of course with
+ // cross sizes instead of main sizes.)
+
+ // Figure out how much packing space we have (container's cross size minus
+ // all the lines' cross sizes). Also, share this loop to count how many
+ // lines we have. (We need that count in some cases below.)
+ mPackingSpaceRemaining = aContentBoxCrossSize;
+ uint32_t numLines = 0;
+ for (FlexLine& line : aLines) {
+ mPackingSpaceRemaining -= line.LineCrossSize();
+ numLines++;
+ }
+
+ // Subtract space required for row/col gap from the remaining packing space
+ MOZ_ASSERT(numLines >= 1,
+ "GenerateFlexLines should've produced at least 1 line");
+ mPackingSpaceRemaining -= aCrossGapSize * (numLines - 1);
+
+ // If <overflow-position> is 'safe' and packing space is negative
+ // all align options fall back to 'start'
+ if ((alignContentFlags & StyleAlignFlags::SAFE) &&
+ mPackingSpaceRemaining < 0) {
+ mAlignContent.primary = StyleAlignFlags::START;
+ }
+
+ // If packing space is negative, 'space-between' and 'stretch' behave like
+ // 'flex-start', and 'space-around' and 'space-evenly' behave like 'center'.
+ // In those cases, it's simplest to just pretend we have a different
+ // 'align-content' value and share code. (If we only have one line, all of
+ // the 'space-*' keywords fall back as well, but 'stretch' doesn't because
+ // even a single line can still stretch.)
+ if (mPackingSpaceRemaining < 0 &&
+ mAlignContent.primary == StyleAlignFlags::STRETCH) {
+ mAlignContent.primary = StyleAlignFlags::FLEX_START;
+ } else if (mPackingSpaceRemaining < 0 || numLines == 1) {
+ if (mAlignContent.primary == StyleAlignFlags::SPACE_BETWEEN) {
+ mAlignContent.primary = StyleAlignFlags::FLEX_START;
+ } else if (mAlignContent.primary == StyleAlignFlags::SPACE_AROUND ||
+ mAlignContent.primary == StyleAlignFlags::SPACE_EVENLY) {
+ mAlignContent.primary = StyleAlignFlags::CENTER;
+ }
+ }
+
+ // Map 'start'/'end' to 'flex-start'/'flex-end'.
+ if (mAlignContent.primary == StyleAlignFlags::START) {
+ mAlignContent.primary = aAxisTracker.IsCrossAxisReversed()
+ ? StyleAlignFlags::FLEX_END
+ : StyleAlignFlags::FLEX_START;
+ } else if (mAlignContent.primary == StyleAlignFlags::END) {
+ mAlignContent.primary = aAxisTracker.IsCrossAxisReversed()
+ ? StyleAlignFlags::FLEX_START
+ : StyleAlignFlags::FLEX_END;
+ }
+
+ // Figure out how much space we'll set aside for packing spaces, and advance
+ // past any leading packing-space.
+ if (mPackingSpaceRemaining != 0) {
+ if (mAlignContent.primary == StyleAlignFlags::BASELINE ||
+ mAlignContent.primary == StyleAlignFlags::LAST_BASELINE) {
+ // TODO: Bug 1480850 will implement 'align-content: [first/last] baseline'
+ // for flexbox. Until then, behaves as if align-content is 'flex-start' by
+ // doing nothing.
+ } else if (mAlignContent.primary == StyleAlignFlags::FLEX_START) {
+ // All packing space should go at the end --> nothing to do here.
+ } else if (mAlignContent.primary == StyleAlignFlags::FLEX_END) {
+ // All packing space goes at the beginning
+ mPosition += mPackingSpaceRemaining;
+ } else if (mAlignContent.primary == StyleAlignFlags::CENTER) {
+ // Half the packing space goes at the beginning
+ mPosition += mPackingSpaceRemaining / 2;
+ } else if (mAlignContent.primary == StyleAlignFlags::SPACE_BETWEEN ||
+ mAlignContent.primary == StyleAlignFlags::SPACE_AROUND ||
+ mAlignContent.primary == StyleAlignFlags::SPACE_EVENLY) {
+ nsFlexContainerFrame::CalculatePackingSpace(
+ numLines, mAlignContent, &mPosition, &mNumPackingSpacesRemaining,
+ &mPackingSpaceRemaining);
+ } else if (mAlignContent.primary == StyleAlignFlags::STRETCH) {
+ // Split space equally between the lines:
+ MOZ_ASSERT(mPackingSpaceRemaining > 0,
+ "negative packing space should make us use 'flex-start' "
+ "instead of 'stretch' (and we shouldn't bother with this "
+ "code if we have 0 packing space)");
+
+ uint32_t numLinesLeft = numLines;
+ for (FlexLine& line : aLines) {
+ // Our share is the amount of space remaining, divided by the number
+ // of lines remainig.
+ MOZ_ASSERT(numLinesLeft > 0, "miscalculated num lines");
+ nscoord shareOfExtraSpace = mPackingSpaceRemaining / numLinesLeft;
+ nscoord newSize = line.LineCrossSize() + shareOfExtraSpace;
+ line.SetLineCrossSize(newSize);
+
+ mPackingSpaceRemaining -= shareOfExtraSpace;
+ numLinesLeft--;
+ }
+ MOZ_ASSERT(numLinesLeft == 0, "miscalculated num lines");
+ } else {
+ MOZ_ASSERT_UNREACHABLE("Unexpected align-content value");
+ }
+ }
+}
+
+void CrossAxisPositionTracker::TraversePackingSpace() {
+ if (mNumPackingSpacesRemaining) {
+ MOZ_ASSERT(mAlignContent.primary == StyleAlignFlags::SPACE_BETWEEN ||
+ mAlignContent.primary == StyleAlignFlags::SPACE_AROUND ||
+ mAlignContent.primary == StyleAlignFlags::SPACE_EVENLY,
+ "mNumPackingSpacesRemaining only applies for "
+ "space-between/space-around/space-evenly");
+
+ MOZ_ASSERT(mPackingSpaceRemaining >= 0,
+ "ran out of packing space earlier than we expected");
+
+ // NOTE: This integer math will skew the distribution of remainder
+ // app-units towards the end, which is fine.
+ nscoord curPackingSpace =
+ mPackingSpaceRemaining / mNumPackingSpacesRemaining;
+
+ mPosition += curPackingSpace;
+ mNumPackingSpacesRemaining--;
+ mPackingSpaceRemaining -= curPackingSpace;
+ }
+}
+
+SingleLineCrossAxisPositionTracker::SingleLineCrossAxisPositionTracker(
+ const FlexboxAxisTracker& aAxisTracker)
+ : PositionTracker(aAxisTracker.GetWritingMode(), aAxisTracker.CrossAxis(),
+ aAxisTracker.IsCrossAxisReversed()) {}
+
+void FlexLine::ComputeCrossSizeAndBaseline(
+ const FlexboxAxisTracker& aAxisTracker) {
+ nscoord crossStartToFurthestFirstBaseline = nscoord_MIN;
+ nscoord crossEndToFurthestFirstBaseline = nscoord_MIN;
+ nscoord crossStartToFurthestLastBaseline = nscoord_MIN;
+ nscoord crossEndToFurthestLastBaseline = nscoord_MIN;
+ nscoord largestOuterCrossSize = 0;
+ for (const FlexItem& item : Items()) {
+ nscoord curOuterCrossSize = item.OuterCrossSize();
+
+ if ((item.AlignSelf()._0 == StyleAlignFlags::BASELINE ||
+ item.AlignSelf()._0 == StyleAlignFlags::LAST_BASELINE) &&
+ item.NumAutoMarginsInCrossAxis() == 0) {
+ const bool useFirst = (item.AlignSelf()._0 == StyleAlignFlags::BASELINE);
+ // FIXME: Once we support "writing-mode", we'll have to do baseline
+ // alignment in vertical flex containers here (w/ horizontal cross-axes).
+
+ // Find distance from our item's cross-start and cross-end margin-box
+ // edges to its baseline.
+ //
+ // Here's a diagram of a flex-item that we might be doing this on.
+ // "mmm" is the margin-box, "bbb" is the border-box. The bottom of
+ // the text "BASE" is the baseline.
+ //
+ // ---(cross-start)---
+ // ___ ___ ___
+ // mmmmmmmmmmmm | |margin-start |
+ // m m | _|_ ___ |
+ // m bbbbbbbb m |curOuterCrossSize | |crossStartToBaseline
+ // m b b m | |ascent |
+ // m b BASE b m | _|_ _|_
+ // m b b m | |
+ // m bbbbbbbb m | |crossEndToBaseline
+ // m m | |
+ // mmmmmmmmmmmm _|_ _|_
+ //
+ // ---(cross-end)---
+ //
+ // We already have the curOuterCrossSize, margin-start, and the ascent.
+ // * We can get crossStartToBaseline by adding margin-start + ascent.
+ // * If we subtract that from the curOuterCrossSize, we get
+ // crossEndToBaseline.
+
+ nscoord crossStartToBaseline = item.BaselineOffsetFromOuterCrossEdge(
+ aAxisTracker.CrossAxisPhysicalStartSide(), useFirst);
+ nscoord crossEndToBaseline = curOuterCrossSize - crossStartToBaseline;
+
+ // Now, update our "largest" values for these (across all the flex items
+ // in this flex line), so we can use them in computing the line's cross
+ // size below:
+ if (useFirst) {
+ crossStartToFurthestFirstBaseline =
+ std::max(crossStartToFurthestFirstBaseline, crossStartToBaseline);
+ crossEndToFurthestFirstBaseline =
+ std::max(crossEndToFurthestFirstBaseline, crossEndToBaseline);
+ } else {
+ crossStartToFurthestLastBaseline =
+ std::max(crossStartToFurthestLastBaseline, crossStartToBaseline);
+ crossEndToFurthestLastBaseline =
+ std::max(crossEndToFurthestLastBaseline, crossEndToBaseline);
+ }
+ } else {
+ largestOuterCrossSize =
+ std::max(largestOuterCrossSize, curOuterCrossSize);
+ }
+ }
+
+ // The line's baseline offset is the distance from the line's edge to the
+ // furthest item-baseline. The item(s) with that baseline will be exactly
+ // aligned with the line's edge.
+ mFirstBaselineOffset = crossStartToFurthestFirstBaseline;
+ mLastBaselineOffset = crossEndToFurthestLastBaseline;
+
+ // The line's cross-size is the larger of:
+ // (a) [largest cross-start-to-baseline + largest baseline-to-cross-end] of
+ // all baseline-aligned items with no cross-axis auto margins...
+ // and
+ // (b) [largest cross-start-to-baseline + largest baseline-to-cross-end] of
+ // all last baseline-aligned items with no cross-axis auto margins...
+ // and
+ // (c) largest cross-size of all other children.
+ mLineCrossSize = std::max(
+ std::max(
+ crossStartToFurthestFirstBaseline + crossEndToFurthestFirstBaseline,
+ crossStartToFurthestLastBaseline + crossEndToFurthestLastBaseline),
+ largestOuterCrossSize);
+}
+
+void FlexItem::ResolveStretchedCrossSize(nscoord aLineCrossSize) {
+ // We stretch IFF we are align-self:stretch, have no auto margins in
+ // cross axis, and have cross-axis size property == "auto". If any of those
+ // conditions don't hold up, we won't stretch.
+ if (mAlignSelf._0 != StyleAlignFlags::STRETCH ||
+ NumAutoMarginsInCrossAxis() != 0 || !IsCrossSizeAuto()) {
+ return;
+ }
+
+ // If we've already been stretched, we can bail out early, too.
+ // No need to redo the calculation.
+ if (mIsStretched) {
+ return;
+ }
+
+ // Reserve space for margins & border & padding, and then use whatever
+ // remains as our item's cross-size (clamped to its min/max range).
+ nscoord stretchedSize = aLineCrossSize - MarginBorderPaddingSizeInCrossAxis();
+
+ stretchedSize = NS_CSS_MINMAX(stretchedSize, mCrossMinSize, mCrossMaxSize);
+
+ // Update the cross-size & make a note that it's stretched, so we know to
+ // override the reflow input's computed cross-size in our final reflow.
+ SetCrossSize(stretchedSize);
+ mIsStretched = true;
+}
+
+static nsBlockFrame* FindFlexItemBlockFrame(nsIFrame* aFrame) {
+ if (nsBlockFrame* block = do_QueryFrame(aFrame)) {
+ return block;
+ }
+ for (nsIFrame* f : aFrame->PrincipalChildList()) {
+ if (nsBlockFrame* block = FindFlexItemBlockFrame(f)) {
+ return block;
+ }
+ }
+ return nullptr;
+}
+
+nsBlockFrame* FlexItem::BlockFrame() const {
+ return FindFlexItemBlockFrame(Frame());
+}
+
+void SingleLineCrossAxisPositionTracker::ResolveAutoMarginsInCrossAxis(
+ const FlexLine& aLine, FlexItem& aItem) {
+ // Subtract the space that our item is already occupying, to see how much
+ // space (if any) is available for its auto margins.
+ nscoord spaceForAutoMargins = aLine.LineCrossSize() - aItem.OuterCrossSize();
+
+ if (spaceForAutoMargins <= 0) {
+ return; // No available space --> nothing to do
+ }
+
+ uint32_t numAutoMargins = aItem.NumAutoMarginsInCrossAxis();
+ if (numAutoMargins == 0) {
+ return; // No auto margins --> nothing to do.
+ }
+
+ // OK, we have at least one auto margin and we have some available space.
+ // Give each auto margin a share of the space.
+ const auto& styleMargin = aItem.Frame()->StyleMargin()->mMargin;
+ for (const auto side : {StartSide(), EndSide()}) {
+ if (styleMargin.Get(mWM, side).IsAuto()) {
+ MOZ_ASSERT(aItem.GetMarginComponentForSide(side) == 0,
+ "Expecting auto margins to have value '0' before we "
+ "update them");
+
+ // NOTE: integer divison is fine here; numAutoMargins is either 1 or 2.
+ // If it's 2 & spaceForAutoMargins is odd, 1st margin gets smaller half.
+ nscoord curAutoMarginSize = spaceForAutoMargins / numAutoMargins;
+ aItem.SetMarginComponentForSide(side, curAutoMarginSize);
+ numAutoMargins--;
+ spaceForAutoMargins -= curAutoMarginSize;
+ }
+ }
+}
+
+void SingleLineCrossAxisPositionTracker::EnterAlignPackingSpace(
+ const FlexLine& aLine, const FlexItem& aItem,
+ const FlexboxAxisTracker& aAxisTracker) {
+ // We don't do align-self alignment on items that have auto margins
+ // in the cross axis.
+ if (aItem.NumAutoMarginsInCrossAxis()) {
+ return;
+ }
+
+ StyleAlignFlags alignSelf = aItem.AlignSelf()._0;
+ // NOTE: 'stretch' behaves like 'flex-start' once we've stretched any
+ // auto-sized items (which we've already done).
+ if (alignSelf == StyleAlignFlags::STRETCH) {
+ alignSelf = StyleAlignFlags::FLEX_START;
+ }
+
+ // Map 'self-start'/'self-end' to 'start'/'end'
+ if (alignSelf == StyleAlignFlags::SELF_START ||
+ alignSelf == StyleAlignFlags::SELF_END) {
+ const LogicalAxis logCrossAxis =
+ aAxisTracker.IsRowOriented() ? eLogicalAxisBlock : eLogicalAxisInline;
+ const WritingMode cWM = aAxisTracker.GetWritingMode();
+ const bool sameStart =
+ cWM.ParallelAxisStartsOnSameSide(logCrossAxis, aItem.GetWritingMode());
+ alignSelf = sameStart == (alignSelf == StyleAlignFlags::SELF_START)
+ ? StyleAlignFlags::START
+ : StyleAlignFlags::END;
+ }
+
+ // Map 'start'/'end' to 'flex-start'/'flex-end'.
+ if (alignSelf == StyleAlignFlags::START) {
+ alignSelf = aAxisTracker.IsCrossAxisReversed()
+ ? StyleAlignFlags::FLEX_END
+ : StyleAlignFlags::FLEX_START;
+ } else if (alignSelf == StyleAlignFlags::END) {
+ alignSelf = aAxisTracker.IsCrossAxisReversed() ? StyleAlignFlags::FLEX_START
+ : StyleAlignFlags::FLEX_END;
+ }
+
+ // 'align-self' falls back to 'flex-start' if it is 'center'/'flex-end' and we
+ // have cross axis overflow
+ // XXX we should really be falling back to 'start' as of bug 1472843
+ if (aLine.LineCrossSize() < aItem.OuterCrossSize() &&
+ (aItem.AlignSelfFlags() & StyleAlignFlags::SAFE)) {
+ alignSelf = StyleAlignFlags::FLEX_START;
+ }
+
+ if (alignSelf == StyleAlignFlags::FLEX_START) {
+ // No space to skip over -- we're done.
+ } else if (alignSelf == StyleAlignFlags::FLEX_END) {
+ mPosition += aLine.LineCrossSize() - aItem.OuterCrossSize();
+ } else if (alignSelf == StyleAlignFlags::CENTER) {
+ // Note: If cross-size is odd, the "after" space will get the extra unit.
+ mPosition += (aLine.LineCrossSize() - aItem.OuterCrossSize()) / 2;
+ } else if (alignSelf == StyleAlignFlags::BASELINE ||
+ alignSelf == StyleAlignFlags::LAST_BASELINE) {
+ const bool useFirst = (alignSelf == StyleAlignFlags::BASELINE);
+
+ // Baseline-aligned items are collectively aligned with the line's physical
+ // cross-start or cross-end side, depending on whether we're doing
+ // first-baseline or last-baseline alignment.
+ const mozilla::Side baselineAlignStartSide =
+ useFirst ? aAxisTracker.CrossAxisPhysicalStartSide()
+ : aAxisTracker.CrossAxisPhysicalEndSide();
+
+ nscoord itemBaselineOffset = aItem.BaselineOffsetFromOuterCrossEdge(
+ baselineAlignStartSide, useFirst);
+
+ nscoord lineBaselineOffset =
+ useFirst ? aLine.FirstBaselineOffset() : aLine.LastBaselineOffset();
+
+ NS_ASSERTION(lineBaselineOffset >= itemBaselineOffset,
+ "failed at finding largest baseline offset");
+
+ // How much do we need to adjust our position (from the line edge),
+ // to get the item's baseline to hit the line's baseline offset:
+ nscoord baselineDiff = lineBaselineOffset - itemBaselineOffset;
+
+ if (useFirst) {
+ // mPosition is already at line's flex-start edge.
+ // From there, we step *forward* by the baseline adjustment:
+ mPosition += baselineDiff;
+ } else {
+ // Advance to align item w/ line's flex-end edge (as in FLEX_END case):
+ mPosition += aLine.LineCrossSize() - aItem.OuterCrossSize();
+ // ...and step *back* by the baseline adjustment:
+ mPosition -= baselineDiff;
+ }
+ } else {
+ MOZ_ASSERT_UNREACHABLE("Unexpected align-self value");
+ }
+}
+
+FlexboxAxisInfo::FlexboxAxisInfo(const nsIFrame* aFlexContainer) {
+ MOZ_ASSERT(aFlexContainer && aFlexContainer->IsFlexContainerFrame(),
+ "Only flex containers may be passed to this constructor!");
+ if (IsLegacyBox(aFlexContainer)) {
+ InitAxesFromLegacyProps(aFlexContainer);
+ } else {
+ InitAxesFromModernProps(aFlexContainer);
+ }
+}
+
+void FlexboxAxisInfo::InitAxesFromLegacyProps(const nsIFrame* aFlexContainer) {
+ const nsStyleXUL* styleXUL = aFlexContainer->StyleXUL();
+
+ const bool boxOrientIsVertical =
+ styleXUL->mBoxOrient == StyleBoxOrient::Vertical;
+ const bool wmIsVertical = aFlexContainer->GetWritingMode().IsVertical();
+
+ // If box-orient agrees with our writing-mode, then we're "row-oriented"
+ // (i.e. the flexbox main axis is the same as our writing mode's inline
+ // direction). Otherwise, we're column-oriented (i.e. the flexbox's main
+ // axis is perpendicular to the writing-mode's inline direction).
+ mIsRowOriented = (boxOrientIsVertical == wmIsVertical);
+
+ // Legacy flexbox can use "-webkit-box-direction: reverse" to reverse the
+ // main axis (so it runs in the reverse direction of the inline axis):
+ mIsMainAxisReversed = styleXUL->mBoxDirection == StyleBoxDirection::Reverse;
+
+ // Legacy flexbox does not support reversing the cross axis -- it has no
+ // equivalent of modern flexbox's "flex-wrap: wrap-reverse".
+ mIsCrossAxisReversed = false;
+}
+
+void FlexboxAxisInfo::InitAxesFromModernProps(const nsIFrame* aFlexContainer) {
+ const nsStylePosition* stylePos = aFlexContainer->StylePosition();
+ StyleFlexDirection flexDirection = stylePos->mFlexDirection;
+
+ // Determine main axis:
+ switch (flexDirection) {
+ case StyleFlexDirection::Row:
+ mIsRowOriented = true;
+ mIsMainAxisReversed = false;
+ break;
+ case StyleFlexDirection::RowReverse:
+ mIsRowOriented = true;
+ mIsMainAxisReversed = true;
+ break;
+ case StyleFlexDirection::Column:
+ mIsRowOriented = false;
+ mIsMainAxisReversed = false;
+ break;
+ case StyleFlexDirection::ColumnReverse:
+ mIsRowOriented = false;
+ mIsMainAxisReversed = true;
+ break;
+ }
+
+ // "flex-wrap: wrap-reverse" reverses our cross axis.
+ mIsCrossAxisReversed = stylePos->mFlexWrap == StyleFlexWrap::WrapReverse;
+}
+
+FlexboxAxisTracker::FlexboxAxisTracker(
+ const nsFlexContainerFrame* aFlexContainer)
+ : mWM(aFlexContainer->GetWritingMode()), mAxisInfo(aFlexContainer) {}
+
+LogicalSide FlexboxAxisTracker::MainAxisStartSide() const {
+ return MakeLogicalSide(
+ MainAxis(), IsMainAxisReversed() ? eLogicalEdgeEnd : eLogicalEdgeStart);
+}
+
+LogicalSide FlexboxAxisTracker::CrossAxisStartSide() const {
+ return MakeLogicalSide(
+ CrossAxis(), IsCrossAxisReversed() ? eLogicalEdgeEnd : eLogicalEdgeStart);
+}
+
+void nsFlexContainerFrame::GenerateFlexLines(
+ const ReflowInput& aReflowInput, const nscoord aTentativeContentBoxMainSize,
+ const nscoord aTentativeContentBoxCrossSize,
+ const nsTArray<StrutInfo>& aStruts, const FlexboxAxisTracker& aAxisTracker,
+ nscoord aMainGapSize, nsTArray<nsIFrame*>& aPlaceholders,
+ nsTArray<FlexLine>& aLines, bool& aHasCollapsedItems) {
+ MOZ_ASSERT(aLines.IsEmpty(), "Expecting outparam to start out empty");
+
+ auto ConstructNewFlexLine = [&aLines, aMainGapSize]() {
+ return aLines.EmplaceBack(aMainGapSize);
+ };
+
+ const bool isSingleLine =
+ StyleFlexWrap::Nowrap == aReflowInput.mStylePosition->mFlexWrap;
+
+ // We have at least one FlexLine. Even an empty flex container has a single
+ // (empty) flex line.
+ FlexLine* curLine = ConstructNewFlexLine();
+
+ nscoord wrapThreshold;
+ if (isSingleLine) {
+ // Not wrapping. Set threshold to sentinel value that tells us not to wrap.
+ wrapThreshold = NS_UNCONSTRAINEDSIZE;
+ } else {
+ // Wrapping! Set wrap threshold to flex container's content-box main-size.
+ wrapThreshold = aTentativeContentBoxMainSize;
+
+ // If the flex container doesn't have a definite content-box main-size
+ // (e.g. if main axis is vertical & 'height' is 'auto'), make sure we at
+ // least wrap when we hit its max main-size.
+ if (wrapThreshold == NS_UNCONSTRAINEDSIZE) {
+ const nscoord flexContainerMaxMainSize =
+ aAxisTracker.MainComponent(aReflowInput.ComputedMaxSize());
+ wrapThreshold = flexContainerMaxMainSize;
+ }
+ }
+
+ // Tracks the index of the next strut, in aStruts (and when this hits
+ // aStruts.Length(), that means there are no more struts):
+ uint32_t nextStrutIdx = 0;
+
+ // Overall index of the current flex item in the flex container. (This gets
+ // checked against entries in aStruts.)
+ uint32_t itemIdxInContainer = 0;
+
+ CSSOrderAwareFrameIterator iter(
+ this, FrameChildListID::Principal,
+ CSSOrderAwareFrameIterator::ChildFilter::IncludeAll,
+ CSSOrderAwareFrameIterator::OrderState::Unknown,
+ OrderingPropertyForIter(this));
+
+ AddOrRemoveStateBits(NS_STATE_FLEX_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER,
+ iter.ItemsAreAlreadyInOrder());
+
+ const bool useMozBoxCollapseBehavior =
+ StyleVisibility()->UseLegacyCollapseBehavior();
+
+ for (; !iter.AtEnd(); iter.Next()) {
+ nsIFrame* childFrame = *iter;
+ // Don't create flex items / lines for placeholder frames:
+ if (childFrame->IsPlaceholderFrame()) {
+ aPlaceholders.AppendElement(childFrame);
+ continue;
+ }
+
+ const bool collapsed = childFrame->StyleVisibility()->IsCollapse();
+ aHasCollapsedItems = aHasCollapsedItems || collapsed;
+
+ if (useMozBoxCollapseBehavior && collapsed) {
+ // Legacy visibility:collapse behavior: make a 0-sized strut. (No need to
+ // bother with aStruts and remembering cross size.)
+ curLine->Items().EmplaceBack(childFrame, 0, aReflowInput.GetWritingMode(),
+ aAxisTracker);
+ } else if (nextStrutIdx < aStruts.Length() &&
+ aStruts[nextStrutIdx].mItemIdx == itemIdxInContainer) {
+ // Use the simplified "strut" FlexItem constructor:
+ curLine->Items().EmplaceBack(childFrame,
+ aStruts[nextStrutIdx].mStrutCrossSize,
+ aReflowInput.GetWritingMode(), aAxisTracker);
+ nextStrutIdx++;
+ } else {
+ GenerateFlexItemForChild(*curLine, childFrame, aReflowInput, aAxisTracker,
+ aTentativeContentBoxCrossSize);
+ }
+
+ // Check if we need to wrap the newly appended item to a new line, i.e. if
+ // its outer hypothetical main size pushes our line over the threshold.
+ // But we don't wrap if the line-length is unconstrained, nor do we wrap if
+ // this was the first item on the line.
+ if (wrapThreshold != NS_UNCONSTRAINEDSIZE &&
+ curLine->Items().Length() > 1) {
+ // If the line will be longer than wrapThreshold or at least as long as
+ // nscoord_MAX because of the newly appended item, then wrap and move the
+ // item to a new line.
+ auto newOuterSize = curLine->TotalOuterHypotheticalMainSize();
+ newOuterSize += curLine->Items().LastElement().OuterMainSize();
+
+ // Account for gap between this line's previous item and this item.
+ newOuterSize += aMainGapSize;
+
+ if (newOuterSize >= nscoord_MAX || newOuterSize > wrapThreshold) {
+ curLine = ConstructNewFlexLine();
+
+ // Get the previous line after adding a new line because the address can
+ // change if nsTArray needs to reallocate a new space for the new line.
+ FlexLine& prevLine = aLines[aLines.Length() - 2];
+
+ // Move the item from the end of prevLine to the end of curLine.
+ curLine->Items().AppendElement(prevLine.Items().PopLastElement());
+ }
+ }
+
+ // Update the line's bookkeeping about how large its items collectively are.
+ curLine->AddLastItemToMainSizeTotals();
+ itemIdxInContainer++;
+ }
+}
+
+nsFlexContainerFrame::FlexLayoutResult
+nsFlexContainerFrame::GenerateFlexLayoutResult() {
+ MOZ_ASSERT(GetPrevInFlow(), "This should be called by non-first-in-flows!");
+
+ auto* data = FirstInFlow()->GetProperty(SharedFlexData::Prop());
+ MOZ_ASSERT(data, "SharedFlexData should be set by our first-in-flow!");
+
+ FlexLayoutResult flr;
+
+ // The order state of the children is consistent across entire continuation
+ // chain due to calling nsContainerFrame::NormalizeChildLists() at the
+ // beginning of Reflow(), so we can align our state bit with our
+ // prev-in-flow's state. Setup here before calling OrderStateForIter() below.
+ AddOrRemoveStateBits(NS_STATE_FLEX_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER,
+ GetPrevInFlow()->HasAnyStateBits(
+ NS_STATE_FLEX_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER));
+
+ // Construct flex items for this flex container fragment from existing flex
+ // items in SharedFlexData.
+ CSSOrderAwareFrameIterator iter(
+ this, FrameChildListID::Principal,
+ CSSOrderAwareFrameIterator::ChildFilter::SkipPlaceholders,
+ OrderStateForIter(this), OrderingPropertyForIter(this));
+
+ auto ConstructNewFlexLine = [&flr]() {
+ // Use zero main gap size since it doesn't matter in flex container's
+ // next-in-flows. We've computed flex items' positions in first-in-flow.
+ return flr.mLines.EmplaceBack(0);
+ };
+
+ // We have at least one FlexLine. Even an empty flex container has a single
+ // (empty) flex line.
+ FlexLine* currentLine = ConstructNewFlexLine();
+
+ if (!iter.AtEnd()) {
+ nsIFrame* child = *iter;
+ nsIFrame* childFirstInFlow = child->FirstInFlow();
+
+ // We are iterating nested for-loops over the FlexLines and FlexItems
+ // generated by GenerateFlexLines() and cached in flex container's
+ // first-in-flow. For each flex item, check if its frame (must be a
+ // first-in-flow) is the first-in-flow of the first child frame in this flex
+ // container continuation. If so, clone the data from that FlexItem into a
+ // FlexLine. When we find a match for the item, we know that the next child
+ // frame might have its first-in-flow as the next item in the same original
+ // line. In this case, we'll put the cloned data in the same line here as
+ // well.
+ for (const FlexLine& line : data->mLines) {
+ // If currentLine is empty, either it is the first line, or all the items
+ // in the previous line have been placed in our prev-in-flows. No need to
+ // construct a new line.
+ if (!currentLine->IsEmpty()) {
+ currentLine = ConstructNewFlexLine();
+ }
+ for (const FlexItem& item : line.Items()) {
+ if (item.Frame() == childFirstInFlow) {
+ currentLine->Items().AppendElement(item.CloneFor(child));
+ iter.Next();
+ if (iter.AtEnd()) {
+ // We've constructed flex items for all children. No need to check
+ // rest of the items.
+ child = childFirstInFlow = nullptr;
+ break;
+ }
+ child = *iter;
+ childFirstInFlow = child->FirstInFlow();
+ }
+ }
+ if (iter.AtEnd()) {
+ // We've constructed flex items for all children. No need to check
+ // rest of the lines.
+ break;
+ }
+ }
+ }
+
+ flr.mContentBoxMainSize = data->mContentBoxMainSize;
+ flr.mContentBoxCrossSize = data->mContentBoxCrossSize;
+
+ return flr;
+}
+
+// Returns the largest outer hypothetical main-size of any line in |aLines|.
+// (i.e. the hypothetical main-size of the largest line)
+static AuCoord64 GetLargestLineMainSize(nsTArray<FlexLine>& aLines) {
+ AuCoord64 largestLineOuterSize = 0;
+ for (const FlexLine& line : aLines) {
+ largestLineOuterSize =
+ std::max(largestLineOuterSize, line.TotalOuterHypotheticalMainSize());
+ }
+ return largestLineOuterSize;
+}
+
+nscoord nsFlexContainerFrame::ComputeMainSize(
+ const ReflowInput& aReflowInput, const FlexboxAxisTracker& aAxisTracker,
+ const nscoord aTentativeContentBoxMainSize,
+ nsTArray<FlexLine>& aLines) const {
+ if (aAxisTracker.IsRowOriented()) {
+ // Row-oriented --> our main axis is the inline axis, so our main size
+ // is our inline size (which should already be resolved).
+ return aTentativeContentBoxMainSize;
+ }
+
+ const bool shouldApplyAutomaticMinimumOnBlockAxis =
+ aReflowInput.ShouldApplyAutomaticMinimumOnBlockAxis();
+ if (aTentativeContentBoxMainSize != NS_UNCONSTRAINEDSIZE &&
+ !shouldApplyAutomaticMinimumOnBlockAxis) {
+ // Column-oriented case, with fixed BSize:
+ // Just use our fixed block-size because we always assume the available
+ // block-size is unconstrained, and the reflow input has already done the
+ // appropriate min/max-BSize clamping.
+ return aTentativeContentBoxMainSize;
+ }
+
+ // Column-oriented case, with size-containment in block axis:
+ // Behave as if we had no content and just use our MinBSize.
+ if (Maybe<nscoord> containBSize =
+ aReflowInput.mFrame->ContainIntrinsicBSize()) {
+ return NS_CSS_MINMAX(*containBSize, aReflowInput.ComputedMinBSize(),
+ aReflowInput.ComputedMaxBSize());
+ }
+
+ const AuCoord64 largestLineMainSize = GetLargestLineMainSize(aLines);
+ const nscoord contentBSize = NS_CSS_MINMAX(
+ nscoord(largestLineMainSize.ToMinMaxClamped()),
+ aReflowInput.ComputedMinBSize(), aReflowInput.ComputedMaxBSize());
+ // If the clamped largest FlexLine length is larger than the tentative main
+ // size (which is resolved by aspect-ratio), we extend it to contain the
+ // entire FlexLine.
+ // https://drafts.csswg.org/css-sizing-4/#aspect-ratio-minimum
+ if (shouldApplyAutomaticMinimumOnBlockAxis) {
+ // Column-oriented case, with auto BSize which is resolved by
+ // aspect-ratio.
+ return std::max(contentBSize, aTentativeContentBoxMainSize);
+ }
+
+ // Column-oriented case, with auto BSize:
+ // Resolve auto BSize to the largest FlexLine length, clamped to our
+ // computed min/max main-size properties.
+ return contentBSize;
+}
+
+nscoord nsFlexContainerFrame::ComputeCrossSize(
+ const ReflowInput& aReflowInput, const FlexboxAxisTracker& aAxisTracker,
+ const nscoord aTentativeContentBoxCrossSize, nscoord aSumLineCrossSizes,
+ bool* aIsDefinite) const {
+ MOZ_ASSERT(aIsDefinite, "outparam pointer must be non-null");
+
+ if (aAxisTracker.IsColumnOriented()) {
+ // Column-oriented --> our cross axis is the inline axis, so our cross size
+ // is our inline size (which should already be resolved).
+ *aIsDefinite = true;
+ // FIXME: Bug 1661847 - there are cases where aTentativeContentBoxCrossSize
+ // (i.e. aReflowInput.ComputedISize()) might not be the right thing to
+ // return here. Specifically: if our cross size is an intrinsic size, and we
+ // have flex items that are flexible and have aspect ratios, then we may
+ // need to take their post-flexing main sizes into account (multiplied
+ // through their aspect ratios to get their cross sizes), in order to
+ // determine their flex line's size & the flex container's cross size (e.g.
+ // as `aSumLineCrossSizes`).
+ return aTentativeContentBoxCrossSize;
+ }
+
+ const bool shouldApplyAutomaticMinimumOnBlockAxis =
+ aReflowInput.ShouldApplyAutomaticMinimumOnBlockAxis();
+ const nscoord computedBSize = aReflowInput.ComputedBSize();
+ if (computedBSize != NS_UNCONSTRAINEDSIZE &&
+ !shouldApplyAutomaticMinimumOnBlockAxis) {
+ // Row-oriented case (cross axis is block-axis), with fixed BSize:
+ *aIsDefinite = true;
+
+ // Just use our fixed block-size because we always assume the available
+ // block-size is unconstrained, and the reflow input has already done the
+ // appropriate min/max-BSize clamping.
+ return computedBSize;
+ }
+
+ // Row-oriented case, with size-containment in block axis:
+ // Behave as if we had no content and just use our MinBSize.
+ if (Maybe<nscoord> containBSize =
+ aReflowInput.mFrame->ContainIntrinsicBSize()) {
+ *aIsDefinite = true;
+ return NS_CSS_MINMAX(*containBSize, aReflowInput.ComputedMinBSize(),
+ aReflowInput.ComputedMaxBSize());
+ }
+
+ // The cross size must not be definite in the following cases.
+ *aIsDefinite = false;
+
+ const nscoord contentBSize =
+ NS_CSS_MINMAX(aSumLineCrossSizes, aReflowInput.ComputedMinBSize(),
+ aReflowInput.ComputedMaxBSize());
+ // If the content block-size is larger than the effective computed
+ // block-size, we extend the block-size to contain all the content.
+ // https://drafts.csswg.org/css-sizing-4/#aspect-ratio-minimum
+ if (shouldApplyAutomaticMinimumOnBlockAxis) {
+ // Row-oriented case (cross axis is block-axis), with auto BSize which is
+ // resolved by aspect-ratio or content size.
+ return std::max(contentBSize, computedBSize);
+ }
+
+ // Row-oriented case (cross axis is block axis), with auto BSize:
+ // Shrink-wrap our line(s), subject to our min-size / max-size
+ // constraints in that (block) axis.
+ return contentBSize;
+}
+
+LogicalSize nsFlexContainerFrame::ComputeAvailableSizeForItems(
+ const ReflowInput& aReflowInput,
+ const mozilla::LogicalMargin& aBorderPadding) const {
+ const WritingMode wm = GetWritingMode();
+ nscoord availableBSize = aReflowInput.AvailableBSize();
+
+ if (availableBSize != NS_UNCONSTRAINEDSIZE) {
+ // Available block-size is constrained. Subtract block-start border and
+ // padding from it.
+ availableBSize -= aBorderPadding.BStart(wm);
+
+ if (aReflowInput.mStyleBorder->mBoxDecorationBreak ==
+ StyleBoxDecorationBreak::Clone) {
+ // We have box-decoration-break:clone. Subtract block-end border and
+ // padding from the available block-size as well.
+ availableBSize -= aBorderPadding.BEnd(wm);
+ }
+
+ // Available block-size can became negative after subtracting block-axis
+ // border and padding. Per spec, to guarantee progress, fragmentainers are
+ // assumed to have a minimum block size of 1px regardless of their used
+ // size. https://drafts.csswg.org/css-break/#breaking-rules
+ availableBSize =
+ std::max(nsPresContext::CSSPixelsToAppUnits(1), availableBSize);
+ }
+
+ return LogicalSize(wm, aReflowInput.ComputedISize(), availableBSize);
+}
+
+void FlexLine::PositionItemsInMainAxis(
+ const StyleContentDistribution& aJustifyContent,
+ nscoord aContentBoxMainSize, const FlexboxAxisTracker& aAxisTracker) {
+ MainAxisPositionTracker mainAxisPosnTracker(
+ aAxisTracker, this, aJustifyContent, aContentBoxMainSize);
+ for (FlexItem& item : Items()) {
+ nscoord itemMainBorderBoxSize =
+ item.MainSize() + item.BorderPaddingSizeInMainAxis();
+
+ // Resolve any main-axis 'auto' margins on aChild to an actual value.
+ mainAxisPosnTracker.ResolveAutoMarginsInMainAxis(item);
+
+ // Advance our position tracker to child's upper-left content-box corner,
+ // and use that as its position in the main axis.
+ mainAxisPosnTracker.EnterMargin(item.Margin());
+ mainAxisPosnTracker.EnterChildFrame(itemMainBorderBoxSize);
+
+ item.SetMainPosition(mainAxisPosnTracker.Position());
+
+ mainAxisPosnTracker.ExitChildFrame(itemMainBorderBoxSize);
+ mainAxisPosnTracker.ExitMargin(item.Margin());
+ mainAxisPosnTracker.TraversePackingSpace();
+ if (&item != &Items().LastElement()) {
+ mainAxisPosnTracker.TraverseGap(mMainGapSize);
+ }
+ }
+}
+
+/**
+ * Given the flex container's "flex-relative ascent" (i.e. distance from the
+ * flex container's content-box cross-start edge to its baseline), returns
+ * its actual physical ascent value (the distance from the *border-box* top
+ * edge to its baseline).
+ */
+static nscoord ComputePhysicalAscentFromFlexRelativeAscent(
+ nscoord aFlexRelativeAscent, nscoord aContentBoxCrossSize,
+ const ReflowInput& aReflowInput, const FlexboxAxisTracker& aAxisTracker) {
+ return aReflowInput.ComputedPhysicalBorderPadding().top +
+ PhysicalCoordFromFlexRelativeCoord(
+ aFlexRelativeAscent, aContentBoxCrossSize,
+ aAxisTracker.CrossAxisPhysicalStartSide());
+}
+
+void nsFlexContainerFrame::SizeItemInCrossAxis(ReflowInput& aChildReflowInput,
+ FlexItem& aItem) {
+ // If cross axis is the item's inline axis, just use ISize from reflow input,
+ // and don't bother with a full reflow.
+ if (aItem.IsInlineAxisCrossAxis()) {
+ aItem.SetCrossSize(aChildReflowInput.ComputedISize());
+ return;
+ }
+
+ MOZ_ASSERT(!aItem.HadMeasuringReflow(),
+ "We shouldn't need more than one measuring reflow");
+
+ if (aItem.AlignSelf()._0 == StyleAlignFlags::STRETCH) {
+ // This item's got "align-self: stretch", so we probably imposed a
+ // stretched computed cross-size on it during its previous
+ // reflow. We're not imposing that BSize for *this* "measuring" reflow, so
+ // we need to tell it to treat this reflow as a resize in its block axis
+ // (regardless of whether any of its ancestors are actually being resized).
+ // (Note: we know that the cross axis is the item's *block* axis -- if it
+ // weren't, then we would've taken the early-return above.)
+ aChildReflowInput.SetBResize(true);
+ // Not 100% sure this is needed, but be conservative for now:
+ aChildReflowInput.mFlags.mIsBResizeForPercentages = true;
+ }
+
+ // Potentially reflow the item, and get the sizing info.
+ const CachedBAxisMeasurement& measurement =
+ MeasureBSizeForFlexItem(aItem, aChildReflowInput);
+
+ // Save the sizing info that we learned from this reflow
+ // -----------------------------------------------------
+
+ // Tentatively store the child's desired content-box cross-size.
+ aItem.SetCrossSize(measurement.BSize());
+}
+
+void FlexLine::PositionItemsInCrossAxis(
+ nscoord aLineStartPosition, const FlexboxAxisTracker& aAxisTracker) {
+ SingleLineCrossAxisPositionTracker lineCrossAxisPosnTracker(aAxisTracker);
+
+ for (FlexItem& item : Items()) {
+ // First, stretch the item's cross size (if appropriate), and resolve any
+ // auto margins in this axis.
+ item.ResolveStretchedCrossSize(mLineCrossSize);
+ lineCrossAxisPosnTracker.ResolveAutoMarginsInCrossAxis(*this, item);
+
+ // Compute the cross-axis position of this item
+ nscoord itemCrossBorderBoxSize =
+ item.CrossSize() + item.BorderPaddingSizeInCrossAxis();
+ lineCrossAxisPosnTracker.EnterAlignPackingSpace(*this, item, aAxisTracker);
+ lineCrossAxisPosnTracker.EnterMargin(item.Margin());
+ lineCrossAxisPosnTracker.EnterChildFrame(itemCrossBorderBoxSize);
+
+ item.SetCrossPosition(aLineStartPosition +
+ lineCrossAxisPosnTracker.Position());
+
+ // Back out to cross-axis edge of the line.
+ lineCrossAxisPosnTracker.ResetPosition();
+ }
+}
+
+void nsFlexContainerFrame::Reflow(nsPresContext* aPresContext,
+ ReflowOutput& aReflowOutput,
+ const ReflowInput& aReflowInput,
+ nsReflowStatus& aStatus) {
+ if (IsHiddenByContentVisibilityOfInFlowParentForLayout()) {
+ return;
+ }
+
+ MarkInReflow();
+ DO_GLOBAL_REFLOW_COUNT("nsFlexContainerFrame");
+ DISPLAY_REFLOW(aPresContext, this, aReflowInput, aReflowOutput, aStatus);
+ MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
+ MOZ_ASSERT(aPresContext == PresContext());
+ NS_WARNING_ASSERTION(
+ aReflowInput.ComputedISize() != NS_UNCONSTRAINEDSIZE,
+ "Unconstrained inline size; this should only result from huge sizes "
+ "(not intrinsic sizing w/ orthogonal flows)");
+
+ FLEX_LOG("Reflow() for nsFlexContainerFrame %p", this);
+
+ if (IsFrameTreeTooDeep(aReflowInput, aReflowOutput, aStatus)) {
+ return;
+ }
+
+ NormalizeChildLists();
+
+#ifdef DEBUG
+ mDidPushItemsBitMayLie = false;
+ SanityCheckChildListsBeforeReflow();
+#endif // DEBUG
+
+ // We (and our children) can only depend on our ancestor's bsize if we have
+ // a percent-bsize, or if we're positioned and we have "block-start" and
+ // "block-end" set and have block-size:auto. (There are actually other cases,
+ // too -- e.g. if our parent is itself a block-dir flex container and we're
+ // flexible -- but we'll let our ancestors handle those sorts of cases.)
+ //
+ // TODO(emilio): the !bsize.IsLengthPercentage() preserves behavior, but it's
+ // too conservative. min/max-content don't really depend on the container.
+ WritingMode wm = aReflowInput.GetWritingMode();
+ const nsStylePosition* stylePos = StylePosition();
+ const auto& bsize = stylePos->BSize(wm);
+ if (bsize.HasPercent() || (StyleDisplay()->IsAbsolutelyPositionedStyle() &&
+ (bsize.IsAuto() || !bsize.IsLengthPercentage()) &&
+ !stylePos->mOffset.GetBStart(wm).IsAuto() &&
+ !stylePos->mOffset.GetBEnd(wm).IsAuto())) {
+ AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);
+ }
+
+ const FlexboxAxisTracker axisTracker(this);
+
+ // Check to see if we need to create a computed info structure, to
+ // be filled out for use by devtools.
+ ComputedFlexContainerInfo* containerInfo = CreateOrClearFlexContainerInfo();
+
+ FlexLayoutResult flr;
+ PerFragmentFlexData fragmentData;
+ const nsIFrame* prevInFlow = GetPrevInFlow();
+ if (!prevInFlow) {
+ const LogicalSize tentativeContentBoxSize = aReflowInput.ComputedSize();
+ const nscoord tentativeContentBoxMainSize =
+ axisTracker.MainComponent(tentativeContentBoxSize);
+ const nscoord tentativeContentBoxCrossSize =
+ axisTracker.CrossComponent(tentativeContentBoxSize);
+
+ // Calculate gap sizes for main and cross axis. We only need them in
+ // DoFlexLayout in the first-in-flow, so no need to worry about consumed
+ // block-size.
+ const auto& mainGapStyle =
+ axisTracker.IsRowOriented() ? stylePos->mColumnGap : stylePos->mRowGap;
+ const auto& crossGapStyle =
+ axisTracker.IsRowOriented() ? stylePos->mRowGap : stylePos->mColumnGap;
+ const nscoord mainGapSize = nsLayoutUtils::ResolveGapToLength(
+ mainGapStyle, tentativeContentBoxMainSize);
+ const nscoord crossGapSize = nsLayoutUtils::ResolveGapToLength(
+ crossGapStyle, tentativeContentBoxCrossSize);
+
+ // When fragmenting a flex container, we run the flex algorithm without
+ // regards to pagination in order to compute the flex container's desired
+ // content-box size. https://drafts.csswg.org/css-flexbox-1/#pagination-algo
+ //
+ // Note: For a multi-line column-oriented flex container, the sample
+ // algorithm suggests we wrap the flex line at the block-end edge of a
+ // column/page, but we do not implement it intentionally. This brings the
+ // layout result closer to the one as if there's no fragmentation.
+ AutoTArray<StrutInfo, 1> struts;
+ flr = DoFlexLayout(aReflowInput, tentativeContentBoxMainSize,
+ tentativeContentBoxCrossSize, axisTracker, mainGapSize,
+ crossGapSize, struts, containerInfo);
+
+ if (!struts.IsEmpty()) {
+ // We're restarting flex layout, with new knowledge of collapsed items.
+ flr.mLines.Clear();
+ flr.mPlaceholders.Clear();
+ flr = DoFlexLayout(aReflowInput, tentativeContentBoxMainSize,
+ tentativeContentBoxCrossSize, axisTracker, mainGapSize,
+ crossGapSize, struts, containerInfo);
+ }
+ } else {
+ flr = GenerateFlexLayoutResult();
+ auto* fragmentDataProp =
+ prevInFlow->GetProperty(PerFragmentFlexData::Prop());
+ MOZ_ASSERT(fragmentDataProp,
+ "PerFragmentFlexData should be set in our prev-in-flow!");
+ fragmentData = *fragmentDataProp;
+ }
+
+ LogicalSize contentBoxSize = axisTracker.LogicalSizeFromFlexRelativeSizes(
+ flr.mContentBoxMainSize, flr.mContentBoxCrossSize);
+
+ const nscoord consumedBSize = CalcAndCacheConsumedBSize();
+ const nscoord effectiveContentBSize =
+ contentBoxSize.BSize(wm) - consumedBSize;
+ LogicalMargin borderPadding = aReflowInput.ComputedLogicalBorderPadding(wm);
+ if (MOZ_UNLIKELY(aReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE)) {
+ // We assume we are the last fragment by using
+ // PreReflowBlockLevelLogicalSkipSides(), and skip block-end border and
+ // padding if needed.
+ borderPadding.ApplySkipSides(PreReflowBlockLevelLogicalSkipSides());
+ }
+
+ // Determine this frame's tentative border-box size. This is used for logical
+ // to physical coordinate conversion when positioning children.
+ //
+ // Note that vertical-rl writing-mode is the only case where the block flow
+ // direction progresses in a negative physical direction, and therefore block
+ // direction coordinate conversion depends on knowing the width of the
+ // coordinate space in order to translate between the logical and physical
+ // origins. As a result, if our final border-box block-size is different from
+ // this tentative one, and we are in vertical-rl writing mode, we need to
+ // adjust our children's position after reflowing them.
+ const LogicalSize tentativeBorderBoxSize(
+ wm, contentBoxSize.ISize(wm) + borderPadding.IStartEnd(wm),
+ std::min(effectiveContentBSize + borderPadding.BStartEnd(wm),
+ aReflowInput.AvailableBSize()));
+ const nsSize containerSize = tentativeBorderBoxSize.GetPhysicalSize(wm);
+
+ OverflowAreas ocBounds;
+ nsReflowStatus ocStatus;
+ if (prevInFlow) {
+ ReflowOverflowContainerChildren(
+ aPresContext, aReflowInput, ocBounds, ReflowChildFlags::Default,
+ ocStatus, MergeSortedFrameListsFor, Some(containerSize));
+ }
+
+ const LogicalSize availableSizeForItems =
+ ComputeAvailableSizeForItems(aReflowInput, borderPadding);
+ const auto [maxBlockEndEdgeOfChildren, anyChildIncomplete] =
+ ReflowChildren(aReflowInput, containerSize, availableSizeForItems,
+ borderPadding, axisTracker, flr, fragmentData);
+
+ bool mayNeedNextInFlow = false;
+ if (aReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE) {
+ // maxBlockEndEdgeOfChildren is relative to border-box, so we need to
+ // subtract block-start border and padding to make it relative to our
+ // content-box. Note that if there is a packing space in between the last
+ // flex item's block-end edge and the available space's block-end edge, we
+ // want to record the available size of item to consume part of the packing
+ // space.
+ fragmentData.mCumulativeContentBoxBSize +=
+ std::max(maxBlockEndEdgeOfChildren - borderPadding.BStart(wm),
+ availableSizeForItems.BSize(wm));
+
+ // mCumulativeBEndEdgeShift was updated in ReflowChildren(). If our
+ // block-size in unconstrained, use that to grow our block-size, subject to
+ // min/max constraints.
+ if (aReflowInput.ComputedBSize() == NS_UNCONSTRAINEDSIZE) {
+ contentBoxSize.BSize(wm) = aReflowInput.ApplyMinMaxBSize(
+ contentBoxSize.BSize(wm) + fragmentData.mCumulativeBEndEdgeShift);
+ }
+
+ // Check if we may need a next-in-flow. If so, we'll need to skip block-end
+ // border and padding.
+ mayNeedNextInFlow = contentBoxSize.BSize(wm) - consumedBSize >
+ availableSizeForItems.BSize(wm);
+ if (mayNeedNextInFlow && aReflowInput.mStyleBorder->mBoxDecorationBreak ==
+ StyleBoxDecorationBreak::Slice) {
+ borderPadding.BEnd(wm) = 0;
+ }
+ }
+
+ PopulateReflowOutput(aReflowOutput, aReflowInput, aStatus, contentBoxSize,
+ borderPadding, consumedBSize, mayNeedNextInFlow,
+ maxBlockEndEdgeOfChildren, anyChildIncomplete,
+ flr.mAscent, flr.mLines, axisTracker);
+
+ if (wm.IsVerticalRL()) {
+ // If the final border-box block-size is different from the tentative one,
+ // adjust our children's position.
+ const nscoord deltaBCoord =
+ tentativeBorderBoxSize.BSize(wm) - aReflowOutput.Size(wm).BSize(wm);
+ if (deltaBCoord != 0) {
+ const LogicalPoint delta(wm, 0, deltaBCoord);
+ for (const FlexLine& line : flr.mLines) {
+ for (const FlexItem& item : line.Items()) {
+ item.Frame()->MovePositionBy(wm, delta);
+ }
+ }
+ }
+ }
+
+ // Overflow area = union(my overflow area, children's overflow areas)
+ aReflowOutput.SetOverflowAreasToDesiredBounds();
+ UnionInFlowChildOverflow(aReflowOutput.mOverflowAreas);
+
+ // Merge overflow container bounds and status.
+ aReflowOutput.mOverflowAreas.UnionWith(ocBounds);
+ aStatus.MergeCompletionStatusFrom(ocStatus);
+
+ FinishReflowWithAbsoluteFrames(PresContext(), aReflowOutput, aReflowInput,
+ aStatus);
+
+ // Finally update our line and item measurements in our containerInfo.
+ if (MOZ_UNLIKELY(containerInfo)) {
+ UpdateFlexLineAndItemInfo(*containerInfo, flr.mLines);
+ }
+
+ // If we are the first-in-flow, we want to store data for our next-in-flows,
+ // or clear the existing data if it is not needed.
+ if (!prevInFlow) {
+ SharedFlexData* sharedData = GetProperty(SharedFlexData::Prop());
+ if (!aStatus.IsFullyComplete()) {
+ if (!sharedData) {
+ sharedData = new SharedFlexData;
+ SetProperty(SharedFlexData::Prop(), sharedData);
+ }
+ sharedData->Update(std::move(flr));
+ } else if (sharedData && !GetNextInFlow()) {
+ // We are fully-complete, so no next-in-flow is needed. However, if we
+ // report SetInlineLineBreakBeforeAndReset() in an incremental reflow, our
+ // next-in-flow might still exist. It can be reflowed again before us if
+ // it is an overflow container. Delete the existing data only if we don't
+ // have a next-in-flow.
+ RemoveProperty(SharedFlexData::Prop());
+ }
+ }
+
+ PerFragmentFlexData* fragmentDataProp =
+ GetProperty(PerFragmentFlexData::Prop());
+ if (!aStatus.IsFullyComplete()) {
+ if (!fragmentDataProp) {
+ fragmentDataProp = new PerFragmentFlexData;
+ SetProperty(PerFragmentFlexData::Prop(), fragmentDataProp);
+ }
+ *fragmentDataProp = fragmentData;
+ } else if (fragmentDataProp && !GetNextInFlow()) {
+ // Similar to the condition to remove SharedFlexData, delete the
+ // existing data only if we don't have a next-in-flow.
+ RemoveProperty(PerFragmentFlexData::Prop());
+ }
+}
+
+Maybe<nscoord> nsFlexContainerFrame::GetNaturalBaselineBOffset(
+ WritingMode aWM, BaselineSharingGroup aBaselineGroup,
+ BaselineExportContext) const {
+ if (StyleDisplay()->IsContainLayout() ||
+ HasAnyStateBits(NS_STATE_FLEX_SYNTHESIZE_BASELINE)) {
+ return Nothing{};
+ }
+ return Some(aBaselineGroup == BaselineSharingGroup::First
+ ? mBaselineFromLastReflow
+ : mLastBaselineFromLastReflow);
+}
+
+void nsFlexContainerFrame::UnionInFlowChildOverflow(
+ OverflowAreas& aOverflowAreas) {
+ // The CSS Overflow spec [1] requires that a scrollable container's
+ // scrollable overflow should include the following areas.
+ //
+ // a) "the box's own content and padding areas": we treat the *content* as
+ // the scrolled inner frame's theoretical content-box that's intrinsically
+ // sized to the union of all the flex items' margin boxes, _without_
+ // relative positioning applied. The *padding areas* is just inflation on
+ // top of the theoretical content-box by the flex container's padding.
+ //
+ // b) "the margin areas of grid item and flex item boxes for which the box
+ // establishes a containing block": a) already includes the flex items'
+ // normal-positioned margin boxes into the scrollable overflow, but their
+ // relative-positioned margin boxes should also be included because relpos
+ // children are still flex items.
+ //
+ // [1] https://drafts.csswg.org/css-overflow-3/#scrollable.
+ const bool isScrolledContent =
+ Style()->GetPseudoType() == PseudoStyleType::scrolledContent;
+ bool anyScrolledContentItem = false;
+ // Union of normal-positioned margin boxes for all the items.
+ nsRect itemMarginBoxes;
+ // Union of relative-positioned margin boxes for the relpos items only.
+ nsRect relPosItemMarginBoxes;
+ const bool useMozBoxCollapseBehavior =
+ StyleVisibility()->UseLegacyCollapseBehavior();
+ for (nsIFrame* f : mFrames) {
+ if (useMozBoxCollapseBehavior && f->StyleVisibility()->IsCollapse()) {
+ continue;
+ }
+ ConsiderChildOverflow(aOverflowAreas, f);
+ if (!isScrolledContent) {
+ continue;
+ }
+ if (f->IsPlaceholderFrame()) {
+ continue;
+ }
+ anyScrolledContentItem = true;
+ if (MOZ_UNLIKELY(f->IsRelativelyOrStickyPositioned())) {
+ const nsRect marginRect = f->GetMarginRectRelativeToSelf();
+ itemMarginBoxes =
+ itemMarginBoxes.Union(marginRect + f->GetNormalPosition());
+ relPosItemMarginBoxes =
+ relPosItemMarginBoxes.Union(marginRect + f->GetPosition());
+ } else {
+ itemMarginBoxes = itemMarginBoxes.Union(f->GetMarginRect());
+ }
+ }
+
+ if (anyScrolledContentItem) {
+ itemMarginBoxes.Inflate(GetUsedPadding());
+ aOverflowAreas.UnionAllWith(itemMarginBoxes);
+ aOverflowAreas.UnionAllWith(relPosItemMarginBoxes);
+ }
+}
+
+void nsFlexContainerFrame::UnionChildOverflow(OverflowAreas& aOverflowAreas) {
+ UnionInFlowChildOverflow(aOverflowAreas);
+ // Union with child frames, skipping the principal list since we already
+ // handled those above.
+ nsLayoutUtils::UnionChildOverflow(this, aOverflowAreas,
+ {FrameChildListID::Principal});
+}
+
+void nsFlexContainerFrame::CalculatePackingSpace(
+ uint32_t aNumThingsToPack, const StyleContentDistribution& aAlignVal,
+ nscoord* aFirstSubjectOffset, uint32_t* aNumPackingSpacesRemaining,
+ nscoord* aPackingSpaceRemaining) {
+ StyleAlignFlags val = aAlignVal.primary;
+ MOZ_ASSERT(val == StyleAlignFlags::SPACE_BETWEEN ||
+ val == StyleAlignFlags::SPACE_AROUND ||
+ val == StyleAlignFlags::SPACE_EVENLY,
+ "Unexpected alignment value");
+
+ MOZ_ASSERT(*aPackingSpaceRemaining >= 0,
+ "Should not be called with negative packing space");
+
+ // Note: In the aNumThingsToPack==1 case, the fallback behavior for
+ // 'space-between' depends on precise information about the axes that we
+ // don't have here. So, for that case, we just depend on the caller to
+ // explicitly convert 'space-{between,around,evenly}' keywords to the
+ // appropriate fallback alignment and skip this function.
+ MOZ_ASSERT(aNumThingsToPack > 1,
+ "Should not be called unless there's more than 1 thing to pack");
+
+ // Packing spaces between items:
+ *aNumPackingSpacesRemaining = aNumThingsToPack - 1;
+
+ if (val == StyleAlignFlags::SPACE_BETWEEN) {
+ // No need to reserve space at beginning/end, so we're done.
+ return;
+ }
+
+ // We need to add 1 or 2 packing spaces, split between beginning/end, for
+ // space-around / space-evenly:
+ size_t numPackingSpacesForEdges =
+ val == StyleAlignFlags::SPACE_AROUND ? 1 : 2;
+
+ // How big will each "full" packing space be:
+ nscoord packingSpaceSize =
+ *aPackingSpaceRemaining /
+ (*aNumPackingSpacesRemaining + numPackingSpacesForEdges);
+ // How much packing-space are we allocating to the edges:
+ nscoord totalEdgePackingSpace = numPackingSpacesForEdges * packingSpaceSize;
+
+ // Use half of that edge packing space right now:
+ *aFirstSubjectOffset += totalEdgePackingSpace / 2;
+ // ...but we need to subtract all of it right away, so that we won't
+ // hand out any of it to intermediate packing spaces.
+ *aPackingSpaceRemaining -= totalEdgePackingSpace;
+}
+
+ComputedFlexContainerInfo*
+nsFlexContainerFrame::CreateOrClearFlexContainerInfo() {
+ if (!ShouldGenerateComputedInfo()) {
+ return nullptr;
+ }
+
+ // The flag that sets ShouldGenerateComputedInfo() will never be cleared.
+ // That's acceptable because it's only set in a Chrome API invoked by
+ // devtools, and won't impact normal browsing.
+
+ // Re-use the ComputedFlexContainerInfo, if it exists.
+ ComputedFlexContainerInfo* info = GetProperty(FlexContainerInfo());
+ if (info) {
+ // We can reuse, as long as we clear out old data.
+ info->mLines.Clear();
+ } else {
+ info = new ComputedFlexContainerInfo();
+ SetProperty(FlexContainerInfo(), info);
+ }
+
+ return info;
+}
+
+void nsFlexContainerFrame::CreateFlexLineAndFlexItemInfo(
+ ComputedFlexContainerInfo& aContainerInfo,
+ const nsTArray<FlexLine>& aLines) {
+ for (const FlexLine& line : aLines) {
+ ComputedFlexLineInfo* lineInfo = aContainerInfo.mLines.AppendElement();
+ // Most of the remaining lineInfo properties will be filled out in
+ // UpdateFlexLineAndItemInfo (some will be provided by other functions),
+ // when we have real values. But we still add all the items here, so
+ // we can capture computed data for each item as we proceed.
+ for (const FlexItem& item : line.Items()) {
+ nsIFrame* frame = item.Frame();
+
+ // The frame may be for an element, or it may be for an
+ // anonymous flex item, e.g. wrapping one or more text nodes.
+ // DevTools wants the content node for the actual child in
+ // the DOM tree, so we descend through anonymous boxes.
+ nsIFrame* targetFrame = GetFirstNonAnonBoxInSubtree(frame);
+ nsIContent* content = targetFrame->GetContent();
+
+ // Skip over content that is only whitespace, which might
+ // have been broken off from a text node which is our real
+ // target.
+ while (content && content->TextIsOnlyWhitespace()) {
+ // If content is only whitespace, try the frame sibling.
+ targetFrame = targetFrame->GetNextSibling();
+ if (targetFrame) {
+ content = targetFrame->GetContent();
+ } else {
+ content = nullptr;
+ }
+ }
+
+ ComputedFlexItemInfo* itemInfo = lineInfo->mItems.AppendElement();
+
+ itemInfo->mNode = content;
+
+ // itemInfo->mMainBaseSize and mMainDeltaSize will be filled out
+ // in ResolveFlexibleLengths(). Other measurements will be captured in
+ // UpdateFlexLineAndItemInfo.
+ }
+ }
+}
+
+void nsFlexContainerFrame::ComputeFlexDirections(
+ ComputedFlexContainerInfo& aContainerInfo,
+ const FlexboxAxisTracker& aAxisTracker) {
+ auto ConvertPhysicalStartSideToFlexPhysicalDirection =
+ [](mozilla::Side aStartSide) {
+ switch (aStartSide) {
+ case eSideLeft:
+ return dom::FlexPhysicalDirection::Horizontal_lr;
+ case eSideRight:
+ return dom::FlexPhysicalDirection::Horizontal_rl;
+ case eSideTop:
+ return dom::FlexPhysicalDirection::Vertical_tb;
+ case eSideBottom:
+ return dom::FlexPhysicalDirection::Vertical_bt;
+ }
+
+ MOZ_ASSERT_UNREACHABLE("We should handle all sides!");
+ return dom::FlexPhysicalDirection::Horizontal_lr;
+ };
+
+ aContainerInfo.mMainAxisDirection =
+ ConvertPhysicalStartSideToFlexPhysicalDirection(
+ aAxisTracker.MainAxisPhysicalStartSide());
+ aContainerInfo.mCrossAxisDirection =
+ ConvertPhysicalStartSideToFlexPhysicalDirection(
+ aAxisTracker.CrossAxisPhysicalStartSide());
+}
+
+void nsFlexContainerFrame::UpdateFlexLineAndItemInfo(
+ ComputedFlexContainerInfo& aContainerInfo,
+ const nsTArray<FlexLine>& aLines) {
+ uint32_t lineIndex = 0;
+ for (const FlexLine& line : aLines) {
+ ComputedFlexLineInfo& lineInfo = aContainerInfo.mLines[lineIndex];
+
+ lineInfo.mCrossSize = line.LineCrossSize();
+ lineInfo.mFirstBaselineOffset = line.FirstBaselineOffset();
+ lineInfo.mLastBaselineOffset = line.LastBaselineOffset();
+
+ uint32_t itemIndex = 0;
+ for (const FlexItem& item : line.Items()) {
+ ComputedFlexItemInfo& itemInfo = lineInfo.mItems[itemIndex];
+ itemInfo.mFrameRect = item.Frame()->GetRect();
+ itemInfo.mMainMinSize = item.MainMinSize();
+ itemInfo.mMainMaxSize = item.MainMaxSize();
+ itemInfo.mCrossMinSize = item.CrossMinSize();
+ itemInfo.mCrossMaxSize = item.CrossMaxSize();
+ itemInfo.mClampState =
+ item.WasMinClamped()
+ ? mozilla::dom::FlexItemClampState::Clamped_to_min
+ : (item.WasMaxClamped()
+ ? mozilla::dom::FlexItemClampState::Clamped_to_max
+ : mozilla::dom::FlexItemClampState::Unclamped);
+ ++itemIndex;
+ }
+ ++lineIndex;
+ }
+}
+
+nsFlexContainerFrame* nsFlexContainerFrame::GetFlexFrameWithComputedInfo(
+ nsIFrame* aFrame) {
+ // Prepare a lambda function that we may need to call multiple times.
+ auto GetFlexContainerFrame = [](nsIFrame* aFrame) {
+ // Return the aFrame's content insertion frame, iff it is
+ // a flex container frame.
+ nsFlexContainerFrame* flexFrame = 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* possibleFlexFrame = insertionFrame ? insertionFrame : aFrame;
+ flexFrame = possibleFlexFrame->IsFlexContainerFrame()
+ ? static_cast<nsFlexContainerFrame*>(possibleFlexFrame)
+ : nullptr;
+ }
+ return flexFrame;
+ };
+
+ nsFlexContainerFrame* flexFrame = GetFlexContainerFrame(aFrame);
+ if (flexFrame) {
+ // Generate the FlexContainerInfo data, if it's not already there.
+ bool reflowNeeded = !flexFrame->HasProperty(FlexContainerInfo());
+
+ if (reflowNeeded) {
+ // Trigger a reflow that generates additional flex property data.
+ // Hold onto aFrame while we do this, in case reflow destroys it.
+ AutoWeakFrame weakFrameRef(aFrame);
+
+ RefPtr<mozilla::PresShell> presShell = flexFrame->PresShell();
+ flexFrame->SetShouldGenerateComputedInfo(true);
+ presShell->FrameNeedsReflow(flexFrame, IntrinsicDirty::None,
+ NS_FRAME_IS_DIRTY);
+ presShell->FlushPendingNotifications(FlushType::Layout);
+
+ // Since the reflow may have side effects, get the flex frame
+ // again. But if the weakFrameRef is no longer valid, then we
+ // must bail out.
+ if (!weakFrameRef.IsAlive()) {
+ return nullptr;
+ }
+
+ flexFrame = GetFlexContainerFrame(weakFrameRef.GetFrame());
+
+ NS_WARNING_ASSERTION(
+ !flexFrame || flexFrame->HasProperty(FlexContainerInfo()),
+ "The state bit should've made our forced-reflow "
+ "generate a FlexContainerInfo object");
+ }
+ }
+ return flexFrame;
+}
+
+/* static */
+bool nsFlexContainerFrame::IsItemInlineAxisMainAxis(nsIFrame* aFrame) {
+ MOZ_ASSERT(aFrame && aFrame->IsFlexItem(), "expecting arg to be a flex item");
+ const WritingMode flexItemWM = aFrame->GetWritingMode();
+ const nsIFrame* flexContainer = aFrame->GetParent();
+
+ if (IsLegacyBox(flexContainer)) {
+ // For legacy boxes, the main axis is determined by "box-orient", and we can
+ // just directly check if that's vertical, and compare that to whether the
+ // item's WM is also vertical:
+ bool boxOrientIsVertical =
+ flexContainer->StyleXUL()->mBoxOrient == StyleBoxOrient::Vertical;
+ return flexItemWM.IsVertical() == boxOrientIsVertical;
+ }
+
+ // For modern CSS flexbox, we get our return value by asking two questions
+ // and comparing their answers.
+ // Question 1: does aFrame have the same inline axis as its flex container?
+ bool itemInlineAxisIsParallelToParent =
+ !flexItemWM.IsOrthogonalTo(flexContainer->GetWritingMode());
+
+ // Question 2: is aFrame's flex container row-oriented? (This tells us
+ // whether the flex container's main axis is its inline axis.)
+ auto flexDirection = flexContainer->StylePosition()->mFlexDirection;
+ bool flexContainerIsRowOriented =
+ flexDirection == StyleFlexDirection::Row ||
+ flexDirection == StyleFlexDirection::RowReverse;
+
+ // aFrame's inline axis is its flex container's main axis IFF the above
+ // questions have the same answer.
+ return flexContainerIsRowOriented == itemInlineAxisIsParallelToParent;
+}
+
+/* static */
+bool nsFlexContainerFrame::IsUsedFlexBasisContent(
+ const StyleFlexBasis& aFlexBasis, const StyleSize& aMainSize) {
+ // We have a used flex-basis of 'content' if flex-basis explicitly has that
+ // value, OR if flex-basis is 'auto' (deferring to the main-size property)
+ // and the main-size property is also 'auto'.
+ // See https://drafts.csswg.org/css-flexbox-1/#valdef-flex-basis-auto
+ if (aFlexBasis.IsContent()) {
+ return true;
+ }
+ return aFlexBasis.IsAuto() && aMainSize.IsAuto();
+}
+
+nsFlexContainerFrame::FlexLayoutResult nsFlexContainerFrame::DoFlexLayout(
+ const ReflowInput& aReflowInput, const nscoord aTentativeContentBoxMainSize,
+ const nscoord aTentativeContentBoxCrossSize,
+ const FlexboxAxisTracker& aAxisTracker, nscoord aMainGapSize,
+ nscoord aCrossGapSize, nsTArray<StrutInfo>& aStruts,
+ ComputedFlexContainerInfo* const aContainerInfo) {
+ FlexLayoutResult flr;
+
+ GenerateFlexLines(aReflowInput, aTentativeContentBoxMainSize,
+ aTentativeContentBoxCrossSize, aStruts, aAxisTracker,
+ aMainGapSize, flr.mPlaceholders, flr.mLines,
+ flr.mHasCollapsedItems);
+
+ if ((flr.mLines.Length() == 1 && flr.mLines[0].IsEmpty()) ||
+ aReflowInput.mStyleDisplay->IsContainLayout()) {
+ // We have no flex items, or we're layout-contained. So, we have no
+ // baseline, and our parent should synthesize a baseline if needed.
+ AddStateBits(NS_STATE_FLEX_SYNTHESIZE_BASELINE);
+ } else {
+ RemoveStateBits(NS_STATE_FLEX_SYNTHESIZE_BASELINE);
+ }
+
+ // Construct our computed info if we've been asked to do so. This is
+ // necessary to do now so we can capture some computed values for
+ // FlexItems during layout that would not otherwise be saved (like
+ // size adjustments). We'll later fix up the line properties,
+ // because the correct values aren't available yet.
+ if (aContainerInfo) {
+ MOZ_ASSERT(ShouldGenerateComputedInfo(),
+ "We should only have the info struct if "
+ "ShouldGenerateComputedInfo() is true!");
+
+ if (!aStruts.IsEmpty()) {
+ // We restarted DoFlexLayout, and may have stale mLines to clear:
+ aContainerInfo->mLines.Clear();
+ } else {
+ MOZ_ASSERT(aContainerInfo->mLines.IsEmpty(), "Shouldn't have lines yet.");
+ }
+
+ CreateFlexLineAndFlexItemInfo(*aContainerInfo, flr.mLines);
+ ComputeFlexDirections(*aContainerInfo, aAxisTracker);
+ }
+
+ flr.mContentBoxMainSize = ComputeMainSize(
+ aReflowInput, aAxisTracker, aTentativeContentBoxMainSize, flr.mLines);
+
+ uint32_t lineIndex = 0;
+ for (FlexLine& line : flr.mLines) {
+ ComputedFlexLineInfo* lineInfo =
+ aContainerInfo ? &aContainerInfo->mLines[lineIndex] : nullptr;
+ line.ResolveFlexibleLengths(flr.mContentBoxMainSize, lineInfo);
+ ++lineIndex;
+ }
+
+ // Cross Size Determination - Flexbox spec section 9.4
+ // https://drafts.csswg.org/css-flexbox-1/#cross-sizing
+ // ===================================================
+ // Calculate the hypothetical cross size of each item:
+
+ // 'sumLineCrossSizes' includes the size of all gaps between lines. We
+ // initialize it with the sum of all the gaps, and add each line's cross size
+ // at the end of the following for-loop.
+ nscoord sumLineCrossSizes = aCrossGapSize * (flr.mLines.Length() - 1);
+ for (FlexLine& line : flr.mLines) {
+ for (FlexItem& item : line.Items()) {
+ // The item may already have the correct cross-size; only recalculate
+ // if the item's main size resolution (flexing) could have influenced it:
+ if (item.CanMainSizeInfluenceCrossSize()) {
+ StyleSizeOverrides sizeOverrides;
+ if (item.IsInlineAxisMainAxis()) {
+ sizeOverrides.mStyleISize.emplace(item.StyleMainSize());
+ } else {
+ sizeOverrides.mStyleBSize.emplace(item.StyleMainSize());
+ }
+ FLEX_LOG("Sizing flex item %p in cross axis", item.Frame());
+ FLEX_LOGV(" Main size override: %d", item.MainSize());
+
+ const WritingMode wm = item.GetWritingMode();
+ LogicalSize availSize = aReflowInput.ComputedSize(wm);
+ availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
+ ReflowInput childReflowInput(PresContext(), aReflowInput, item.Frame(),
+ availSize, Nothing(), {}, sizeOverrides);
+ if (item.IsBlockAxisMainAxis() && item.TreatBSizeAsIndefinite()) {
+ childReflowInput.mFlags.mTreatBSizeAsIndefinite = true;
+ }
+
+ SizeItemInCrossAxis(childReflowInput, item);
+ }
+ }
+ // Now that we've finished with this line's items, size the line itself:
+ line.ComputeCrossSizeAndBaseline(aAxisTracker);
+ sumLineCrossSizes += line.LineCrossSize();
+ }
+
+ bool isCrossSizeDefinite;
+ flr.mContentBoxCrossSize = ComputeCrossSize(
+ aReflowInput, aAxisTracker, aTentativeContentBoxCrossSize,
+ sumLineCrossSizes, &isCrossSizeDefinite);
+
+ // Set up state for cross-axis alignment, at a high level (outside the
+ // scope of a particular flex line)
+ CrossAxisPositionTracker crossAxisPosnTracker(
+ flr.mLines, aReflowInput, flr.mContentBoxCrossSize, isCrossSizeDefinite,
+ aAxisTracker, aCrossGapSize);
+
+ // Now that we know the cross size of each line (including
+ // "align-content:stretch" adjustments, from the CrossAxisPositionTracker
+ // constructor), we can create struts for any flex items with
+ // "visibility: collapse" (and restart flex layout).
+ // Make sure to only do this if we had no struts.
+ if (aStruts.IsEmpty() && flr.mHasCollapsedItems &&
+ !StyleVisibility()->UseLegacyCollapseBehavior()) {
+ BuildStrutInfoFromCollapsedItems(flr.mLines, aStruts);
+ if (!aStruts.IsEmpty()) {
+ // Restart flex layout, using our struts.
+ return flr;
+ }
+ }
+
+ // If the container should derive its baseline from the first FlexLine,
+ // do that here (while crossAxisPosnTracker is conveniently pointing
+ // at the cross-start edge of that line, which the line's baseline offset is
+ // measured from):
+ if (nscoord firstLineBaselineOffset = flr.mLines[0].FirstBaselineOffset();
+ firstLineBaselineOffset == nscoord_MIN) {
+ // No baseline-aligned items in line. Use sentinel value to prompt us to
+ // get baseline from the first FlexItem after we've reflowed it.
+ flr.mAscent = nscoord_MIN;
+ } else {
+ flr.mAscent = ComputePhysicalAscentFromFlexRelativeAscent(
+ crossAxisPosnTracker.Position() + firstLineBaselineOffset,
+ flr.mContentBoxCrossSize, aReflowInput, aAxisTracker);
+ }
+
+ const auto justifyContent =
+ IsLegacyBox(aReflowInput.mFrame)
+ ? ConvertLegacyStyleToJustifyContent(StyleXUL())
+ : aReflowInput.mStylePosition->mJustifyContent;
+
+ lineIndex = 0;
+ for (FlexLine& line : flr.mLines) {
+ // Main-Axis Alignment - Flexbox spec section 9.5
+ // https://drafts.csswg.org/css-flexbox-1/#main-alignment
+ // ==============================================
+ line.PositionItemsInMainAxis(justifyContent, flr.mContentBoxMainSize,
+ aAxisTracker);
+
+ // See if we need to extract some computed info for this line.
+ if (MOZ_UNLIKELY(aContainerInfo)) {
+ ComputedFlexLineInfo& lineInfo = aContainerInfo->mLines[lineIndex];
+ lineInfo.mCrossStart = crossAxisPosnTracker.Position();
+ }
+
+ // Cross-Axis Alignment - Flexbox spec section 9.6
+ // https://drafts.csswg.org/css-flexbox-1/#cross-alignment
+ // ===============================================
+ line.PositionItemsInCrossAxis(crossAxisPosnTracker.Position(),
+ aAxisTracker);
+ crossAxisPosnTracker.TraverseLine(line);
+ crossAxisPosnTracker.TraversePackingSpace();
+
+ if (&line != &flr.mLines.LastElement()) {
+ crossAxisPosnTracker.TraverseGap();
+ }
+ ++lineIndex;
+ }
+
+ return flr;
+}
+
+// This data structure is used in fragmentation, storing the block coordinate
+// metrics when reflowing 1) the BStart-most line in each fragment of a
+// row-oriented flex container or, 2) the BStart-most item in each fragment of a
+// single-line column-oriented flex container.
+//
+// When we lay out a row-oriented flex container fragment, its first line might
+// contain one or more monolithic items that were pushed from the previous
+// fragment specifically to avoid having those monolithic items overlap the
+// page/column break. The situation is similar for single-row column-oriented
+// flex container fragments, but a bit simpler; only their first item might have
+// been pushed to avoid overlapping a page/column break.
+//
+// We'll have to place any such pushed items at the block-start edge of the
+// current fragment's content-box, which is as close as we can get them to their
+// theoretical/unfragmented position (without slicing them); but it does
+// represent a shift away from their theoretical/unfragmented position (which
+// was somewhere in the previous fragment).
+//
+// When that happens, we need to record the maximum such shift that we had to
+// perform so that we can apply the same block-endwards shift to "downstream"
+// items (items towards the block-end edge) that we could otherwise collide
+// with. We also potentially apply the same shift when computing the block-end
+// edge of this flex container fragment's content-box so that we don't
+// inadvertently shift the last item (or line-of-items) to overlap the flex
+// container's border, or content beyond the flex container.
+//
+// We use this structure to keep track of several metrics, in service of this
+// goal. This structure is also necessary to adjust PerFragmentFlexData at the
+// end of ReflowChildren().
+//
+// Note: "First" in the struct name means "BStart-most", not the order in the
+// flex line array or flex item array.
+//
+// TODO: Currently, we assume (for proper fragmentation) that the main-axis (or
+// cross-axis) is in the same direction as the corresponding writing-mode
+// inline-axis (or block-axis). Bug 1812485 will support pushing tall flex items
+// for flex containers with a "reversed" main-axis (or cross-axis).
+struct FirstLineOrFirstItemBAxisMetrics final {
+ // This value stores the block-end edge shift for 1) the BStart-most line in
+ // the current fragment of a row-oriented flex container, or 2) the
+ // BStart-most item in the current fragment of a single-line column-oriented
+ // flex container. This number is non-negative.
+ //
+ // This value may become positive when any item is a first-in-flow and also
+ // satisfies either the above condition 1) or 2), since that's a hint that it
+ // could be monolithic or have a monolithic first descendant, and therefore an
+ // item that might incur a page/column-break-dodging position-shift that this
+ // variable needs to track.
+ nscoord mBEndEdgeShift = 0;
+
+ // The first and second value in the pair store the max block-end edges for
+ // items before and after applying the per-item position-shift in the block
+ // axis. We only record the block-end edges for items with first-in-flow
+ // frames placed in the current flex container fragment. This is used only by
+ // row-oriented flex containers.
+ Maybe<std::pair<nscoord, nscoord>> mMaxBEndEdge;
+};
+
+std::tuple<nscoord, bool> nsFlexContainerFrame::ReflowChildren(
+ const ReflowInput& aReflowInput, const nsSize& aContainerSize,
+ const LogicalSize& aAvailableSizeForItems,
+ const LogicalMargin& aBorderPadding, const FlexboxAxisTracker& aAxisTracker,
+ FlexLayoutResult& aFlr, PerFragmentFlexData& aFragmentData) {
+ if (HidesContentForLayout()) {
+ return {0, false};
+ }
+
+ // Before giving each child a final reflow, calculate the origin of the
+ // flex container's content box (with respect to its border-box), so that
+ // we can compute our flex item's final positions.
+ WritingMode flexWM = aReflowInput.GetWritingMode();
+ const LogicalPoint containerContentBoxOrigin(
+ flexWM, aBorderPadding.IStart(flexWM), aBorderPadding.BStart(flexWM));
+
+ // If the flex container has no baseline-aligned items, it will use the first
+ // item to determine its baseline:
+ const FlexItem* firstItem =
+ aFlr.mLines[0].IsEmpty() ? nullptr : &aFlr.mLines[0].FirstItem();
+
+ // The block-end of children is relative to the flex container's border-box.
+ nscoord maxBlockEndEdgeOfChildren = containerContentBoxOrigin.B(flexWM);
+
+ FirstLineOrFirstItemBAxisMetrics bAxisMetrics;
+ FrameHashtable pushedItems;
+ FrameHashtable incompleteItems;
+ FrameHashtable overflowIncompleteItems;
+
+ const bool isSingleLine =
+ StyleFlexWrap::Nowrap == aReflowInput.mStylePosition->mFlexWrap;
+
+ // FINAL REFLOW: Give each child frame another chance to reflow, now that
+ // we know its final size and position.
+ for (const FlexLine& line : aFlr.mLines) {
+ const bool isInFirstLine = &line == &aFlr.mLines[0];
+
+ for (const FlexItem& item : line.Items()) {
+ LogicalPoint framePos = aAxisTracker.LogicalPointFromFlexRelativePoint(
+ item.MainPosition(), item.CrossPosition(), aFlr.mContentBoxMainSize,
+ aFlr.mContentBoxCrossSize);
+ // This variable records the item's block-end edge before we give it a
+ // per-item-position-shift, if the item is a first-in-flow in the first
+ // line of a row-oriented flex container fragment. It is used to determine
+ // the block-end edge shift for the first line at the end of the outer
+ // loop.
+ Maybe<nscoord> frameBPosBeforePerItemShift;
+
+ if (item.Frame()->GetPrevInFlow()) {
+ // The item is a continuation. Lay it out at the beginning of the
+ // available space.
+ framePos.B(flexWM) = 0;
+ } else if (GetPrevInFlow()) {
+ // The item we're placing is not a continuation; though we're placing it
+ // into a flex container fragment which *is* a continuation. To compute
+ // the item's correct position in this fragment, we adjust the item's
+ // theoretical/unfragmented block-direction position by subtracting the
+ // cumulative content-box block-size for all the previous fragments and
+ // adding the cumulative block-end edge shift.
+ //
+ // Note that the item's position in this fragment has not been finalized
+ // yet. At this point, we've adjusted the item's
+ // theoretical/unfragmented position to be relative to the block-end
+ // edge of the previous container fragment's content-box. Later, we'll
+ // compute per-item position-shift to finalize its position.
+ framePos.B(flexWM) -= aFragmentData.mCumulativeContentBoxBSize;
+ framePos.B(flexWM) += aFragmentData.mCumulativeBEndEdgeShift;
+
+ // This helper gets the per-item position-shift in the block-axis.
+ auto GetPerItemPositionShiftToBEnd = [&]() {
+ if (framePos.B(flexWM) >= 0) {
+ // The item final position might be in current flex container
+ // fragment or in any of the later fragments. No adjustment needed.
+ return 0;
+ }
+
+ // The item's block position is negative, but we want to place it at
+ // the content-box block-start edge of this container fragment. To
+ // achieve this, return a negated (positive) value to make the final
+ // block position zero.
+ //
+ // This scenario occurs when fragmenting a row-oriented flex container
+ // where this item is pushed to this container fragment.
+ return -framePos.B(flexWM);
+ };
+
+ if (aAxisTracker.IsRowOriented()) {
+ if (isInFirstLine) {
+ frameBPosBeforePerItemShift.emplace(framePos.B(flexWM));
+ framePos.B(flexWM) += GetPerItemPositionShiftToBEnd();
+ } else {
+ // We've computed how far the block-end edge of the first line had
+ // to shift at the end of outer loop. Here, we just shift all items
+ // in rest of the lines by the same amount.
+ framePos.B(flexWM) += bAxisMetrics.mBEndEdgeShift;
+ }
+ } else {
+ MOZ_ASSERT(aAxisTracker.IsColumnOriented());
+ if (isSingleLine) {
+ if (&item == firstItem) {
+ bAxisMetrics.mBEndEdgeShift = GetPerItemPositionShiftToBEnd();
+ }
+ framePos.B(flexWM) += bAxisMetrics.mBEndEdgeShift;
+ } else {
+ // Bug 1806717: We need a more sophisticated solution for multi-line
+ // column-oriented flex container when each line has a different
+ // position-shift value. For now, we don't shift them.
+ }
+ }
+ }
+
+ // Adjust available block-size for the item. (We compute it here because
+ // framePos is still relative to the container's content-box.)
+ //
+ // Note: The available block-size can become negative if item's
+ // block-direction position is below available space's block-end.
+ const nscoord availableBSizeForItem =
+ aAvailableSizeForItems.BSize(flexWM) == NS_UNCONSTRAINEDSIZE
+ ? NS_UNCONSTRAINEDSIZE
+ : aAvailableSizeForItems.BSize(flexWM) - framePos.B(flexWM);
+
+ // Adjust framePos to be relative to the container's border-box
+ // (i.e. its frame rect), instead of the container's content-box:
+ framePos += containerContentBoxOrigin;
+
+ // Check if we actually need to reflow the item -- if the item's position
+ // is below the available space's block-end, push it to our next-in-flow;
+ // if it does need a reflow, and we already reflowed it with the right
+ // content-box size.
+ const bool childBPosExceedAvailableSpaceBEnd =
+ availableBSizeForItem != NS_UNCONSTRAINEDSIZE &&
+ availableBSizeForItem <= 0;
+ bool itemInPushedItems = false;
+ if (childBPosExceedAvailableSpaceBEnd) {
+ // Note: Even if all of our items are beyond the available space & get
+ // pushed here, we'll be guaranteed to place at least one of them (and
+ // make progress) in one of the flex container's *next* fragment. It's
+ // because ComputeAvailableSizeForItems() always reserves at least 1px
+ // available block-size for its children, and we consume all available
+ // block-size and add it to
+ // PerFragmentFlexData::mCumulativeContentBoxBSize even if we are not
+ // laying out any child.
+ FLEX_LOG(
+ "[frag] Flex item %p needed to be pushed to container's "
+ "next-in-flow due to position below available space's block-end",
+ item.Frame());
+ pushedItems.Insert(item.Frame());
+ itemInPushedItems = true;
+ } else if (item.NeedsFinalReflow(aReflowInput)) {
+ // The available size must be in item's writing-mode.
+ const WritingMode itemWM = item.GetWritingMode();
+ const auto availableSize =
+ LogicalSize(flexWM, aAvailableSizeForItems.ISize(flexWM),
+ availableBSizeForItem)
+ .ConvertTo(itemWM, flexWM);
+
+ const nsReflowStatus childReflowStatus =
+ ReflowFlexItem(aAxisTracker, aReflowInput, item, framePos,
+ availableSize, aContainerSize);
+
+ const bool shouldPushItem = [&]() {
+ if (availableBSizeForItem == NS_UNCONSTRAINEDSIZE) {
+ // If the available block-size is unconstrained, then we're not
+ // fragmenting and we don't want to push the item.
+ return false;
+ }
+ if (framePos.B(flexWM) == containerContentBoxOrigin.B(flexWM)) {
+ // The flex item is adjacent with block-start of the container's
+ // content-box. Don't push it, or we'll trap in an infinite loop.
+ return false;
+ }
+ if (item.Frame()->BSize() <= availableBSizeForItem) {
+ return false;
+ }
+ if (aAxisTracker.IsColumnOriented() &&
+ item.Frame()->StyleDisplay()->mBreakBefore ==
+ StyleBreakBetween::Avoid) {
+ return false;
+ }
+ return true;
+ }();
+ if (shouldPushItem) {
+ FLEX_LOG(
+ "[frag] Flex item %p needed to be pushed to container's "
+ "next-in-flow because its block-size is larger than the "
+ "available space",
+ item.Frame());
+ pushedItems.Insert(item.Frame());
+ itemInPushedItems = true;
+ } else if (childReflowStatus.IsIncomplete()) {
+ incompleteItems.Insert(item.Frame());
+ } else if (childReflowStatus.IsOverflowIncomplete()) {
+ overflowIncompleteItems.Insert(item.Frame());
+ }
+ } else {
+ MoveFlexItemToFinalPosition(item, framePos, aContainerSize);
+ }
+
+ if (!itemInPushedItems) {
+ const nscoord itemBSize = item.Frame()->BSize(flexWM);
+ const nscoord bEndEdgeAfterPerItemShift =
+ framePos.B(flexWM) + itemBSize;
+
+ // The item (or a fragment thereof) was placed in this flex container
+ // fragment. Update the max block-end edge with the item's block-end
+ // edge.
+ maxBlockEndEdgeOfChildren =
+ std::max(maxBlockEndEdgeOfChildren, bEndEdgeAfterPerItemShift);
+
+ if (frameBPosBeforePerItemShift) {
+ // Make the block-end edge relative to flex container's border-box
+ // because bEndEdgeAfterPerItemShift is relative to the border-box.
+ const nscoord bEndEdgeBeforePerItemShift =
+ containerContentBoxOrigin.B(flexWM) +
+ *frameBPosBeforePerItemShift + itemBSize;
+
+ if (bAxisMetrics.mMaxBEndEdge) {
+ auto& [before, after] = *bAxisMetrics.mMaxBEndEdge;
+ before = std::max(before, bEndEdgeBeforePerItemShift);
+ after = std::max(after, bEndEdgeAfterPerItemShift);
+ } else {
+ bAxisMetrics.mMaxBEndEdge.emplace(bEndEdgeBeforePerItemShift,
+ bEndEdgeAfterPerItemShift);
+ }
+ }
+ }
+
+ // If the item has auto margins, and we were tracking the UsedMargin
+ // property, set the property to the computed margin values.
+ if (item.HasAnyAutoMargin()) {
+ nsMargin* propValue =
+ item.Frame()->GetProperty(nsIFrame::UsedMarginProperty());
+ if (propValue) {
+ *propValue = item.PhysicalMargin();
+ }
+ }
+
+ // If this is our first item and we haven't established a baseline for
+ // the container yet (i.e. if we don't have 'align-self: baseline' on any
+ // children), then use this child's first baseline as the container's
+ // baseline.
+ if (&item == firstItem && aFlr.mAscent == nscoord_MIN) {
+ aFlr.mAscent = framePos.B(flexWM) + item.ResolvedAscent(true);
+ }
+ }
+
+ // Now we've finished processing all the items in the first line. Determine
+ // the amount by which the first line's block-end edge has shifted, so we
+ // can apply the same shift for the remaining lines.
+ if (GetPrevInFlow() && aAxisTracker.IsRowOriented() && isInFirstLine &&
+ bAxisMetrics.mMaxBEndEdge) {
+ auto& [before, after] = *bAxisMetrics.mMaxBEndEdge;
+ bAxisMetrics.mBEndEdgeShift = after - before;
+ }
+ }
+
+ if (!aFlr.mPlaceholders.IsEmpty()) {
+ ReflowPlaceholders(aReflowInput, aFlr.mPlaceholders,
+ containerContentBoxOrigin, aContainerSize);
+ }
+
+ const bool anyChildIncomplete = PushIncompleteChildren(
+ pushedItems, incompleteItems, overflowIncompleteItems);
+
+ // TODO: Try making this a fatal assertion after we fix bug 1751260.
+ NS_ASSERTION(!anyChildIncomplete ||
+ aAvailableSizeForItems.BSize(flexWM) != NS_UNCONSTRAINEDSIZE,
+ "We shouldn't have any incomplete children if the available "
+ "block-size is unconstrained!");
+
+ if (!pushedItems.IsEmpty()) {
+ AddStateBits(NS_STATE_FLEX_DID_PUSH_ITEMS);
+ }
+
+ if (GetPrevInFlow()) {
+ aFragmentData.mCumulativeBEndEdgeShift += bAxisMetrics.mBEndEdgeShift;
+ }
+
+ return {maxBlockEndEdgeOfChildren, anyChildIncomplete};
+}
+
+void nsFlexContainerFrame::PopulateReflowOutput(
+ ReflowOutput& aReflowOutput, const ReflowInput& aReflowInput,
+ nsReflowStatus& aStatus, const LogicalSize& aContentBoxSize,
+ const LogicalMargin& aBorderPadding, const nscoord aConsumedBSize,
+ const bool aMayNeedNextInFlow, const nscoord aMaxBlockEndEdgeOfChildren,
+ const bool aAnyChildIncomplete, nscoord aFlexContainerAscent,
+ nsTArray<FlexLine>& aLines, const FlexboxAxisTracker& aAxisTracker) {
+ const WritingMode flexWM = aReflowInput.GetWritingMode();
+
+ // Compute flex container's desired size (in its own writing-mode).
+ LogicalSize desiredSizeInFlexWM(flexWM);
+ desiredSizeInFlexWM.ISize(flexWM) =
+ aContentBoxSize.ISize(flexWM) + aBorderPadding.IStartEnd(flexWM);
+
+ // Unconditionally skip adding block-end border and padding for now. We add it
+ // lower down, after we've established baseline and decided whether bottom
+ // border-padding fits (if we're fragmented).
+ const nscoord effectiveContentBSizeWithBStartBP =
+ aContentBoxSize.BSize(flexWM) - aConsumedBSize +
+ aBorderPadding.BStart(flexWM);
+ nscoord blockEndContainerBP = aBorderPadding.BEnd(flexWM);
+
+ if (aMayNeedNextInFlow) {
+ // We assume our status should be reported as incomplete because we may need
+ // a next-in-flow.
+ bool isStatusIncomplete = true;
+
+ const nscoord availableBSizeMinusBEndBP =
+ aReflowInput.AvailableBSize() - aBorderPadding.BEnd(flexWM);
+
+ if (aMaxBlockEndEdgeOfChildren <= availableBSizeMinusBEndBP) {
+ // Consume all the available block-size.
+ desiredSizeInFlexWM.BSize(flexWM) = availableBSizeMinusBEndBP;
+ } else {
+ // This case happens if we have some tall unbreakable children exceeding
+ // the available block-size.
+ desiredSizeInFlexWM.BSize(flexWM) = std::min(
+ effectiveContentBSizeWithBStartBP, aMaxBlockEndEdgeOfChildren);
+
+ if ((aReflowInput.ComputedBSize() != NS_UNCONSTRAINEDSIZE ||
+ !aAnyChildIncomplete) &&
+ aMaxBlockEndEdgeOfChildren >= effectiveContentBSizeWithBStartBP) {
+ // We have some tall unbreakable child that's sticking off the end of
+ // our fragment, *and* forcing us to consume all of our remaining
+ // content block-size and call ourselves complete.
+ //
+ // - If we have a definite block-size: we get here if the tall child
+ // makes us reach that block-size.
+ // - If we have a content-based block-size: we get here if the tall
+ // child makes us reach the content-based block-size from a
+ // theoretical unfragmented layout, *and* all our children are
+ // complete. (Note that if we have some incomplete child, then we
+ // instead prefer to return an incomplete status, so we can get a
+ // next-in-flow to include that child's requested next-in-flow, in the
+ // spirit of having a block-size that fits the content.)
+ //
+ // TODO: the auto-height case might need more subtlety; see bug 1828977.
+ isStatusIncomplete = false;
+
+ // We also potentially need to get the unskipped block-end border and
+ // padding (if we assumed it'd be skipped as part of our tentative
+ // assumption that we'd be incomplete).
+ if (aReflowInput.mStyleBorder->mBoxDecorationBreak ==
+ StyleBoxDecorationBreak::Slice) {
+ blockEndContainerBP =
+ aReflowInput.ComputedLogicalBorderPadding(flexWM).BEnd(flexWM);
+ }
+ }
+ }
+
+ if (isStatusIncomplete) {
+ aStatus.SetIncomplete();
+ }
+ } else {
+ // Our own effective content-box block-size can fit within the available
+ // block-size.
+ desiredSizeInFlexWM.BSize(flexWM) = effectiveContentBSizeWithBStartBP;
+ }
+
+ if (aFlexContainerAscent == nscoord_MIN) {
+ // Still don't have our baseline set -- this happens if we have no
+ // children, if our children are huge enough that they have nscoord_MIN
+ // as their baseline, or our content is hidden in which case, we'll use the
+ // wrong baseline (but no big deal).
+ NS_WARNING_ASSERTION(
+ HidesContentForLayout() || aLines[0].IsEmpty(),
+ "Have flex items but didn't get an ascent - that's odd (or there are "
+ "just gigantic sizes involved)");
+ // Per spec, synthesize baseline from the flex container's content box
+ // (i.e. use block-end side of content-box)
+ // XXXdholbert This only makes sense if parent's writing mode is
+ // horizontal (& even then, really we should be using the BSize in terms
+ // of the parent's writing mode, not ours). Clean up in bug 1155322.
+ aFlexContainerAscent = desiredSizeInFlexWM.BSize(flexWM);
+ }
+
+ if (HasAnyStateBits(NS_STATE_FLEX_SYNTHESIZE_BASELINE)) {
+ // This will force our parent to call GetLogicalBaseline, which will
+ // synthesize a margin-box baseline.
+ aReflowOutput.SetBlockStartAscent(ReflowOutput::ASK_FOR_BASELINE);
+ } else {
+ // XXXdholbert aFlexContainerAscent needs to be in terms of
+ // our parent's writing-mode here. See bug 1155322.
+ aReflowOutput.SetBlockStartAscent(aFlexContainerAscent);
+ }
+
+ // Now, we account for how the block-end border and padding (if any) impacts
+ // our desired size. If adding it pushes us over the available block-size,
+ // then we become incomplete (unless we already weren't asking for any
+ // block-size, in which case we stay complete to avoid looping forever).
+ //
+ // NOTE: If we have auto block-size, we allow our block-end border and padding
+ // to push us over the available block-size without requesting a continuation,
+ // for consistency with the behavior of "display:block" elements.
+ const nscoord effectiveContentBSizeWithBStartEndBP =
+ desiredSizeInFlexWM.BSize(flexWM) + blockEndContainerBP;
+
+ if (aReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE &&
+ effectiveContentBSizeWithBStartEndBP > aReflowInput.AvailableBSize() &&
+ desiredSizeInFlexWM.BSize(flexWM) != 0 &&
+ aReflowInput.ComputedBSize() != NS_UNCONSTRAINEDSIZE) {
+ // We couldn't fit with the block-end border and padding included, so we'll
+ // need a continuation.
+ aStatus.SetIncomplete();
+
+ if (aReflowInput.mStyleBorder->mBoxDecorationBreak ==
+ StyleBoxDecorationBreak::Slice) {
+ blockEndContainerBP = 0;
+ }
+ }
+
+ // The variable "blockEndContainerBP" now accurately reflects how much (if
+ // any) block-end border and padding we want for this frame, so we can proceed
+ // to add it in.
+ desiredSizeInFlexWM.BSize(flexWM) += blockEndContainerBP;
+
+ if (aStatus.IsComplete() && aAnyChildIncomplete) {
+ aStatus.SetOverflowIncomplete();
+ aStatus.SetNextInFlowNeedsReflow();
+ }
+
+ // If we are the first-in-flow and not fully complete (either our block-size
+ // or any of our flex items cannot fit in the available block-size), and the
+ // style requires us to avoid breaking inside, set the status to prompt our
+ // parent to push us to the next page/column.
+ if (!GetPrevInFlow() && !aStatus.IsFullyComplete() &&
+ ShouldAvoidBreakInside(aReflowInput)) {
+ aStatus.SetInlineLineBreakBeforeAndReset();
+ return;
+ }
+
+ // Calculate the container baselines so that our parent can baseline-align us.
+ mBaselineFromLastReflow = aFlexContainerAscent;
+ mLastBaselineFromLastReflow = aLines.LastElement().LastBaselineOffset();
+ if (mLastBaselineFromLastReflow == nscoord_MIN) {
+ // XXX we fall back to a mirrored first baseline here for now, but this
+ // should probably use the last baseline of the last item or something.
+ mLastBaselineFromLastReflow =
+ desiredSizeInFlexWM.BSize(flexWM) - aFlexContainerAscent;
+ }
+
+ // Convert flex container's final desired size to parent's WM, for outparam.
+ aReflowOutput.SetSize(flexWM, desiredSizeInFlexWM);
+}
+
+void nsFlexContainerFrame::MoveFlexItemToFinalPosition(
+ const FlexItem& aItem, const LogicalPoint& aFramePos,
+ const nsSize& aContainerSize) {
+ const WritingMode outerWM = aItem.ContainingBlockWM();
+ const nsStyleDisplay* display = aItem.Frame()->StyleDisplay();
+ LogicalPoint pos(aFramePos);
+ if (display->IsRelativelyOrStickyPositionedStyle()) {
+ // If the item is relatively positioned, look up its offsets (cached from
+ // previous reflow). A sticky positioned item can pass a dummy
+ // logicalOffsets into ApplyRelativePositioning().
+ LogicalMargin logicalOffsets(outerWM);
+ if (display->IsRelativelyPositionedStyle()) {
+ nsMargin* cachedOffsets =
+ aItem.Frame()->GetProperty(nsIFrame::ComputedOffsetProperty());
+ MOZ_ASSERT(
+ cachedOffsets,
+ "relpos previously-reflowed frame should've cached its offsets");
+ logicalOffsets = LogicalMargin(outerWM, *cachedOffsets);
+ }
+ ReflowInput::ApplyRelativePositioning(aItem.Frame(), outerWM,
+ logicalOffsets, &pos, aContainerSize);
+ }
+
+ FLEX_LOG("Moving flex item %p to its desired position %s", aItem.Frame(),
+ ToString(pos).c_str());
+ aItem.Frame()->SetPosition(outerWM, pos, aContainerSize);
+ PositionFrameView(aItem.Frame());
+ PositionChildViews(aItem.Frame());
+}
+
+nsReflowStatus nsFlexContainerFrame::ReflowFlexItem(
+ const FlexboxAxisTracker& aAxisTracker, const ReflowInput& aReflowInput,
+ const FlexItem& aItem, const LogicalPoint& aFramePos,
+ const LogicalSize& aAvailableSize, const nsSize& aContainerSize) {
+ FLEX_LOG("Doing final reflow for flex item %p", aItem.Frame());
+
+ WritingMode outerWM = aReflowInput.GetWritingMode();
+
+ StyleSizeOverrides sizeOverrides;
+ // Override flex item's main size.
+ if (aItem.IsInlineAxisMainAxis()) {
+ sizeOverrides.mStyleISize.emplace(aItem.StyleMainSize());
+ FLEX_LOGV(" Main size (inline-size) override: %d", aItem.MainSize());
+ } else {
+ sizeOverrides.mStyleBSize.emplace(aItem.StyleMainSize());
+ FLEX_LOGV(" Main size (block-size) override: %d", aItem.MainSize());
+ }
+
+ // Override flex item's cross size if it was stretched in the cross axis (in
+ // which case we're imposing a cross size).
+ if (aItem.IsStretched()) {
+ if (aItem.IsInlineAxisCrossAxis()) {
+ sizeOverrides.mStyleISize.emplace(aItem.StyleCrossSize());
+ FLEX_LOGV(" Cross size (inline-size) override: %d", aItem.CrossSize());
+ } else {
+ sizeOverrides.mStyleBSize.emplace(aItem.StyleCrossSize());
+ FLEX_LOGV(" Cross size (block-size) override: %d", aItem.CrossSize());
+ }
+ }
+ if (sizeOverrides.mStyleBSize) {
+ // We are overriding the block-size. For robustness, we always assume that
+ // this represents a block-axis resize for the frame. This may be
+ // conservative, but we do capture all the conditions in the block-axis
+ // (checked in NeedsFinalReflow()) that make this item require a final
+ // reflow. This sets relevant flags in ReflowInput::InitResizeFlags().
+ aItem.Frame()->SetHasBSizeChange(true);
+ }
+
+ ReflowInput childReflowInput(PresContext(), aReflowInput, aItem.Frame(),
+ aAvailableSize, Nothing(), {}, sizeOverrides);
+
+ if (aItem.TreatBSizeAsIndefinite() && aItem.IsBlockAxisMainAxis()) {
+ childReflowInput.mFlags.mTreatBSizeAsIndefinite = true;
+ }
+
+ if (aItem.IsStretched() && aItem.IsBlockAxisCrossAxis()) {
+ // This item is stretched (in the cross axis), and that axis is its block
+ // axis. That stretching effectively gives it a relative BSize.
+ // XXXdholbert This flag only makes a difference if we use the flex items'
+ // frame-state when deciding whether to reflow them -- and we don't, as of
+ // the changes in bug 851607. So this has no effect right now, but it might
+ // make a difference if we optimize to use dirty bits in the
+ // future. (Reftests flexbox-resizeviewport-1.xhtml and -2.xhtml are
+ // intended to catch any regressions here, if we end up relying on this bit
+ // & neglecting to set it.)
+ aItem.Frame()->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);
+ }
+
+ // NOTE: Be very careful about doing anything else with childReflowInput
+ // after this point, because some of its methods (e.g. SetComputedWidth)
+ // internally call InitResizeFlags and stomp on mVResize & mHResize.
+
+ FLEX_LOG("Reflowing flex item %p at its desired position %s", aItem.Frame(),
+ ToString(aFramePos).c_str());
+
+ // CachedFlexItemData is stored in item's writing mode, so we pass
+ // aChildReflowInput into ReflowOutput's constructor.
+ ReflowOutput childReflowOutput(childReflowInput);
+ nsReflowStatus childReflowStatus;
+ ReflowChild(aItem.Frame(), PresContext(), childReflowOutput, childReflowInput,
+ outerWM, aFramePos, aContainerSize, ReflowChildFlags::Default,
+ childReflowStatus);
+
+ // XXXdholbert Perhaps we should call CheckForInterrupt here; see bug 1495532.
+
+ FinishReflowChild(aItem.Frame(), PresContext(), childReflowOutput,
+ &childReflowInput, outerWM, aFramePos, aContainerSize,
+ ReflowChildFlags::ApplyRelativePositioning);
+
+ aItem.SetAscent(childReflowOutput.BlockStartAscent());
+
+ // Update our cached flex item info:
+ if (auto* cached = aItem.Frame()->GetProperty(CachedFlexItemData::Prop())) {
+ cached->Update(childReflowInput, childReflowOutput,
+ FlexItemReflowType::Final);
+ } else {
+ cached = new CachedFlexItemData(childReflowInput, childReflowOutput,
+ FlexItemReflowType::Final);
+ aItem.Frame()->SetProperty(CachedFlexItemData::Prop(), cached);
+ }
+
+ return childReflowStatus;
+}
+
+void nsFlexContainerFrame::ReflowPlaceholders(
+ const ReflowInput& aReflowInput, nsTArray<nsIFrame*>& aPlaceholders,
+ const LogicalPoint& aContentBoxOrigin, const nsSize& aContainerSize) {
+ WritingMode outerWM = aReflowInput.GetWritingMode();
+
+ // As noted in this method's documentation, we'll reflow every entry in
+ // |aPlaceholders| at the container's content-box origin.
+ for (nsIFrame* placeholder : aPlaceholders) {
+ MOZ_ASSERT(placeholder->IsPlaceholderFrame(),
+ "placeholders array should only contain placeholder frames");
+ WritingMode wm = placeholder->GetWritingMode();
+ LogicalSize availSize = aReflowInput.ComputedSize(wm);
+ ReflowInput childReflowInput(PresContext(), aReflowInput, placeholder,
+ availSize);
+ // No need to set the -webkit-line-clamp related flags when reflowing
+ // a placeholder.
+ ReflowOutput childReflowOutput(outerWM);
+ nsReflowStatus childReflowStatus;
+ ReflowChild(placeholder, PresContext(), childReflowOutput, childReflowInput,
+ outerWM, aContentBoxOrigin, aContainerSize,
+ ReflowChildFlags::Default, childReflowStatus);
+
+ FinishReflowChild(placeholder, PresContext(), childReflowOutput,
+ &childReflowInput, outerWM, aContentBoxOrigin,
+ aContainerSize, ReflowChildFlags::Default);
+
+ // Mark the placeholder frame to indicate that it's not actually at the
+ // element's static position, because we need to apply CSS Alignment after
+ // we determine the OOF's size:
+ placeholder->AddStateBits(PLACEHOLDER_STATICPOS_NEEDS_CSSALIGN);
+ }
+}
+
+nscoord nsFlexContainerFrame::IntrinsicISize(gfxContext* aRenderingContext,
+ IntrinsicISizeType aType) {
+ nscoord containerISize = 0;
+ const nsStylePosition* stylePos = StylePosition();
+ const FlexboxAxisTracker axisTracker(this);
+
+ nscoord mainGapSize;
+ if (axisTracker.IsRowOriented()) {
+ mainGapSize = nsLayoutUtils::ResolveGapToLength(stylePos->mColumnGap,
+ NS_UNCONSTRAINEDSIZE);
+ } else {
+ mainGapSize = nsLayoutUtils::ResolveGapToLength(stylePos->mRowGap,
+ NS_UNCONSTRAINEDSIZE);
+ }
+
+ const bool useMozBoxCollapseBehavior =
+ StyleVisibility()->UseLegacyCollapseBehavior();
+
+ // The loop below sets aside space for a gap before each item besides the
+ // first. This bool helps us handle that special-case.
+ bool onFirstChild = true;
+
+ for (nsIFrame* childFrame : mFrames) {
+ // Skip out-of-flow children because they don't participate in flex layout.
+ if (childFrame->IsPlaceholderFrame()) {
+ continue;
+ }
+
+ if (useMozBoxCollapseBehavior &&
+ childFrame->StyleVisibility()->IsCollapse()) {
+ // If we're using legacy "visibility:collapse" behavior, then we don't
+ // care about the sizes of any collapsed children.
+ continue;
+ }
+
+ nscoord childISize = nsLayoutUtils::IntrinsicForContainer(
+ aRenderingContext, childFrame, aType);
+
+ // * For a row-oriented single-line flex container, the intrinsic
+ // {min/pref}-isize is the sum of its items' {min/pref}-isizes and
+ // (n-1) column gaps.
+ // * For a column-oriented flex container, the intrinsic min isize
+ // is the max of its items' min isizes.
+ // * For a row-oriented multi-line flex container, the intrinsic
+ // pref isize is former (sum), and its min isize is the latter (max).
+ bool isSingleLine = (StyleFlexWrap::Nowrap == stylePos->mFlexWrap);
+ if (axisTracker.IsRowOriented() &&
+ (isSingleLine || aType == IntrinsicISizeType::PrefISize)) {
+ containerISize += childISize;
+ if (!onFirstChild) {
+ containerISize += mainGapSize;
+ }
+ onFirstChild = false;
+ } else { // (col-oriented, or MinISize for multi-line row flex container)
+ containerISize = std::max(containerISize, childISize);
+ }
+ }
+
+ return containerISize;
+}
+
+/* virtual */
+nscoord nsFlexContainerFrame::GetMinISize(gfxContext* aRenderingContext) {
+ DISPLAY_MIN_INLINE_SIZE(this, mCachedMinISize);
+ if (mCachedMinISize == NS_INTRINSIC_ISIZE_UNKNOWN) {
+ if (Maybe<nscoord> containISize = ContainIntrinsicISize()) {
+ mCachedMinISize = *containISize;
+ } else {
+ mCachedMinISize =
+ IntrinsicISize(aRenderingContext, IntrinsicISizeType::MinISize);
+ }
+ }
+
+ return mCachedMinISize;
+}
+
+/* virtual */
+nscoord nsFlexContainerFrame::GetPrefISize(gfxContext* aRenderingContext) {
+ DISPLAY_PREF_INLINE_SIZE(this, mCachedPrefISize);
+ if (mCachedPrefISize == NS_INTRINSIC_ISIZE_UNKNOWN) {
+ if (Maybe<nscoord> containISize = ContainIntrinsicISize()) {
+ mCachedPrefISize = *containISize;
+ } else {
+ mCachedPrefISize =
+ IntrinsicISize(aRenderingContext, IntrinsicISizeType::PrefISize);
+ }
+ }
+
+ return mCachedPrefISize;
+}
+
+int32_t nsFlexContainerFrame::GetNumLines() const {
+ // TODO(emilio, bug 1793251): Treating all row oriented frames as single-lines
+ // might not be great for flex-wrap'd containers, consider trying to do
+ // better? We probably would need to persist more stuff than we do after
+ // layout.
+ return FlexboxAxisInfo(this).mIsRowOriented ? 1 : mFrames.GetLength();
+}
+
+bool nsFlexContainerFrame::IsLineIteratorFlowRTL() {
+ FlexboxAxisInfo info(this);
+ if (info.mIsRowOriented) {
+ const bool isRtl = StyleVisibility()->mDirection == StyleDirection::Rtl;
+ return info.mIsMainAxisReversed != isRtl;
+ }
+ return false;
+}
+
+Result<nsILineIterator::LineInfo, nsresult> nsFlexContainerFrame::GetLine(
+ int32_t aLineNumber) {
+ if (aLineNumber < 0 || aLineNumber >= GetNumLines()) {
+ return Err(NS_ERROR_FAILURE);
+ }
+ FlexboxAxisInfo info(this);
+ LineInfo lineInfo;
+ if (info.mIsRowOriented) {
+ lineInfo.mLineBounds = GetRect();
+ lineInfo.mFirstFrameOnLine = mFrames.FirstChild();
+ // This isn't quite ideal for multi-line row flexbox, see bug 1793251.
+ lineInfo.mNumFramesOnLine = mFrames.GetLength();
+ } else {
+ // TODO(emilio, bug 1793322): Deal with column-reverse (mIsMainAxisReversed)
+ nsIFrame* f = mFrames.FrameAt(aLineNumber);
+ lineInfo.mLineBounds = f->GetRect();
+ lineInfo.mFirstFrameOnLine = f;
+ lineInfo.mNumFramesOnLine = 1;
+ }
+ return lineInfo;
+}
+
+int32_t nsFlexContainerFrame::FindLineContaining(nsIFrame* aFrame,
+ int32_t aStartLine) {
+ const int32_t index = mFrames.IndexOf(aFrame);
+ if (index < 0) {
+ return -1;
+ }
+ const FlexboxAxisInfo info(this);
+ if (info.mIsRowOriented) {
+ return 0;
+ }
+ if (index < aStartLine) {
+ return -1;
+ }
+ return index;
+}
+
+NS_IMETHODIMP
+nsFlexContainerFrame::CheckLineOrder(int32_t aLine, bool* aIsReordered,
+ nsIFrame** aFirstVisual,
+ nsIFrame** aLastVisual) {
+ *aIsReordered = false;
+ *aFirstVisual = nullptr;
+ *aLastVisual = nullptr;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFlexContainerFrame::FindFrameAt(int32_t aLineNumber, nsPoint aPos,
+ nsIFrame** aFrameFound,
+ bool* aPosIsBeforeFirstFrame,
+ bool* aPosIsAfterLastFrame) {
+ const auto wm = GetWritingMode();
+ const LogicalPoint pos(wm, aPos, GetSize());
+ const FlexboxAxisInfo info(this);
+
+ *aFrameFound = nullptr;
+ *aPosIsBeforeFirstFrame = true;
+ *aPosIsAfterLastFrame = false;
+
+ if (!info.mIsRowOriented) {
+ 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;
+ }
+
+ LineFrameFinder finder(aPos, GetSize(), GetWritingMode(),
+ IsLineIteratorFlowRTL());
+ for (nsIFrame* f : mFrames) {
+ finder.Scan(f);
+ if (finder.IsDone()) {
+ break;
+ }
+ }
+ finder.Finish(aFrameFound, aPosIsBeforeFirstFrame, aPosIsAfterLastFrame);
+ return NS_OK;
+}