Skip to main content

layout/flexbox/
layout.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5use std::cell::{Cell, LazyCell};
6use std::cmp::Ordering;
7use std::sync::Arc;
8
9use app_units::Au;
10use atomic_refcell::AtomicRef;
11use itertools::izip;
12use rayon::iter::{
13    IndexedParallelIterator, IntoParallelIterator, ParallelDrainRange, ParallelIterator,
14};
15use style::Zero;
16use style::computed_values::position::T as Position;
17use style::logical_geometry::{LogicalAxis, WritingMode};
18use style::properties::ComputedValues;
19use style::properties::longhands::align_items::computed_value::T as AlignItems;
20use style::properties::longhands::box_sizing::computed_value::T as BoxSizing;
21use style::properties::longhands::flex_wrap::computed_value::T as FlexWrap;
22use style::values::computed::LengthPercentage;
23use style::values::generics::flex::GenericFlexBasis as FlexBasis;
24use style::values::generics::length::LengthPercentageOrNormal;
25use style::values::specified::align::AlignFlags;
26
27use super::geom::{FlexAxis, FlexRelativeRect, FlexRelativeSides, FlexRelativeVec2};
28use super::{FlexContainer, FlexContainerConfig, FlexItemBox, FlexLevelBox};
29use crate::cell::ArcRefCell;
30use crate::containing_block::{
31    ConstraintSpace, ContainingBlock, ContainingBlockSize, IndefiniteContainingBlock,
32};
33use crate::context::LayoutContext;
34use crate::dom::WeakLayoutBox;
35use crate::formatting_contexts::Baselines;
36use crate::fragment_tree::{
37    BoxFragment, CollapsedBlockMargins, Fragment, FragmentChildren, FragmentFlags,
38    SpecificLayoutInfo,
39};
40use crate::geom::{AuOrAuto, LogicalRect, LogicalSides, LogicalVec2};
41use crate::layout_box_base::IndependentFormattingContextLayoutResult;
42use crate::positioned::{
43    AbsolutelyPositionedBox, PositioningContext, PositioningContextLength, StaticPositionRect,
44    relative_adjustement,
45};
46use crate::sizing::{
47    ComputeInlineContentSizes, ContentSizes, InlineContentSizesResult, IntrinsicSizingMode,
48    LazySize, Size, SizeConstraint, Sizes,
49};
50use crate::style_ext::{AspectRatio, Clamp, ComputedValuesExt, ContentBoxSizesAndPBM, LayoutStyle};
51
52/// Layout parameters and intermediate results about a flex container,
53/// grouped to avoid passing around many parameters
54struct FlexContext<'a> {
55    config: FlexContainerConfig,
56    layout_context: &'a LayoutContext<'a>,
57    containing_block: &'a ContainingBlock<'a>, // For items
58    container_inner_size_constraint: FlexRelativeVec2<SizeConstraint>,
59}
60
61/// A flex item with some intermediate results
62struct FlexItem<'a> {
63    box_: &'a FlexItemBox,
64
65    /// The preferred, min and max inner cross sizes.
66    content_cross_sizes: Sizes,
67
68    padding: FlexRelativeSides<Au>,
69    border: FlexRelativeSides<Au>,
70    margin: FlexRelativeSides<AuOrAuto>,
71
72    /// Sum of padding, border, and margin (with `auto` assumed to be zero) in each axis.
73    /// This is the difference between an outer and inner size.
74    pbm_auto_is_zero: FlexRelativeVec2<Au>,
75
76    /// <https://drafts.csswg.org/css-flexbox/#algo-main-item>
77    flex_base_size: Au,
78
79    /// Whether the [`Self::flex_base_size`] comes from a definite `flex-basis`.
80    /// If false and the container main size is also indefinite, percentages in the item's
81    /// content that resolve against its main size should be indefinite.
82    flex_base_size_is_definite: bool,
83
84    /// <https://drafts.csswg.org/css-flexbox/#algo-main-item>
85    hypothetical_main_size: Au,
86
87    /// The used min main size of the flex item.
88    /// <https://drafts.csswg.org/css-flexbox/#min-main-size-property>
89    content_min_main_size: Au,
90
91    /// The used max main size of the flex item.
92    /// <https://drafts.csswg.org/css-flexbox/#max-main-size-property>
93    content_max_main_size: Option<Au>,
94
95    /// This is `align-self`, defaulting to `align-items` if `auto`
96    align_self: AlignItems,
97
98    /// Whether or not the size of this [`FlexItem`] depends on its block constraints.
99    depends_on_block_constraints: bool,
100
101    /// <https://drafts.csswg.org/css-sizing-4/#preferred-aspect-ratio>
102    preferred_aspect_ratio: Option<AspectRatio>,
103
104    /// The automatic size in the cross axis.
105    /// <https://drafts.csswg.org/css-sizing-3/#automatic-size>
106    automatic_cross_size: Size<Au>,
107    automatic_cross_size_for_intrinsic_sizing: Size<Au>,
108}
109
110/// Child of a FlexContainer. Can either be absolutely positioned, or not. If not,
111/// a placeholder is used and flex content is stored outside of this enum.
112enum FlexContent {
113    AbsolutelyPositionedBox(ArcRefCell<AbsolutelyPositionedBox>),
114    FlexItemPlaceholder,
115}
116
117/// Return type of `FlexItem::layout`
118struct FlexItemLayoutResult {
119    hypothetical_cross_size: Au,
120    fragments: FragmentChildren,
121    positioning_context: PositioningContext,
122
123    /// Baselines from the item’s content, relative to the item’s margin box.
124    /// Used only for baseline propagation to parent layout contexts.
125    content_baselines_for_parent_relative_to_margin_box: Baselines,
126
127    /// This is the single baseline this item uses for flex alignment.
128    /// Either the first or the last baseline or None, depending on ‘align-self’.
129    flex_alignment_baseline_relative_to_margin_box: Option<Au>,
130
131    // The content size of this layout in the block axis. This is known before layout
132    // for replaced elements, but for non-replaced it's only known after layout.
133    content_block_size: Au,
134
135    // The containing block size used to generate this layout.
136    containing_block_size: ContainingBlockSize,
137
138    // Whether or not this layout depended on block constraints.
139    depends_on_block_constraints: bool,
140
141    // The specific layout info that this flex item had.
142    specific_layout_info: Option<SpecificLayoutInfo>,
143}
144
145/// A data structure to hold all of the information about a flex item that has been placed
146/// into a flex line. This happens once the item is laid out and its line has been determined.
147struct FlexLineItem<'a> {
148    /// The items that are placed in this line.
149    item: FlexItem<'a>,
150
151    /// The layout results of the initial layout pass for a flex line. These may be replaced
152    /// if necessary due to the use of `align-content: stretch` or `align-self: stretch`.
153    layout_result: FlexItemLayoutResult,
154
155    /// The used main size of this item in its line.
156    used_main_size: Au,
157}
158
159impl FlexLineItem<'_> {
160    fn get_or_synthesize_baseline_with_cross_size(
161        &self,
162        cross_size: Au,
163        flex_container_config: &FlexContainerConfig,
164    ) -> Au {
165        self.layout_result
166            .flex_alignment_baseline_relative_to_margin_box
167            .unwrap_or_else(|| {
168                self.item
169                    .synthesized_baseline_relative_to_margin_box(cross_size, flex_container_config)
170            })
171    }
172
173    #[expect(clippy::too_many_arguments)]
174    fn collect_fragment(
175        mut self,
176        initial_flex_layout: &InitialFlexLineLayout,
177        item_used_size: FlexRelativeVec2<Au>,
178        item_margin: FlexRelativeSides<Au>,
179        item_main_interval: Au,
180        final_line_cross_size: Au,
181        shared_alignment_baseline: &Option<Au>,
182        flex_context: &mut FlexContext,
183        all_baselines: &mut Baselines,
184        main_position_cursor: &mut Au,
185    ) -> (Arc<BoxFragment>, PositioningContext) {
186        // https://drafts.csswg.org/css-flexbox/#algo-main-align
187        // “Align the items along the main-axis”
188        *main_position_cursor +=
189            item_margin.main_start + self.item.border.main_start + self.item.padding.main_start;
190        let item_content_main_start_position = *main_position_cursor;
191
192        *main_position_cursor += item_used_size.main +
193            self.item.padding.main_end +
194            self.item.border.main_end +
195            item_margin.main_end +
196            item_main_interval;
197
198        // https://drafts.csswg.org/css-flexbox/#algo-cross-align
199        let item_content_cross_start_position = self.item.align_along_cross_axis(
200            &item_margin,
201            &item_used_size.cross,
202            final_line_cross_size,
203            self.layout_result
204                .flex_alignment_baseline_relative_to_margin_box
205                .unwrap_or_default(),
206            shared_alignment_baseline.unwrap_or_default(),
207            flex_context.config.flex_wrap_is_reversed,
208        );
209
210        let start_corner = FlexRelativeVec2 {
211            main: item_content_main_start_position,
212            cross: item_content_cross_start_position,
213        };
214
215        // Need to collect both baselines from baseline participation and other baselines.
216        let final_line_size = FlexRelativeVec2 {
217            main: initial_flex_layout.line_size.main,
218            cross: final_line_cross_size,
219        };
220        let content_rect = flex_context.rect_to_flow_relative(
221            final_line_size,
222            FlexRelativeRect {
223                start_corner,
224                size: item_used_size,
225            },
226        );
227
228        let adjust_baseline = |baseline: Au| {
229            baseline + item_content_cross_start_position -
230                self.item.border.cross_start -
231                self.item.padding.cross_start -
232                item_margin.cross_start
233        };
234
235        let baselines = self
236            .layout_result
237            .content_baselines_for_parent_relative_to_margin_box;
238        if flex_context.config.flex_direction_is_reversed {
239            if let Some(last_baseline) = baselines.last {
240                all_baselines
241                    .last
242                    .get_or_insert_with(|| adjust_baseline(last_baseline));
243            }
244            if let Some(first_baseline) = baselines.first {
245                all_baselines.first = Some(adjust_baseline(first_baseline));
246            }
247        } else {
248            if let Some(first_baseline) = baselines.first {
249                all_baselines
250                    .first
251                    .get_or_insert_with(|| adjust_baseline(first_baseline));
252            }
253            if let Some(last_baseline) = baselines.last {
254                all_baselines.last = Some(adjust_baseline(last_baseline));
255            }
256        }
257
258        let mut fragment_info = self.item.box_.base_fragment_info();
259        fragment_info
260            .flags
261            .insert(FragmentFlags::IS_FLEX_OR_GRID_ITEM);
262        if self.item.depends_on_block_constraints {
263            fragment_info.flags.insert(
264                FragmentFlags::SIZE_DEPENDS_ON_BLOCK_CONSTRAINTS_AND_CAN_BE_CHILD_OF_FLEX_ITEM,
265            );
266        }
267        let flags = fragment_info.flags;
268
269        let containing_block = flex_context.containing_block;
270        let container_writing_mode = containing_block.style.writing_mode;
271        let style = self.item.box_.style();
272
273        let mut fragment = BoxFragment::new(
274            fragment_info,
275            style.clone(),
276            self.layout_result.fragments,
277            content_rect.as_physical_deprecated(flex_context.containing_block),
278            flex_context
279                .sides_to_flow_relative(self.item.padding)
280                .to_physical(container_writing_mode),
281            flex_context
282                .sides_to_flow_relative(self.item.border)
283                .to_physical(container_writing_mode),
284            flex_context
285                .sides_to_flow_relative(item_margin)
286                .to_physical(container_writing_mode),
287            self.layout_result.specific_layout_info,
288        );
289
290        // If this flex item establishes a containing block for absolutely-positioned
291        // descendants, then lay out any relevant absolutely-positioned children. This
292        // will remove those children from `self.positioning_context`.
293        if style.establishes_containing_block_for_absolute_descendants(flags) {
294            self.layout_result
295                .positioning_context
296                .layout_collected_children(flex_context.layout_context, &mut fragment);
297        }
298
299        if style.get_box().position == Position::Relative {
300            fragment.base.translate_rect(
301                relative_adjustement(style, containing_block)
302                    .to_physical_size(containing_block.style.writing_mode),
303            );
304        }
305
306        let fragment = Arc::new(fragment);
307        self.item
308            .box_
309            .independent_formatting_context
310            .base
311            .set_fragment(Fragment::Box(fragment.clone()));
312        (fragment, self.layout_result.positioning_context)
313    }
314}
315
316/// Once the final cross size of a line is known, the line can go through their final
317/// layout and this the return value. See [`InitialFlexLineLayout::finish_with_final_cross_size`].
318struct FinalFlexLineLayout {
319    /// The final cross size of this flex line.
320    cross_size: Au,
321    /// The [`BoxFragment`]s and [`PositioningContext`]s of all flex items,
322    /// one per flex item in "order-modified document order."
323    item_fragments: Vec<(Arc<BoxFragment>, PositioningContext)>,
324    /// The 'shared alignment baseline' of this flex line. This is the baseline used for
325    /// baseline-aligned items if there are any, otherwise `None`.
326    shared_alignment_baseline: Option<Au>,
327    /// This is the baseline of the first and last items with compatible writing mode, regardless of
328    /// whether they particpate in baseline alignement. This is used as a fallback baseline for the
329    /// container, if there are no items participating in baseline alignment in the first or last
330    /// flex lines.
331    all_baselines: Baselines,
332}
333
334impl FlexContainerConfig {
335    fn resolve_reversable_flex_alignment(
336        &self,
337        align_flags: AlignFlags,
338        reversed: bool,
339    ) -> AlignFlags {
340        match (align_flags.value(), reversed) {
341            (AlignFlags::FLEX_START, false) => AlignFlags::START | align_flags.flags(),
342            (AlignFlags::FLEX_START, true) => AlignFlags::END | align_flags.flags(),
343            (AlignFlags::FLEX_END, false) => AlignFlags::END | align_flags.flags(),
344            (AlignFlags::FLEX_END, true) => AlignFlags::START | align_flags.flags(),
345            (_, _) => align_flags,
346        }
347    }
348
349    fn resolve_align_self_for_child(&self, child_style: &ComputedValues) -> AlignFlags {
350        self.resolve_reversable_flex_alignment(
351            child_style
352                .resolve_align_self(self.align_items, AlignFlags::STRETCH)
353                .0,
354            self.flex_wrap_is_reversed,
355        )
356    }
357
358    fn resolve_justify_content_for_child(&self) -> AlignFlags {
359        self.resolve_reversable_flex_alignment(
360            self.justify_content.primary(),
361            self.flex_direction_is_reversed,
362        )
363    }
364
365    fn sides_to_flex_relative<T>(&self, sides: LogicalSides<T>) -> FlexRelativeSides<T> {
366        self.main_start_cross_start_sides_are
367            .sides_to_flex_relative(sides)
368    }
369
370    fn sides_to_flow_relative<T>(&self, sides: FlexRelativeSides<T>) -> LogicalSides<T> {
371        self.main_start_cross_start_sides_are
372            .sides_to_flow_relative(sides)
373    }
374}
375
376impl FlexContext<'_> {
377    #[inline]
378    fn sides_to_flow_relative<T>(&self, x: FlexRelativeSides<T>) -> LogicalSides<T> {
379        self.config.sides_to_flow_relative(x)
380    }
381
382    #[inline]
383    fn rect_to_flow_relative(
384        &self,
385        base_rect_size: FlexRelativeVec2<Au>,
386        rect: FlexRelativeRect<Au>,
387    ) -> LogicalRect<Au> {
388        super::geom::rect_to_flow_relative(
389            self.config.flex_axis,
390            self.config.main_start_cross_start_sides_are,
391            base_rect_size,
392            rect,
393        )
394    }
395}
396
397#[derive(Debug, Default)]
398struct DesiredFlexFractionAndGrowOrShrinkFactor {
399    desired_flex_fraction: f32,
400    flex_grow_or_shrink_factor: f32,
401}
402
403#[derive(Default)]
404struct FlexItemBoxInlineContentSizesInfo {
405    outer_flex_base_size: Au,
406    outer_min_main_size: Au,
407    outer_max_main_size: Option<Au>,
408    min_flex_factors: DesiredFlexFractionAndGrowOrShrinkFactor,
409    max_flex_factors: DesiredFlexFractionAndGrowOrShrinkFactor,
410    min_content_main_size_for_multiline_container: Au,
411    depends_on_block_constraints: bool,
412}
413
414impl ComputeInlineContentSizes for FlexContainer {
415    #[servo_tracing::instrument(name = "FlexContainer::compute_inline_content_sizes", skip_all)]
416    fn compute_inline_content_sizes(
417        &self,
418        layout_context: &LayoutContext,
419        constraint_space: &ConstraintSpace,
420    ) -> InlineContentSizesResult {
421        match self.config.flex_axis {
422            FlexAxis::Row => {
423                self.main_content_sizes(layout_context, &constraint_space.into(), || {
424                    unreachable!(
425                        "Unexpected FlexContext query during row flex intrinsic size calculation."
426                    )
427                })
428            },
429            FlexAxis::Column => self.cross_content_sizes(layout_context, &constraint_space.into()),
430        }
431    }
432}
433
434impl FlexContainer {
435    fn cross_content_sizes(
436        &self,
437        layout_context: &LayoutContext,
438        containing_block_for_children: &IndefiniteContainingBlock,
439    ) -> InlineContentSizesResult {
440        // <https://drafts.csswg.org/css-flexbox/#intrinsic-cross-sizes>
441        assert_eq!(
442            self.config.flex_axis,
443            FlexAxis::Column,
444            "The cross axis should be the inline one"
445        );
446        let mut sizes = ContentSizes::zero();
447        let mut depends_on_block_constraints = false;
448        for kid in self.children.iter() {
449            let kid = &*kid.borrow();
450            match kid {
451                FlexLevelBox::FlexItem(item) => {
452                    // TODO: For the max-content size we should distribute items into
453                    // columns, and sum the column sizes and gaps.
454                    // TODO: Use the proper automatic minimum size.
455                    let ifc = &item.independent_formatting_context;
456                    let result = ifc.outer_inline_content_sizes(
457                        layout_context,
458                        containing_block_for_children,
459                        &LogicalVec2::zero(),
460                        false, /* auto_block_size_stretches_to_containing_block */
461                        false, /* skippable_for_block_percentage_quirk */
462                    );
463                    sizes.max_assign(result.sizes);
464                    depends_on_block_constraints |= result.depends_on_block_constraints;
465                },
466                FlexLevelBox::OutOfFlowAbsolutelyPositionedBox(_) => {},
467            }
468        }
469        InlineContentSizesResult {
470            sizes,
471            depends_on_block_constraints,
472        }
473    }
474
475    fn main_content_sizes<'a>(
476        &self,
477        layout_context: &LayoutContext,
478        containing_block_for_children: &IndefiniteContainingBlock,
479        flex_context_getter: impl Fn() -> &'a FlexContext<'a>,
480    ) -> InlineContentSizesResult {
481        // - TODO: calculate intrinsic cross sizes when container is a column
482        // (and check for ‘writing-mode’?)
483        // - TODO: Collapsed flex items need to be skipped for intrinsic size calculation.
484
485        // <https://drafts.csswg.org/css-flexbox-1/#intrinsic-main-sizes>
486        // > It is calculated, considering only non-collapsed flex items, by:
487        // > 1. For each flex item, subtract its outer flex base size from its max-content
488        // > contribution size.
489        let mut chosen_max_flex_fraction = f32::NEG_INFINITY;
490        let mut chosen_min_flex_fraction = f32::NEG_INFINITY;
491        let mut sum_of_flex_grow_factors = 0.0;
492        let mut sum_of_flex_shrink_factors = 0.0;
493        let mut item_infos = vec![];
494
495        for kid in self.children.iter() {
496            let kid = &*kid.borrow();
497            match kid {
498                FlexLevelBox::FlexItem(item) => {
499                    sum_of_flex_grow_factors += item.style().get_position().flex_grow.0;
500                    sum_of_flex_shrink_factors += item.style().get_position().flex_shrink.0;
501
502                    let info = item.main_content_size_info(
503                        layout_context,
504                        containing_block_for_children,
505                        &self.config,
506                        &flex_context_getter,
507                    );
508
509                    // > 2. Place all flex items into lines of infinite length. Within
510                    // > each line, find the greatest (most positive) desired flex
511                    // > fraction among all the flex items. This is the line’s chosen flex
512                    // > fraction.
513                    chosen_max_flex_fraction =
514                        chosen_max_flex_fraction.max(info.max_flex_factors.desired_flex_fraction);
515                    chosen_min_flex_fraction =
516                        chosen_min_flex_fraction.max(info.min_flex_factors.desired_flex_fraction);
517
518                    item_infos.push(info)
519                },
520                FlexLevelBox::OutOfFlowAbsolutelyPositionedBox(_) => {},
521            }
522        }
523
524        let normalize_flex_fraction = |chosen_flex_fraction| {
525            if chosen_flex_fraction > 0.0 && sum_of_flex_grow_factors < 1.0 {
526                // > 3. If the chosen flex fraction is positive, and the sum of the line’s
527                // > flex grow factors is less than 1, > divide the chosen flex fraction by that
528                // > sum.
529                chosen_flex_fraction / sum_of_flex_grow_factors
530            } else if chosen_flex_fraction < 0.0 && sum_of_flex_shrink_factors < 1.0 {
531                // > If the chosen flex fraction is negative, and the sum of the line’s flex
532                // > shrink factors is less than 1, > multiply the chosen flex fraction by that
533                // > sum.
534                chosen_flex_fraction * sum_of_flex_shrink_factors
535            } else {
536                chosen_flex_fraction
537            }
538        };
539
540        let chosen_min_flex_fraction = normalize_flex_fraction(chosen_min_flex_fraction);
541        let chosen_max_flex_fraction = normalize_flex_fraction(chosen_max_flex_fraction);
542
543        let main_gap = match self.config.flex_axis {
544            FlexAxis::Row => self.style.get_column_gap(),
545            FlexAxis::Column => self.style.get_row_gap(),
546        };
547        let main_gap = match main_gap {
548            LengthPercentageOrNormal::LengthPercentage(length_percentage) => {
549                length_percentage.to_used_value(Au::zero())
550            },
551            LengthPercentageOrNormal::Normal => Au::zero(),
552        };
553        let extra_space_from_main_gap = main_gap * (item_infos.len() as i32 - 1);
554        let mut container_max_content_size = extra_space_from_main_gap;
555        let mut container_min_content_size = if self.config.flex_wrap == FlexWrap::NOWRAP {
556            extra_space_from_main_gap
557        } else {
558            Au::zero()
559        };
560        let mut container_depends_on_block_constraints = false;
561
562        for FlexItemBoxInlineContentSizesInfo {
563            outer_flex_base_size,
564            outer_min_main_size,
565            outer_max_main_size,
566            min_flex_factors,
567            max_flex_factors,
568            min_content_main_size_for_multiline_container,
569            depends_on_block_constraints,
570        } in item_infos.iter()
571        {
572            // > 4. Add each item’s flex base size to the product of its flex grow factor (scaled flex shrink
573            // > factor, if shrinking) and the chosen flex fraction, then clamp that result by the max main size
574            // > floored by the min main size.
575            // > 5. The flex container’s max-content size is the largest sum (among all the lines) of the
576            // > afore-calculated sizes of all items within a single line.
577            container_max_content_size += (*outer_flex_base_size +
578                Au::from_f32_px(
579                    max_flex_factors.flex_grow_or_shrink_factor * chosen_max_flex_fraction,
580                ))
581            .clamp_between_extremums(*outer_min_main_size, *outer_max_main_size);
582
583            // > The min-content main size of a single-line flex container is calculated
584            // > identically to the max-content main size, except that the flex items’
585            // > min-content contributions are used instead of their max-content contributions.
586            //
587            // > However, for a multi-line container, the min-content main size is simply the
588            // > largest min-content contribution of all the non-collapsed flex items in the
589            // > flex container. For this purpose, each item’s contribution is capped by the
590            // > item’s flex base size if the item is not growable, floored by the item’s flex
591            // > base size if the item is not shrinkable, and then further clamped by the item’s
592            // > min and max main sizes.
593            if self.config.flex_wrap == FlexWrap::NOWRAP {
594                container_min_content_size += (*outer_flex_base_size +
595                    Au::from_f32_px(
596                        min_flex_factors.flex_grow_or_shrink_factor * chosen_min_flex_fraction,
597                    ))
598                .clamp_between_extremums(*outer_min_main_size, *outer_max_main_size);
599            } else {
600                container_min_content_size
601                    .max_assign(*min_content_main_size_for_multiline_container);
602            }
603
604            container_depends_on_block_constraints |= depends_on_block_constraints;
605        }
606
607        InlineContentSizesResult {
608            sizes: ContentSizes {
609                min_content: container_min_content_size,
610                max_content: container_max_content_size,
611            },
612            depends_on_block_constraints: container_depends_on_block_constraints,
613        }
614    }
615
616    /// <https://drafts.csswg.org/css-flexbox/#layout-algorithm>
617    #[servo_tracing::instrument(
618        name = "FlexContainer::layout",
619        skip_all,
620        fields(self_address = self as *const _ as usize)
621    )]
622    pub(crate) fn layout(
623        &self,
624        layout_context: &LayoutContext,
625        positioning_context: &mut PositioningContext,
626        containing_block: &ContainingBlock,
627        lazy_block_size: &LazySize,
628    ) -> IndependentFormattingContextLayoutResult {
629        debug_assert!(!containing_block.has_quirky_block_size());
630        let mut flex_context = FlexContext {
631            config: self.config.clone(),
632            layout_context,
633            containing_block,
634            // https://drafts.csswg.org/css-flexbox/#definite-sizes
635            container_inner_size_constraint: self.config.flex_axis.vec2_to_flex_relative(
636                LogicalVec2 {
637                    inline: SizeConstraint::Definite(containing_block.inline_size()),
638                    block: containing_block.maybe_quirky_block_size(),
639                },
640            ),
641        };
642
643        // “Determine the main size of the flex container”
644        // https://drafts.csswg.org/css-flexbox/#algo-main-container
645        let container_main_size = match self.config.flex_axis {
646            FlexAxis::Row => containing_block.inline_size(),
647            FlexAxis::Column => lazy_block_size.resolve(|| {
648                let mut containing_block = IndefiniteContainingBlock::from(containing_block);
649                containing_block.size.maybe_quirky_block_size = None;
650                self.main_content_sizes(layout_context, &containing_block, || &flex_context)
651                    .sizes
652                    .max_content
653            }),
654        };
655
656        // Actual length may be less, but we guess that usually not by a lot
657        let mut flex_items = Vec::with_capacity(self.children.len());
658
659        // Absolutely-positioned children of the flex container may be interleaved
660        // with flex items. We need to preserve their relative order for correct painting order,
661        // which is the order of `Fragment`s in this function’s return value.
662        //
663        // Example:
664        // absolutely_positioned_items_with_original_order = [Some(item), Some(item), None, Some(item), None]
665        // flex_items                                      =                         [item,             item]
666        let absolutely_positioned_items_with_original_order = self
667            .children
668            .iter()
669            .map(|arcrefcell| {
670                let borrowed = arcrefcell.borrow();
671                match &*borrowed {
672                    FlexLevelBox::OutOfFlowAbsolutelyPositionedBox(absolutely_positioned) => {
673                        FlexContent::AbsolutelyPositionedBox(absolutely_positioned.clone())
674                    },
675                    FlexLevelBox::FlexItem(_) => {
676                        let item = AtomicRef::map(borrowed, |child| match child {
677                            FlexLevelBox::FlexItem(item) => item,
678                            _ => unreachable!(),
679                        });
680                        flex_items.push(item);
681                        FlexContent::FlexItemPlaceholder
682                    },
683                }
684            })
685            .collect::<Vec<_>>();
686
687        let row_gap = self.style.get_row_gap();
688        let column_gap = self.style.get_column_gap();
689        let (cross_gap, main_gap) = match flex_context.config.flex_axis {
690            FlexAxis::Row => (row_gap, column_gap),
691            FlexAxis::Column => (column_gap, row_gap),
692        };
693        let cross_gap = match cross_gap {
694            LengthPercentageOrNormal::LengthPercentage(length_percent) => length_percent
695                .maybe_to_used_value(
696                    flex_context
697                        .container_inner_size_constraint
698                        .cross
699                        .to_definite(),
700                )
701                .unwrap_or_default(),
702            LengthPercentageOrNormal::Normal => Au::zero(),
703        };
704        let main_gap = match main_gap {
705            LengthPercentageOrNormal::LengthPercentage(length_percent) => length_percent
706                .maybe_to_used_value(
707                    flex_context
708                        .container_inner_size_constraint
709                        .main
710                        .to_definite(),
711                )
712                .unwrap_or_default(),
713            LengthPercentageOrNormal::Normal => Au::zero(),
714        };
715
716        // “Resolve the flexible lengths of all the flex items to find their *used main size*.”
717        // https://drafts.csswg.org/css-flexbox/#algo-flex
718        let initial_line_layouts = do_initial_flex_line_layout(
719            &mut flex_context,
720            container_main_size,
721            &flex_items,
722            main_gap,
723        );
724
725        let line_count = initial_line_layouts.len();
726        let content_cross_size = initial_line_layouts
727            .iter()
728            .map(|layout| layout.line_size.cross)
729            .sum::<Au>() +
730            cross_gap * (line_count as i32 - 1);
731        let content_block_size = match self.config.flex_axis {
732            FlexAxis::Row => content_cross_size,
733            FlexAxis::Column => container_main_size,
734        };
735
736        // https://drafts.csswg.org/css-flexbox/#algo-cross-container
737        let container_cross_size = match self.config.flex_axis {
738            FlexAxis::Row => lazy_block_size.resolve(|| content_cross_size),
739            FlexAxis::Column => containing_block.inline_size(),
740        };
741
742        let container_size = FlexRelativeVec2 {
743            main: container_main_size,
744            cross: container_cross_size,
745        };
746
747        let mut remaining_free_cross_space = container_cross_size - content_cross_size;
748
749        // Implement fallback alignment.
750        //
751        // In addition to the spec at https://www.w3.org/TR/css-align-3/ this implementation follows
752        // the resolution of https://github.com/w3c/csswg-drafts/issues/10154
753        let num_lines = initial_line_layouts.len();
754        let resolved_align_content: AlignFlags = {
755            // Computed value from the style system
756            let align_content_style = flex_context.config.align_content.primary();
757            let mut is_safe = align_content_style.flags() == AlignFlags::SAFE;
758
759            // From https://drafts.csswg.org/css-align/#distribution-flex
760            // > `normal` behaves as `stretch`.
761            let mut resolved_align_content = match align_content_style.value() {
762                AlignFlags::NORMAL => AlignFlags::STRETCH,
763                align_content => align_content,
764            };
765
766            // From https://drafts.csswg.org/css-flexbox/#algo-line-align:
767            // > Some alignments can only be fulfilled in certain situations or are
768            // > limited in how much space they can consume; for example, space-between
769            // > can only operate when there is more than one alignment subject, and
770            // > baseline alignment, once fulfilled, might not be enough to absorb all
771            // > the excess space. In these cases a fallback alignment takes effect (as
772            // > defined below) to fully consume the excess space.
773            let fallback_is_needed = match resolved_align_content {
774                _ if remaining_free_cross_space <= Au::zero() => true,
775                AlignFlags::STRETCH => num_lines < 1,
776                AlignFlags::SPACE_BETWEEN | AlignFlags::SPACE_AROUND | AlignFlags::SPACE_EVENLY => {
777                    num_lines < 2
778                },
779                _ => false,
780            };
781
782            if fallback_is_needed {
783                (resolved_align_content, is_safe) = match resolved_align_content {
784                    AlignFlags::STRETCH => (AlignFlags::FLEX_START, false),
785                    AlignFlags::SPACE_BETWEEN => (AlignFlags::FLEX_START, true),
786                    AlignFlags::SPACE_AROUND => (AlignFlags::CENTER, true),
787                    AlignFlags::SPACE_EVENLY => (AlignFlags::CENTER, true),
788                    _ => (resolved_align_content, is_safe),
789                }
790            };
791
792            // 2. If free space is negative the "safe" alignment variants all fallback to Start alignment
793            if remaining_free_cross_space <= Au::zero() && is_safe {
794                resolved_align_content = AlignFlags::START;
795            }
796
797            resolved_align_content
798        };
799
800        // Implement "unsafe" alignment. "safe" alignment is handled by the fallback process above.
801        let flex_wrap_is_reversed = flex_context.config.flex_wrap_is_reversed;
802        let resolved_align_content = self
803            .config
804            .resolve_reversable_flex_alignment(resolved_align_content, flex_wrap_is_reversed);
805        let mut cross_start_position_cursor = match resolved_align_content {
806            AlignFlags::START if flex_wrap_is_reversed => remaining_free_cross_space,
807            AlignFlags::START => Au::zero(),
808            AlignFlags::END if flex_wrap_is_reversed => Au::zero(),
809            AlignFlags::END => remaining_free_cross_space,
810            AlignFlags::CENTER => remaining_free_cross_space / 2,
811            AlignFlags::STRETCH => Au::zero(),
812            AlignFlags::SPACE_BETWEEN => Au::zero(),
813            AlignFlags::SPACE_AROUND => remaining_free_cross_space / num_lines as i32 / 2,
814            AlignFlags::SPACE_EVENLY => remaining_free_cross_space / (num_lines as i32 + 1),
815
816            // TODO: Implement all alignments. Note: not all alignment values are valid for content distribution
817            _ => Au::zero(),
818        };
819
820        let inline_axis_is_main_axis = self.config.flex_axis == FlexAxis::Row;
821        let mut baseline_alignment_participating_baselines = Baselines::default();
822        let mut all_baselines = Baselines::default();
823        let mut flex_item_fragments = initial_line_layouts.into_iter().enumerate().flat_map(
824            |(index, initial_line_layout)| {
825                // We call `allocate_free_cross_space_for_flex_line` for each line to avoid having
826                // leftover space when the number of lines doesn't evenly divide the total free space,
827                // considering the precision of app units.
828                let (space_to_add_to_line, space_to_add_after_line) =
829                    allocate_free_cross_space_for_flex_line(
830                        resolved_align_content,
831                        remaining_free_cross_space,
832                        (num_lines - index) as i32,
833                    );
834                remaining_free_cross_space -= space_to_add_to_line + space_to_add_after_line;
835
836                let final_line_cross_size =
837                    initial_line_layout.line_size.cross + space_to_add_to_line;
838                let mut final_line_layout = initial_line_layout.finish_with_final_cross_size(
839                    &mut flex_context,
840                    main_gap,
841                    final_line_cross_size,
842                );
843
844                let line_cross_start_position = cross_start_position_cursor;
845                cross_start_position_cursor = line_cross_start_position +
846                    final_line_cross_size +
847                    space_to_add_after_line +
848                    cross_gap;
849
850                let flow_relative_line_position =
851                    match (self.config.flex_axis, flex_wrap_is_reversed) {
852                        (FlexAxis::Row, false) => LogicalVec2 {
853                            block: line_cross_start_position,
854                            inline: Au::zero(),
855                        },
856                        (FlexAxis::Row, true) => LogicalVec2 {
857                            block: container_cross_size -
858                                line_cross_start_position -
859                                final_line_layout.cross_size,
860                            inline: Au::zero(),
861                        },
862                        (FlexAxis::Column, false) => LogicalVec2 {
863                            block: Au::zero(),
864                            inline: line_cross_start_position,
865                        },
866                        (FlexAxis::Column, true) => LogicalVec2 {
867                            block: Au::zero(),
868                            inline: container_cross_size -
869                                line_cross_start_position -
870                                final_line_cross_size,
871                        },
872                    };
873
874                if inline_axis_is_main_axis {
875                    let line_shared_alignment_baseline = final_line_layout
876                        .shared_alignment_baseline
877                        .map(|baseline| baseline + flow_relative_line_position.block);
878                    if index == 0 {
879                        baseline_alignment_participating_baselines.first =
880                            line_shared_alignment_baseline;
881                    }
882                    if index == num_lines - 1 {
883                        baseline_alignment_participating_baselines.last =
884                            line_shared_alignment_baseline;
885                    }
886                }
887
888                let line_all_baselines = final_line_layout
889                    .all_baselines
890                    .offset(flow_relative_line_position.block);
891                if index == 0 {
892                    all_baselines.first = line_all_baselines.first;
893                }
894                if index == num_lines - 1 {
895                    all_baselines.last = line_all_baselines.last;
896                }
897
898                let physical_line_position =
899                    flow_relative_line_position.to_physical_size(self.style.writing_mode);
900                for (fragment, _) in &mut final_line_layout.item_fragments {
901                    fragment.base.translate_rect(physical_line_position);
902                }
903                final_line_layout.item_fragments
904            },
905        );
906
907        let flex_container_size = LogicalVec2 {
908            inline: containing_block.inline_size(),
909            block: content_block_size,
910        };
911        let fragments = absolutely_positioned_items_with_original_order
912            .into_iter()
913            .map(|child_as_abspos| match child_as_abspos {
914                FlexContent::AbsolutelyPositionedBox(absolutely_positioned_box) => self
915                    .create_absolutely_positioned_flex_child_fragment(
916                        absolutely_positioned_box,
917                        container_size,
918                        positioning_context,
919                    ),
920                FlexContent::FlexItemPlaceholder => {
921                    // The `flex_item_fragments` iterator yields one fragment
922                    // per flex item, in the original order.
923                    let (fragment, mut child_positioning_context) =
924                        flex_item_fragments.next().unwrap();
925                    child_positioning_context.adjust_static_position_of_hoisted_fragments(
926                        &LogicalRect::from_physical(
927                            fragment.base.rect(),
928                            self.style.writing_mode,
929                            flex_container_size,
930                        ),
931                        self.style.writing_mode,
932                        PositioningContextLength::zero(),
933                    );
934                    positioning_context.append(child_positioning_context);
935                    Fragment::Box(fragment)
936                },
937            })
938            .collect::<Vec<_>>();
939
940        // There should be no more flex items
941        assert!(flex_item_fragments.next().is_none());
942
943        let baselines = Baselines {
944            first: baseline_alignment_participating_baselines
945                .first
946                .or(all_baselines.first),
947            last: baseline_alignment_participating_baselines
948                .last
949                .or(all_baselines.last),
950        };
951
952        // TODO: `depends_on_block_constraints` could be false in some corner cases
953        // in order to improve performance.
954        // - In a single-line column container where all items have the grow and shrink
955        //   factors set to zero and the flex basis doesn't depend on block constraints,
956        //   and `justify-content` is `start` or equivalent.
957        //   This is unlikely because the flex shrink factor defaults to 1.
958        // - In a single-line row container where all items have `align-self: start` or
959        //   equivalent, and the cross size doesn't depend on block constraints.
960        //   This is unlikely because `align-self` stretches by default.
961        // - In a multi-line row container where `align-content` is `start` or equivalent,
962        //   and no item cross size depends on block constraints.
963        //   This is unlikely because `align-content` defaults to `stretch`.
964        let depends_on_block_constraints = true;
965
966        IndependentFormattingContextLayoutResult {
967            fragments: FragmentChildren::PhysicalDeprecated(fragments),
968            content_block_size,
969            content_inline_size_for_table: None,
970            baselines,
971            depends_on_block_constraints,
972            specific_layout_info: None,
973            collapsible_margins_in_children: CollapsedBlockMargins::zero(),
974        }
975    }
976
977    /// Create a absolutely positioned flex child fragment, using the rules the
978    /// specification dictates. This should take into account the alignment and
979    /// justification values of the container and the child to position it within a
980    /// "inset-modified containing block," which may be either the "static-position
981    /// rectangle" that's calculated below or a modified version of the absolute's
982    /// containing block adjusted by the insets specified in the item's style.
983    ///
984    /// From <https://drafts.csswg.org/css-flexbox/#abspos-items>:
985    /// > The cross-axis edges of the static-position rectangle of an
986    /// > absolutely-positioned child of a flex container are the content edges of the
987    /// > flex container The main-axis edges of the static-position rectangle are where
988    /// > the margin edges of the child would be positioned if it were the sole flex item
989    /// > in the flex container, assuming both the child and the flex container were
990    /// > fixed-size boxes of their used size. (For this purpose, auto margins are
991    /// > treated as zero.)
992    fn create_absolutely_positioned_flex_child_fragment(
993        &self,
994        absolutely_positioned_box: ArcRefCell<AbsolutelyPositionedBox>,
995        container_size: FlexRelativeVec2<Au>,
996        positioning_context: &mut PositioningContext,
997    ) -> Fragment {
998        let alignment = {
999            let fragment = absolutely_positioned_box.borrow();
1000            let make_flex_only_values_directional_for_absolutes =
1001                |value: AlignFlags, reversed: bool| match (value.value(), reversed) {
1002                    (AlignFlags::NORMAL | AlignFlags::AUTO | AlignFlags::STRETCH, true) => {
1003                        AlignFlags::END
1004                    },
1005                    (AlignFlags::STRETCH, false) => AlignFlags::START,
1006                    (AlignFlags::SPACE_BETWEEN, false) => AlignFlags::START,
1007                    (AlignFlags::SPACE_BETWEEN, true) => AlignFlags::END,
1008                    _ => value,
1009                };
1010            let cross = make_flex_only_values_directional_for_absolutes(
1011                self.config
1012                    .resolve_align_self_for_child(fragment.context.style()),
1013                self.config.flex_wrap_is_reversed,
1014            );
1015            let main = make_flex_only_values_directional_for_absolutes(
1016                self.config.resolve_justify_content_for_child(),
1017                self.config.flex_direction_is_reversed,
1018            );
1019
1020            FlexRelativeVec2 { cross, main }
1021        };
1022        let logical_alignment = self.config.flex_axis.vec2_to_flow_relative(alignment);
1023
1024        let static_position_rect = LogicalRect {
1025            start_corner: LogicalVec2::zero(),
1026            size: self.config.flex_axis.vec2_to_flow_relative(container_size),
1027        };
1028
1029        let hoisted_box = AbsolutelyPositionedBox::to_hoisted(
1030            absolutely_positioned_box,
1031            StaticPositionRect::new(static_position_rect, self.style.writing_mode),
1032            logical_alignment,
1033            self.config.writing_mode,
1034        );
1035        let hoisted_fragment = hoisted_box.fragment.clone();
1036        positioning_context.push(hoisted_box);
1037        Fragment::AbsoluteOrFixedPositionedPlaceholder(hoisted_fragment)
1038    }
1039
1040    #[inline]
1041    pub(crate) fn layout_style(&self) -> LayoutStyle<'_> {
1042        LayoutStyle::Default(&self.style)
1043    }
1044
1045    pub(crate) fn attached_to_tree(&self, layout_box: WeakLayoutBox) {
1046        for child in &self.children {
1047            child.borrow_mut().with_base_mut(|base| {
1048                base.parent_box.replace(layout_box.clone());
1049            });
1050        }
1051    }
1052}
1053
1054/// Align all flex lines per `align-content` according to
1055/// <https://drafts.csswg.org/css-flexbox/#algo-line-align>. Returns the space to add to
1056/// each line or the space to add after each line.
1057fn allocate_free_cross_space_for_flex_line(
1058    resolved_align_content: AlignFlags,
1059    remaining_free_cross_space: Au,
1060    remaining_line_count: i32,
1061) -> (Au, Au) {
1062    if remaining_free_cross_space.is_zero() {
1063        return (Au::zero(), Au::zero());
1064    }
1065
1066    match resolved_align_content {
1067        AlignFlags::START => (Au::zero(), Au::zero()),
1068        AlignFlags::FLEX_START => (Au::zero(), Au::zero()),
1069        AlignFlags::END => (Au::zero(), Au::zero()),
1070        AlignFlags::FLEX_END => (Au::zero(), Au::zero()),
1071        AlignFlags::CENTER => (Au::zero(), Au::zero()),
1072        AlignFlags::STRETCH => (
1073            remaining_free_cross_space / remaining_line_count,
1074            Au::zero(),
1075        ),
1076        AlignFlags::SPACE_BETWEEN => {
1077            if remaining_line_count > 1 {
1078                (
1079                    Au::zero(),
1080                    remaining_free_cross_space / (remaining_line_count - 1),
1081                )
1082            } else {
1083                (Au::zero(), Au::zero())
1084            }
1085        },
1086        AlignFlags::SPACE_AROUND => (
1087            Au::zero(),
1088            remaining_free_cross_space / remaining_line_count,
1089        ),
1090        AlignFlags::SPACE_EVENLY => (
1091            Au::zero(),
1092            remaining_free_cross_space / (remaining_line_count + 1),
1093        ),
1094
1095        // TODO: Implement all alignments. Note: not all alignment values are valid for content distribution
1096        _ => (Au::zero(), Au::zero()),
1097    }
1098}
1099
1100impl<'a> FlexItem<'a> {
1101    fn new(flex_context: &FlexContext, box_: &'a FlexItemBox) -> Self {
1102        let containing_block = IndefiniteContainingBlock::from(flex_context.containing_block);
1103        let content_box_sizes_and_pbm = box_
1104            .independent_formatting_context
1105            .layout_style()
1106            .content_box_sizes_and_padding_border_margin(&containing_block);
1107        box_.to_flex_item(
1108            flex_context.layout_context,
1109            &containing_block,
1110            &content_box_sizes_and_pbm,
1111            &flex_context.config,
1112            &|| flex_context,
1113        )
1114    }
1115}
1116
1117fn cross_axis_is_item_block_axis(
1118    container_is_horizontal: bool,
1119    item_is_horizontal: bool,
1120    flex_axis: FlexAxis,
1121) -> bool {
1122    let item_is_orthogonal = item_is_horizontal != container_is_horizontal;
1123    let container_is_row = flex_axis == FlexAxis::Row;
1124
1125    container_is_row ^ item_is_orthogonal
1126}
1127
1128/// Whether an item with a computed preferred cross size of `auto` will stretch
1129/// to fill the cross size of its flex line.
1130/// <https://drafts.csswg.org/css-flexbox/#stretched>
1131fn item_with_auto_cross_size_stretches_to_line_size(
1132    align_self: AlignItems,
1133    margin: &FlexRelativeSides<AuOrAuto>,
1134) -> bool {
1135    align_self.0.value() == AlignFlags::STRETCH &&
1136        !margin.cross_start.is_auto() &&
1137        !margin.cross_end.is_auto()
1138}
1139
1140/// "Collect flex items into flex lines"
1141/// <https://drafts.csswg.org/css-flexbox/#algo-line-break>
1142fn do_initial_flex_line_layout<'items>(
1143    flex_context: &mut FlexContext,
1144    container_main_size: Au,
1145    flex_item_boxes: &'items Vec<AtomicRef<'items, FlexItemBox>>,
1146    main_gap: Au,
1147) -> Vec<InitialFlexLineLayout<'items>> {
1148    let construct_line = |items: Vec<FlexItem<'items>>| {
1149        InitialFlexLineLayout::new(flex_context, items, container_main_size, main_gap)
1150    };
1151
1152    if flex_context.config.container_is_single_line {
1153        let items: Vec<_> = flex_item_boxes
1154            .iter()
1155            .map(|item_box| FlexItem::new(flex_context, item_box))
1156            .collect();
1157        return vec![construct_line(items)];
1158    }
1159
1160    let mut lines = Vec::new();
1161    let mut line_items = Vec::new();
1162    let mut line_size_so_far = Au::zero();
1163
1164    for item_box in flex_item_boxes {
1165        let item = FlexItem::new(flex_context, item_box);
1166        let item_size = item.hypothetical_main_size + item.pbm_auto_is_zero.main;
1167
1168        // Compute the size the line would be if we added this item.
1169        let mut line_size_would_be = line_size_so_far + item_size;
1170        if !line_items.is_empty() {
1171            line_size_would_be += main_gap;
1172        }
1173
1174        let item_fits = line_size_would_be <= container_main_size;
1175        if item_fits || line_items.is_empty() {
1176            line_items.push(item);
1177            line_size_so_far = line_size_would_be;
1178        } else {
1179            lines.push(std::mem::take(&mut line_items));
1180            line_items.push(item);
1181            line_size_so_far = item_size;
1182        }
1183    }
1184
1185    // We didn't reach the end of the last line, so add all remaining items there.
1186    lines.push(line_items);
1187
1188    let job_sizes = lines
1189        .iter()
1190        .map(|line| line.iter().map(FlexItem::subtree_size).sum());
1191    if flex_context
1192        .layout_context
1193        .should_parallelize_layout(job_sizes)
1194    {
1195        lines.par_drain(..).map(construct_line).collect()
1196    } else {
1197        lines.into_iter().map(construct_line).collect()
1198    }
1199}
1200
1201/// The result of splitting the flex items into lines using their intrinsic sizes and doing an
1202/// initial layout of each item. A final layout may still need to happen after this is produced
1203/// to handle stretching.
1204struct InitialFlexLineLayout<'a> {
1205    /// The items that are placed in this line.
1206    items: Vec<FlexLineItem<'a>>,
1207
1208    /// The initial size of this flex line, not taking into account `align-content: stretch`.
1209    line_size: FlexRelativeVec2<Au>,
1210
1211    /// The free space available to this line after the initial layout.
1212    free_space_in_main_axis: Au,
1213}
1214
1215impl InitialFlexLineLayout<'_> {
1216    fn new<'items>(
1217        flex_context: &FlexContext,
1218        items: Vec<FlexItem<'items>>,
1219        container_main_size: Au,
1220        main_gap: Au,
1221    ) -> InitialFlexLineLayout<'items> {
1222        let item_count = items.len();
1223        let (item_used_main_sizes, free_space_in_main_axis) = Self::resolve_flexible_lengths(
1224            &items,
1225            container_main_size - main_gap * (item_count as i32 - 1),
1226        );
1227
1228        // https://drafts.csswg.org/css-flexbox/#algo-cross-item
1229        //
1230        // When the cross size of the line is already known, the items whose used cross size
1231        // doesn't depend on their layout are laid out with it directly, instead of being laid
1232        // out once to find their hypothetical cross size and then again with their used size.
1233        let line_cross_size_before_layout = Self::cross_size_before_layout(flex_context);
1234        let layout_item = |(item, used_main_size): (FlexItem<'items>, Au)| {
1235            let used_cross_size = line_cross_size_before_layout.and_then(|line_cross_size| {
1236                item.used_cross_size_before_layout(flex_context, used_main_size, line_cross_size)
1237            });
1238            let layout_result = item.layout(used_main_size, flex_context, used_cross_size);
1239            FlexLineItem {
1240                item,
1241                layout_result,
1242                used_main_size,
1243            }
1244        };
1245        let items: Vec<_> = if flex_context
1246            .layout_context
1247            .should_parallelize_layout(items.iter().map(FlexItem::subtree_size))
1248        {
1249            items
1250                .into_par_iter()
1251                .zip(item_used_main_sizes.into_par_iter())
1252                .map(layout_item)
1253                .collect()
1254        } else {
1255            items
1256                .into_iter()
1257                .zip(item_used_main_sizes)
1258                .map(layout_item)
1259                .collect()
1260        };
1261
1262        // https://drafts.csswg.org/css-flexbox/#algo-cross-line
1263        let line_cross_size = Self::cross_size(&items, flex_context);
1264        let line_size = FlexRelativeVec2 {
1265            main: container_main_size,
1266            cross: line_cross_size,
1267        };
1268
1269        InitialFlexLineLayout {
1270            items,
1271            line_size,
1272            free_space_in_main_axis,
1273        }
1274    }
1275
1276    /// Return the *main size* of each item, and the line’s remainaing free space
1277    /// <https://drafts.csswg.org/css-flexbox/#resolve-flexible-lengths>
1278    fn resolve_flexible_lengths<'items>(
1279        items: &'items [FlexItem<'items>],
1280        container_main_size: Au,
1281    ) -> (Vec<Au>, Au) {
1282        struct FlexibleLengthResolutionItem<'items> {
1283            item: &'items FlexItem<'items>,
1284            frozen: Cell<bool>,
1285            target_main_size: Cell<Au>,
1286            flex_factor: f32,
1287            min_max_violation_kind: Cell<Ordering>,
1288        }
1289
1290        // > 1. Determine the used flex factor. Sum the outer hypothetical main sizes of all
1291        // > items on the line. If the sum is less than the flex container’s inner main
1292        // > size, use the flex grow factor for the rest of this algorithm; otherwise, use
1293        // > the flex shrink factor.
1294        let outer_hypothetical_main_sizes_sum: Au = items
1295            .iter()
1296            .map(|item| item.hypothetical_main_size + item.pbm_auto_is_zero.main)
1297            .sum();
1298        let grow = outer_hypothetical_main_sizes_sum < container_main_size;
1299
1300        let mut frozen_count = 0;
1301        let items: Vec<_> = items
1302            .iter()
1303            .map(|item| {
1304                // > 2. Each item in the flex line has a target main size, initially set to its
1305                // > flex base size. Each item is initially unfrozen and may become frozen.
1306                let target_main_size = Cell::new(item.flex_base_size);
1307
1308                // > 3. Size inflexible items. Freeze, setting its target main size to its hypothetical main size…
1309                // > - any item that has a flex factor of zero
1310                // > - if using the flex grow factor: any item that has a flex base size
1311                // >   greater than its hypothetical main size
1312                // > - if using the flex shrink factor: any item that has a flex base size
1313                // >   smaller than its hypothetical main size
1314                let flex_factor = if grow {
1315                    item.box_.style().get_position().flex_grow.0
1316                } else {
1317                    item.box_.style().get_position().flex_shrink.0
1318                };
1319
1320                let is_inflexible = flex_factor == 0. ||
1321                    if grow {
1322                        item.flex_base_size > item.hypothetical_main_size
1323                    } else {
1324                        item.flex_base_size < item.hypothetical_main_size
1325                    };
1326
1327                let frozen = Cell::new(false);
1328                if is_inflexible {
1329                    frozen_count += 1;
1330                    frozen.set(true);
1331                    target_main_size.set(item.hypothetical_main_size);
1332                }
1333
1334                FlexibleLengthResolutionItem {
1335                    item,
1336                    frozen,
1337                    target_main_size,
1338                    flex_factor,
1339                    // The actual violation will be computed later.
1340                    min_max_violation_kind: Cell::new(Ordering::Equal),
1341                }
1342            })
1343            .collect();
1344
1345        let unfrozen_items = || items.iter().filter(|item| !item.frozen.get());
1346        let main_sizes = |items: Vec<FlexibleLengthResolutionItem>| {
1347            items
1348                .into_iter()
1349                .map(|item| item.target_main_size.get())
1350                .collect()
1351        };
1352
1353        // https://drafts.csswg.org/css-flexbox/#initial-free-space
1354        // > 4. Calculate initial free space. Sum the outer sizes of all items on the line, and
1355        // > subtract this from the flex container’s inner main size. For frozen items, use
1356        // > their outer target main size; for other items, use their outer flex base size.
1357        let free_space = |all_items_frozen| {
1358            let items_size = items
1359                .iter()
1360                .map(|item| {
1361                    item.item.pbm_auto_is_zero.main +
1362                        if all_items_frozen || item.frozen.get() {
1363                            item.target_main_size.get()
1364                        } else {
1365                            item.item.flex_base_size
1366                        }
1367                })
1368                .sum();
1369            container_main_size - items_size
1370        };
1371
1372        let initial_free_space = free_space(false);
1373        loop {
1374            // https://drafts.csswg.org/css-flexbox/#remaining-free-space
1375            let mut remaining_free_space = free_space(false);
1376            // > 5. a. Check for flexible items. If all the flex items on the line are
1377            // >       frozen, free space has been distributed; exit this loop.
1378            if frozen_count >= items.len() {
1379                return (main_sizes(items), remaining_free_space);
1380            }
1381
1382            // > 5. b. Calculate the remaining free space as for initial free space, above. If the
1383            // > sum of the unfrozen flex items’ flex factors is less than one, multiply the
1384            // > initial free space by this sum. If the magnitude of this value is less than
1385            // > the magnitude of the remaining free space, use this as the remaining free
1386            // > space.
1387            let unfrozen_items_flex_factor_sum =
1388                unfrozen_items().map(|item| item.flex_factor).sum();
1389            if unfrozen_items_flex_factor_sum < 1. {
1390                let multiplied = initial_free_space.scale_by(unfrozen_items_flex_factor_sum);
1391                if multiplied.abs() < remaining_free_space.abs() {
1392                    remaining_free_space = multiplied
1393                }
1394            }
1395
1396            // > 5. c. If the remaining free space is non-zero, distribute it proportional
1397            // to the flex factors:
1398            //
1399            // FIXME: is it a problem if floating point precision errors accumulate
1400            // and we get not-quite-zero remaining free space when we should get zero here?
1401            if !remaining_free_space.is_zero() {
1402                // > If using the flex grow factor:
1403                // > For every unfrozen item on the line, find the ratio of the item’s flex grow factor to
1404                // > the sum of the flex grow factors of all unfrozen items on the line. Set the item’s
1405                // > target main size to its flex base size plus a fraction of the remaining free space
1406                // > proportional to the ratio.
1407                if grow {
1408                    for item in unfrozen_items() {
1409                        let ratio = item.flex_factor / unfrozen_items_flex_factor_sum;
1410                        item.target_main_size
1411                            .set(item.item.flex_base_size + remaining_free_space.scale_by(ratio));
1412                    }
1413                // > If using the flex shrink factor
1414                // > For every unfrozen item on the line, multiply its flex shrink factor by its inner flex
1415                // > base size, and note this as its scaled flex shrink factor. Find the ratio of the
1416                // > item’s scaled flex shrink factor to the sum of the scaled flex shrink factors of all
1417                // > unfrozen items on the line. Set the item’s target main size to its flex base size
1418                // > minus a fraction of the absolute value of the remaining free space proportional to the
1419                // > ratio. Note this may result in a negative inner main size; it will be corrected in the
1420                // > next step.
1421                } else {
1422                    // https://drafts.csswg.org/css-flexbox/#scaled-flex-shrink-factor
1423                    let scaled_shrink_factor = |item: &FlexibleLengthResolutionItem| {
1424                        item.item.flex_base_size.scale_by(item.flex_factor)
1425                    };
1426                    let scaled_shrink_factors_sum: Au =
1427                        unfrozen_items().map(scaled_shrink_factor).sum();
1428                    if scaled_shrink_factors_sum > Au::zero() {
1429                        for item in unfrozen_items() {
1430                            let ratio = scaled_shrink_factor(item).0 as f32 /
1431                                scaled_shrink_factors_sum.0 as f32;
1432                            item.target_main_size.set(
1433                                item.item.flex_base_size -
1434                                    remaining_free_space.abs().scale_by(ratio),
1435                            );
1436                        }
1437                    }
1438                }
1439            }
1440
1441            // > 5. d. Fix min/max violations. Clamp each non-frozen item’s target main size
1442            // > by its used min and max main sizes and floor its content-box size at zero.
1443            // > If the item’s target main size was made smaller by this, it’s a max
1444            // > violation. If the item’s target main size was made larger by this, it’s a
1445            // > min violation.
1446            let mut total_violation = Au::zero();
1447            for item in unfrozen_items() {
1448                let unclamped = item.target_main_size.get();
1449                let clamped = unclamped.clamp_between_extremums(
1450                    item.item.content_min_main_size,
1451                    item.item.content_max_main_size,
1452                );
1453                item.target_main_size.set(clamped);
1454                // We represent min violations with Ordering::Greater, and max violations
1455                // with Ordering::Less.
1456                item.min_max_violation_kind.set(clamped.cmp(&unclamped));
1457                total_violation += clamped - unclamped;
1458            }
1459
1460            // > 5. e. Freeze over-flexed items. The total violation is the sum of the
1461            // > adjustments from the previous step ∑(clamped size - unclamped size). If the
1462            // > total violation is:
1463            // > - Zero:  Freeze all items.
1464            // > - Positive: Freeze all the items with min violations.
1465            // > - Negative:  Freeze all the items with max violations.
1466            match total_violation.cmp(&Au::zero()) {
1467                Ordering::Equal => {
1468                    // “Freeze all items.”
1469                    // Return instead, as that’s what the next loop iteration would do.
1470                    let remaining_free_space = free_space(true);
1471                    return (main_sizes(items), remaining_free_space);
1472                },
1473                total_violation_kind => {
1474                    for item in unfrozen_items() {
1475                        if item.min_max_violation_kind.get() == total_violation_kind {
1476                            item.frozen.set(true);
1477                            frozen_count += 1;
1478                        }
1479                    }
1480                },
1481            }
1482        }
1483    }
1484
1485    /// The cross size of the flex line, if it's known before laying out its items.
1486    /// This is the case in single-line containers with a definite cross size.
1487    /// <https://drafts.csswg.org/css-flexbox/#algo-cross-line>
1488    fn cross_size_before_layout(flex_context: &FlexContext) -> Option<Au> {
1489        flex_context
1490            .container_inner_size_constraint
1491            .cross
1492            .to_definite()
1493            .filter(|_| flex_context.config.container_is_single_line)
1494    }
1495
1496    /// <https://drafts.csswg.org/css-flexbox/#algo-cross-line>
1497    fn cross_size<'items>(items: &'items [FlexLineItem<'items>], flex_context: &FlexContext) -> Au {
1498        if let Some(size) = Self::cross_size_before_layout(flex_context) {
1499            return size;
1500        }
1501
1502        let mut max_ascent = Au::zero();
1503        let mut max_descent = Au::zero();
1504        let mut max_outer_hypothetical_cross_size = Au::zero();
1505        for item in items.iter() {
1506            // TODO: check inline-axis is parallel to main axis, check no auto cross margins
1507            if matches!(
1508                item.item.align_self.0.value(),
1509                AlignFlags::BASELINE | AlignFlags::LAST_BASELINE
1510            ) {
1511                let baseline = item.get_or_synthesize_baseline_with_cross_size(
1512                    item.layout_result.hypothetical_cross_size,
1513                    &flex_context.config,
1514                );
1515                let hypothetical_margin_box_cross_size =
1516                    item.layout_result.hypothetical_cross_size + item.item.pbm_auto_is_zero.cross;
1517                max_ascent = max_ascent.max(baseline);
1518                max_descent = max_descent.max(hypothetical_margin_box_cross_size - baseline);
1519            } else {
1520                max_outer_hypothetical_cross_size = max_outer_hypothetical_cross_size.max(
1521                    item.layout_result.hypothetical_cross_size + item.item.pbm_auto_is_zero.cross,
1522                );
1523            }
1524        }
1525
1526        // https://drafts.csswg.org/css-flexbox/#baseline-participation
1527        let largest = max_outer_hypothetical_cross_size.max(max_ascent + max_descent);
1528        match flex_context.container_inner_size_constraint.cross {
1529            SizeConstraint::MinMax(min, max) if flex_context.config.container_is_single_line => {
1530                largest.clamp_between_extremums(min, max)
1531            },
1532            _ => largest,
1533        }
1534    }
1535
1536    fn finish_with_final_cross_size(
1537        mut self,
1538        flex_context: &mut FlexContext,
1539        main_gap: Au,
1540        final_line_cross_size: Au,
1541    ) -> FinalFlexLineLayout {
1542        // FIXME: Collapse `visibility: collapse` items
1543        // This involves “restart layout from the beginning” with a modified second round,
1544        // which will make structuring the code… interesting.
1545        // https://drafts.csswg.org/css-flexbox/#algo-visibility
1546
1547        // Distribute any remaining main free space to auto margins according to
1548        // https://drafts.csswg.org/css-flexbox/#algo-main-align.
1549        let auto_margins_count = self
1550            .items
1551            .iter()
1552            .map(|item| {
1553                item.item.margin.main_start.is_auto() as u32 +
1554                    item.item.margin.main_end.is_auto() as u32
1555            })
1556            .sum::<u32>();
1557        let (space_distributed_to_auto_main_margins, free_space_in_main_axis) =
1558            if self.free_space_in_main_axis > Au::zero() && auto_margins_count > 0 {
1559                (
1560                    self.free_space_in_main_axis / auto_margins_count as i32,
1561                    Au::zero(),
1562                )
1563            } else {
1564                (Au::zero(), self.free_space_in_main_axis)
1565            };
1566
1567        // Determine the used cross size of each flex item
1568        // https://drafts.csswg.org/css-flexbox/#algo-stretch
1569        let item_count = self.items.len();
1570        let mut shared_alignment_baseline = None;
1571        let mut item_used_cross_sizes = Vec::with_capacity(item_count);
1572        let mut item_margins = Vec::with_capacity(item_count);
1573        for item in self.items.iter_mut() {
1574            let cross_axis = match flex_context.config.flex_axis {
1575                FlexAxis::Row => LogicalAxis::Block,
1576                FlexAxis::Column => LogicalAxis::Inline,
1577            };
1578            let layout = &mut item.layout_result;
1579            let get_content_size = || match cross_axis {
1580                LogicalAxis::Block => layout.content_block_size.into(),
1581                LogicalAxis::Inline => item
1582                    .item
1583                    .inline_content_sizes(flex_context, item.used_main_size),
1584            };
1585            let used_cross_size =
1586                item.item
1587                    .used_cross_size(cross_axis, final_line_cross_size, get_content_size);
1588            item_used_cross_sizes.push(used_cross_size);
1589
1590            // “If the flex item has `align-self: stretch`, redo layout for its contents,
1591            // treating this used size as its definite cross size so that percentage-sized
1592            // children can be resolved.”
1593            // However, as resolved in https://github.com/w3c/csswg-drafts/issues/11784,
1594            // we do that when the cross size is `stretch`. We also need to do it if the
1595            // inline size changes, which may happen with a `fit-content` cross size.
1596            let needs_new_layout = match cross_axis {
1597                LogicalAxis::Block => {
1598                    (match item.item.content_cross_sizes.preferred {
1599                        Size::Initial => item.item.automatic_cross_size == Size::Stretch,
1600                        Size::Stretch => true,
1601                        _ => false,
1602                    }) && Some(used_cross_size) != layout.containing_block_size.block_size() &&
1603                        layout.depends_on_block_constraints
1604                },
1605                LogicalAxis::Inline => used_cross_size != layout.containing_block_size.inline_size,
1606            };
1607            if needs_new_layout {
1608                #[cfg(feature = "tracing")]
1609                tracing::warn!(
1610                    name: "Flex item stretch cache miss",
1611                    cached_inline = ?layout.containing_block_size.inline_size,
1612                    cached_block = ?layout.containing_block_size.block_size(),
1613                    required_cross_size = ?used_cross_size,
1614                    cross_axis = ?cross_axis,
1615                    depends_on_block_constraints = layout.depends_on_block_constraints,
1616                );
1617                *layout =
1618                    item.item
1619                        .layout(item.used_main_size, flex_context, Some(used_cross_size));
1620            }
1621
1622            let baseline = item
1623                .get_or_synthesize_baseline_with_cross_size(used_cross_size, &flex_context.config);
1624            if matches!(
1625                item.item.align_self.0.value(),
1626                AlignFlags::BASELINE | AlignFlags::LAST_BASELINE
1627            ) {
1628                shared_alignment_baseline =
1629                    Some(shared_alignment_baseline.unwrap_or(baseline).max(baseline));
1630            }
1631            item.layout_result
1632                .flex_alignment_baseline_relative_to_margin_box = Some(baseline);
1633
1634            item_margins.push(item.item.resolve_auto_margins(
1635                flex_context,
1636                final_line_cross_size,
1637                used_cross_size,
1638                space_distributed_to_auto_main_margins,
1639            ));
1640        }
1641
1642        // Align the items along the main-axis per justify-content.
1643        // Implement fallback alignment.
1644        //
1645        // In addition to the spec at https://www.w3.org/TR/css-align-3/ this implementation follows
1646        // the resolution of https://github.com/w3c/csswg-drafts/issues/10154
1647        let resolved_justify_content: AlignFlags = {
1648            let justify_content_style = flex_context.config.justify_content.primary();
1649
1650            // Inital values from the style system
1651            let inline_axis_is_main_axis = flex_context.config.flex_axis == FlexAxis::Row;
1652            let line_left_is_inline_start =
1653                flex_context.config.writing_mode.line_left_is_inline_start();
1654            let mut resolved_justify_content = match justify_content_style.value() {
1655                // On the inline axis `left`/`right` are line-left/line-right.
1656                // https://drafts.csswg.org/css-align/#valdef-justify-content-left
1657                AlignFlags::LEFT if inline_axis_is_main_axis => {
1658                    if line_left_is_inline_start {
1659                        AlignFlags::FLEX_START
1660                    } else {
1661                        AlignFlags::FLEX_END
1662                    }
1663                },
1664                // https://drafts.csswg.org/css-align/#valdef-justify-content-right
1665                AlignFlags::RIGHT if inline_axis_is_main_axis => {
1666                    if line_left_is_inline_start {
1667                        AlignFlags::FLEX_END
1668                    } else {
1669                        AlignFlags::FLEX_START
1670                    }
1671                },
1672                // On the block axis these keywords are not parallel with the
1673                // left-right axis, so they behave as `start`.
1674                AlignFlags::LEFT | AlignFlags::RIGHT => AlignFlags::FLEX_START,
1675                justify_content => justify_content,
1676            };
1677            let mut is_safe = justify_content_style.flags() == AlignFlags::SAFE;
1678
1679            // Fallback occurs in two cases:
1680
1681            // 1. If there is only a single item being aligned and alignment is a distributed alignment keyword
1682            //    https://www.w3.org/TR/css-align-3/#distribution-values
1683            if item_count <= 1 || free_space_in_main_axis <= Au::zero() {
1684                (resolved_justify_content, is_safe) = match resolved_justify_content {
1685                    AlignFlags::STRETCH => (AlignFlags::FLEX_START, true),
1686                    AlignFlags::SPACE_BETWEEN => (AlignFlags::FLEX_START, true),
1687                    AlignFlags::SPACE_AROUND => (AlignFlags::CENTER, true),
1688                    AlignFlags::SPACE_EVENLY => (AlignFlags::CENTER, true),
1689                    _ => (resolved_justify_content, is_safe),
1690                }
1691            };
1692
1693            // 2. If free space is negative the "safe" alignment variants all fallback to Start alignment
1694            if free_space_in_main_axis <= Au::zero() && is_safe {
1695                resolved_justify_content = AlignFlags::START;
1696            }
1697
1698            resolved_justify_content
1699        };
1700
1701        // Implement "unsafe" alignment. "safe" alignment is handled by the fallback process above.
1702        let main_start_position = match resolved_justify_content {
1703            AlignFlags::START => Au::zero(),
1704            AlignFlags::FLEX_START => {
1705                if flex_context.config.flex_direction_is_reversed {
1706                    free_space_in_main_axis
1707                } else {
1708                    Au::zero()
1709                }
1710            },
1711            AlignFlags::END => free_space_in_main_axis,
1712            AlignFlags::FLEX_END => {
1713                if flex_context.config.flex_direction_is_reversed {
1714                    Au::zero()
1715                } else {
1716                    free_space_in_main_axis
1717                }
1718            },
1719            AlignFlags::CENTER => free_space_in_main_axis / 2,
1720            AlignFlags::STRETCH => Au::zero(),
1721            AlignFlags::SPACE_BETWEEN => Au::zero(),
1722            AlignFlags::SPACE_AROUND => (free_space_in_main_axis / item_count as i32) / 2,
1723            AlignFlags::SPACE_EVENLY => free_space_in_main_axis / (item_count + 1) as i32,
1724
1725            // TODO: Implement all alignments. Note: not all alignment values are valid for content distribution
1726            _ => Au::zero(),
1727        };
1728
1729        let item_main_interval = match resolved_justify_content {
1730            AlignFlags::START => Au::zero(),
1731            AlignFlags::FLEX_START => Au::zero(),
1732            AlignFlags::END => Au::zero(),
1733            AlignFlags::FLEX_END => Au::zero(),
1734            AlignFlags::CENTER => Au::zero(),
1735            AlignFlags::STRETCH => Au::zero(),
1736            AlignFlags::SPACE_BETWEEN => free_space_in_main_axis / (item_count - 1) as i32,
1737            AlignFlags::SPACE_AROUND => free_space_in_main_axis / item_count as i32,
1738            AlignFlags::SPACE_EVENLY => free_space_in_main_axis / (item_count + 1) as i32,
1739
1740            // TODO: Implement all alignments. Note: not all alignment values are valid for content distribution
1741            _ => Au::zero(),
1742        };
1743        let item_main_interval = item_main_interval + main_gap;
1744
1745        let mut all_baselines = Baselines::default();
1746        let mut main_position_cursor = main_start_position;
1747
1748        let items = std::mem::take(&mut self.items);
1749        let item_fragments = izip!(items, item_margins, item_used_cross_sizes.iter())
1750            .map(|(item, item_margin, item_used_cross_size)| {
1751                let item_used_size = FlexRelativeVec2 {
1752                    main: item.used_main_size,
1753                    cross: *item_used_cross_size,
1754                };
1755                item.collect_fragment(
1756                    &self,
1757                    item_used_size,
1758                    item_margin,
1759                    item_main_interval,
1760                    final_line_cross_size,
1761                    &shared_alignment_baseline,
1762                    flex_context,
1763                    &mut all_baselines,
1764                    &mut main_position_cursor,
1765                )
1766            })
1767            .collect();
1768
1769        FinalFlexLineLayout {
1770            cross_size: final_line_cross_size,
1771            item_fragments,
1772            all_baselines,
1773            shared_alignment_baseline,
1774        }
1775    }
1776}
1777
1778impl FlexItem<'_> {
1779    /// Return the hypothetical cross size together with laid out contents of the fragment.
1780    /// From <https://drafts.csswg.org/css-flexbox/#algo-cross-item>:
1781    /// > performing layout as if it were an in-flow block-level box with the used main
1782    /// > size and the given available space, treating `auto` as `fit-content`.
1783    #[servo_tracing::instrument(
1784        name = "FlexItem::layout",
1785        skip_all,
1786        fields(
1787            self_address = self as *const _ as usize,
1788            box_address = self.box_ as *const _ as usize,
1789        )
1790    )]
1791
1792    fn layout(
1793        &self,
1794        used_main_size: Au,
1795        flex_context: &FlexContext,
1796        used_cross_size_override: Option<Au>,
1797    ) -> FlexItemLayoutResult {
1798        let containing_block = flex_context.containing_block;
1799        let independent_formatting_context = &self.box_.independent_formatting_context;
1800        let is_table = independent_formatting_context.is_table();
1801        let mut positioning_context = PositioningContext::default();
1802        let item_writing_mode = independent_formatting_context.style().writing_mode;
1803        let item_is_horizontal = item_writing_mode.is_horizontal();
1804        let flex_axis = flex_context.config.flex_axis;
1805        let cross_axis_is_item_block_axis = cross_axis_is_item_block_axis(
1806            containing_block.style.writing_mode.is_horizontal(),
1807            item_is_horizontal,
1808            flex_axis,
1809        );
1810
1811        let (inline_size, block_size) = if cross_axis_is_item_block_axis {
1812            let cross_size = match used_cross_size_override {
1813                Some(s) => SizeConstraint::Definite(s),
1814                None => {
1815                    let inline_stretch_size =
1816                        containing_block.inline_stretch_size(self.pbm_auto_is_zero.main);
1817                    let block_stretch_size =
1818                        containing_block.block_stretch_size(self.pbm_auto_is_zero.cross);
1819                    let tentative_block_content_size = independent_formatting_context
1820                        .tentative_block_content_size(
1821                            self.preferred_aspect_ratio,
1822                            inline_stretch_size,
1823                        );
1824                    if let Some(block_content_size) = tentative_block_content_size {
1825                        SizeConstraint::Definite(self.content_cross_sizes.resolve(
1826                            LogicalAxis::Block,
1827                            Size::FitContent,
1828                            Au::zero,
1829                            block_stretch_size,
1830                            || block_content_size,
1831                            is_table,
1832                        ))
1833                    } else {
1834                        self.content_cross_sizes.resolve_extrinsic(
1835                            Size::FitContent,
1836                            Au::zero(),
1837                            block_stretch_size,
1838                        )
1839                    }
1840                },
1841            };
1842            (used_main_size, cross_size)
1843        } else {
1844            let cross_size = used_cross_size_override.unwrap_or_else(|| {
1845                let stretch_size =
1846                    containing_block.inline_stretch_size(self.pbm_auto_is_zero.cross);
1847                self.content_cross_sizes.resolve(
1848                    LogicalAxis::Inline,
1849                    Size::FitContent,
1850                    Au::zero,
1851                    stretch_size,
1852                    || self.inline_content_sizes(flex_context, used_main_size),
1853                    is_table,
1854                )
1855            });
1856            // The main size of a flex item is considered to be definite if its flex basis is definite
1857            // or the flex container has a definite main size.
1858            // <https://drafts.csswg.org/css-flexbox-1/#definite-sizes>
1859            //
1860            // Each grid area’s width and height are considered definite
1861            // when laying out the grid items into their respective containing blocks,
1862            // after the grid is sized.
1863            // <https://drafts.csswg.org/css-grid-1/#layout-algorithm>
1864            let is_grid = self.box_.independent_formatting_context.is_grid();
1865            let main_size = if is_grid ||
1866                self.flex_base_size_is_definite ||
1867                flex_context
1868                    .container_inner_size_constraint
1869                    .main
1870                    .is_definite()
1871            {
1872                SizeConstraint::Definite(used_main_size)
1873            } else {
1874                SizeConstraint::MinMax(self.content_min_main_size, self.content_max_main_size)
1875            };
1876            (cross_size, main_size)
1877        };
1878
1879        let item_style = independent_formatting_context.style();
1880        let item_as_containing_block = ContainingBlock {
1881            size: ContainingBlockSize::new(inline_size, block_size),
1882            style: item_style,
1883        };
1884
1885        let lazy_block_size = if !cross_axis_is_item_block_axis {
1886            used_main_size.into()
1887        } else if let Some(cross_size) = used_cross_size_override {
1888            cross_size.into()
1889        } else {
1890            let stretch_size = containing_block.block_stretch_size(self.pbm_auto_is_zero.cross);
1891            LazySize::new(
1892                &self.content_cross_sizes,
1893                LogicalAxis::Block,
1894                Size::FitContent,
1895                Au::zero,
1896                stretch_size,
1897                is_table,
1898            )
1899        };
1900
1901        let layout = independent_formatting_context.layout(
1902            flex_context.layout_context,
1903            &mut positioning_context,
1904            &item_as_containing_block,
1905            containing_block,
1906            self.preferred_aspect_ratio,
1907            &lazy_block_size,
1908        );
1909        let IndependentFormattingContextLayoutResult {
1910            fragments,
1911            content_block_size,
1912            baselines: content_box_baselines,
1913            depends_on_block_constraints,
1914            specific_layout_info,
1915            ..
1916        } = layout;
1917
1918        let hypothetical_cross_size = if cross_axis_is_item_block_axis {
1919            lazy_block_size.resolve(|| content_block_size)
1920        } else {
1921            inline_size
1922        };
1923
1924        let item_inline_axis_is_horizontal = item_style.writing_mode.is_horizontal();
1925        let container_inline_axis_is_horizontal = flex_context.config.writing_mode.is_horizontal();
1926        let container_main_axis_is_horizontal = match flex_axis {
1927            FlexAxis::Row => container_inline_axis_is_horizontal,
1928            FlexAxis::Column => !container_inline_axis_is_horizontal,
1929        };
1930        let item_inline_axis_parallel_to_container_inline_axis =
1931            item_inline_axis_is_horizontal == container_inline_axis_is_horizontal;
1932        let item_inline_axis_parallel_to_container_main_axis =
1933            item_inline_axis_is_horizontal == container_main_axis_is_horizontal;
1934
1935        let content_baselines_relative_to_margin_box = content_box_baselines.offset(
1936            self.margin.cross_start.auto_is(Au::zero) +
1937                self.padding.cross_start +
1938                self.border.cross_start,
1939        );
1940
1941        let content_baselines_for_parent_relative_to_margin_box =
1942            if item_inline_axis_parallel_to_container_inline_axis {
1943                content_baselines_relative_to_margin_box
1944            } else {
1945                Baselines::default()
1946            };
1947
1948        let flex_alignment_baseline_relative_to_margin_box =
1949            if item_inline_axis_parallel_to_container_main_axis {
1950                match self.align_self.0.value() {
1951                    // ‘baseline’ computes to ‘first baseline’.
1952                    AlignFlags::BASELINE => content_baselines_relative_to_margin_box.first,
1953                    AlignFlags::LAST_BASELINE => content_baselines_relative_to_margin_box.last,
1954                    _ => None,
1955                }
1956            } else {
1957                None
1958            };
1959
1960        FlexItemLayoutResult {
1961            hypothetical_cross_size,
1962            fragments,
1963            positioning_context,
1964            content_baselines_for_parent_relative_to_margin_box,
1965            flex_alignment_baseline_relative_to_margin_box,
1966            content_block_size,
1967            containing_block_size: item_as_containing_block.size,
1968            depends_on_block_constraints,
1969            specific_layout_info,
1970        }
1971    }
1972
1973    /// Returns the distance from the baseline relative to the cross-start edge of the margin box
1974    /// along the cross axis.
1975    fn synthesized_baseline_relative_to_margin_box(
1976        &self,
1977        content_size: Au,
1978        config: &FlexContainerConfig,
1979    ) -> Au {
1980        let own_writing_mode = self.box_.style().writing_mode;
1981        // https://drafts.csswg.org/css-flexbox/#valdef-align-items-baseline
1982        // > If the item does not have a baseline in the necessary axis,
1983        // > then one is synthesized from the flex item’s border box.
1984        // Note: This is the case when this function is called.
1985
1986        // https://drafts.csswg.org/css-align-3/#synthesize-baseline
1987        // > To synthesize baselines from a rectangle (or two parallel lines),
1988        // > synthesize the alphabetic baseline from the line-under.
1989        let distance_from_cross_start_to_line_under = |writing_mode: WritingMode| -> Au {
1990            // The different positions for line-under depending on the writing mode are defined
1991            // in https://drafts.csswg.org/css-writing-modes-4/#logical-to-physical.
1992            // FIXME: This needs to handle "writing-mode: sideways-lr" once that is
1993            // enabled in stylo.
1994            let line_under_edge_is_on_same_side_as_cross_start = (writing_mode.is_horizontal() &&
1995                config.flex_wrap_is_reversed) ||
1996                (writing_mode.is_vertical_lr() != config.flex_wrap_is_reversed);
1997            if line_under_edge_is_on_same_side_as_cross_start {
1998                // line-under edge is the bottom border edge and cross axis goes bottom->top
1999                // OR
2000                // line-under edge is the left border edge and cross axis goes left->right
2001                // OR
2002                // line-under edge is the right border edge and cross axis goes right->left
2003                self.margin.cross_start.auto_is(Au::zero)
2004            } else {
2005                // line-under edge is the bottom border edge and cross axis goes top->bottom
2006                // OR
2007                // line-under edge is the right border edge and cross axis goes left->right
2008                // OR
2009                // line-under edge is the left border edge and cross axis goes right->left
2010                content_size +
2011                    self.margin.cross_start.auto_is(Au::zero) +
2012                    self.padding.cross_sum() +
2013                    self.border.cross_sum()
2014            }
2015        };
2016
2017        // > In general, the writing mode of the box, shape, or other object being aligned is used
2018        // > to determine the line-under and line-over edges for synthesis.
2019        // > However, when that writing mode’s block flow direction is parallel to the axis of the
2020        // > alignment context, an axis-compatible writing mode must be assumed:
2021        // > * If the box establishing the alignment context has a block flow direction that is orthogonal
2022        // >   to the axis of the alignment context, use its writing mode.
2023        // > * Otherwise:
2024        // >   * If the box’s own writing mode is vertical, assume horizontal-tb.
2025        // >   * If the box’s own writing mode is horizontal, assume vertical-lr if direction is ltr
2026        // >     and vertical-rl if direction is rtl.
2027        let block_flow_direction_is_orthogonal_to_main_axis = |writing_mode: WritingMode| {
2028            writing_mode.is_vertical() != (config.flex_axis == FlexAxis::Row)
2029        };
2030        if block_flow_direction_is_orthogonal_to_main_axis(own_writing_mode) {
2031            distance_from_cross_start_to_line_under(own_writing_mode)
2032        } else if block_flow_direction_is_orthogonal_to_main_axis(config.writing_mode) {
2033            distance_from_cross_start_to_line_under(config.writing_mode)
2034        } else if own_writing_mode.is_vertical() {
2035            distance_from_cross_start_to_line_under(WritingMode::WRITING_MODE_HORIZONTAL_TB)
2036        } else {
2037            let used_writing_mode = match own_writing_mode.is_bidi_ltr() {
2038                true => WritingMode::WRITING_MODE_VERTICAL_LR,
2039                false => WritingMode::WRITING_MODE_VERTICAL_RL,
2040            };
2041
2042            distance_from_cross_start_to_line_under(used_writing_mode)
2043        }
2044    }
2045
2046    fn subtree_size(&self) -> usize {
2047        self.box_.independent_formatting_context.subtree_size()
2048    }
2049
2050    /// Return the cross-start, cross-end, main-start, and main-end margins, with `auto` values resolved.
2051    /// See:
2052    ///
2053    /// - <https://drafts.csswg.org/css-flexbox/#algo-cross-margins>
2054    /// - <https://drafts.csswg.org/css-flexbox/#algo-main-align>
2055    fn resolve_auto_margins(
2056        &self,
2057        flex_context: &FlexContext,
2058        line_cross_size: Au,
2059        item_cross_content_size: Au,
2060        space_distributed_to_auto_main_margins: Au,
2061    ) -> FlexRelativeSides<Au> {
2062        let main_start = self
2063            .margin
2064            .main_start
2065            .auto_is(|| space_distributed_to_auto_main_margins);
2066        let main_end = self
2067            .margin
2068            .main_end
2069            .auto_is(|| space_distributed_to_auto_main_margins);
2070
2071        let auto_count = match (self.margin.cross_start, self.margin.cross_end) {
2072            (AuOrAuto::LengthPercentage(cross_start), AuOrAuto::LengthPercentage(cross_end)) => {
2073                return FlexRelativeSides {
2074                    cross_start,
2075                    cross_end,
2076                    main_start,
2077                    main_end,
2078                };
2079            },
2080            (AuOrAuto::Auto, AuOrAuto::Auto) => 2,
2081            _ => 1,
2082        };
2083        let outer_cross_size = self.pbm_auto_is_zero.cross + item_cross_content_size;
2084        let available = line_cross_size - outer_cross_size;
2085        let cross_start;
2086        let cross_end;
2087        if available > Au::zero() {
2088            let each_auto_margin = available / auto_count;
2089            cross_start = self.margin.cross_start.auto_is(|| each_auto_margin);
2090            cross_end = self.margin.cross_end.auto_is(|| each_auto_margin);
2091        } else {
2092            // “the block-start or inline-start margin (whichever is in the cross axis)”
2093            // This margin is the cross-end on iff `flex-wrap` is `wrap-reverse`,
2094            // cross-start otherwise.
2095            // We know this because:
2096            // https://drafts.csswg.org/css-flexbox/#flex-wrap-property
2097            // “For the values that are not wrap-reverse,
2098            //  the cross-start direction is equivalent to
2099            //  either the inline-start or block-start direction of the current writing mode
2100            //  (whichever is in the cross axis)
2101            //  and the cross-end direction is the opposite direction of cross-start.
2102            //  When flex-wrap is wrap-reverse,
2103            //  the cross-start and cross-end directions are swapped.”
2104            let flex_wrap = flex_context.containing_block.style.get_position().flex_wrap;
2105            let flex_wrap_reverse = match flex_wrap {
2106                FlexWrap::NOWRAP | FlexWrap::WRAP => false,
2107                FlexWrap::WRAP_REVERSE => true,
2108                _ => unreachable!("FlexWrap::BALANCE should be disabled"),
2109            };
2110            // “if the block-start or inline-start margin (whichever is in the cross axis) is auto,
2111            //  set it to zero. Set the opposite margin so that the outer cross size of the item
2112            //  equals the cross size of its flex line.”
2113            if flex_wrap_reverse {
2114                cross_start = self.margin.cross_start.auto_is(|| available);
2115                cross_end = self.margin.cross_end.auto_is(Au::zero);
2116            } else {
2117                cross_start = self.margin.cross_start.auto_is(Au::zero);
2118                cross_end = self.margin.cross_end.auto_is(|| available);
2119            }
2120        }
2121
2122        FlexRelativeSides {
2123            cross_start,
2124            cross_end,
2125            main_start,
2126            main_end,
2127        }
2128    }
2129
2130    /// Return the coordinate of the cross-start side of the content area
2131    fn align_along_cross_axis(
2132        &self,
2133        margin: &FlexRelativeSides<Au>,
2134        used_cross_size: &Au,
2135        line_cross_size: Au,
2136        propagated_baseline: Au,
2137        max_propagated_baseline: Au,
2138        wrap_reverse: bool,
2139    ) -> Au {
2140        let ending_alignment = line_cross_size - *used_cross_size - self.pbm_auto_is_zero.cross;
2141        let outer_cross_start =
2142            if self.margin.cross_start.is_auto() || self.margin.cross_end.is_auto() {
2143                Au::zero()
2144            } else {
2145                match self.align_self.0.value() {
2146                    AlignFlags::STRETCH => Au::zero(),
2147                    AlignFlags::CENTER => ending_alignment / 2,
2148                    AlignFlags::BASELINE | AlignFlags::LAST_BASELINE => {
2149                        max_propagated_baseline - propagated_baseline
2150                    },
2151                    AlignFlags::START => {
2152                        if !wrap_reverse {
2153                            Au::zero()
2154                        } else {
2155                            ending_alignment
2156                        }
2157                    },
2158                    AlignFlags::END => {
2159                        if !wrap_reverse {
2160                            ending_alignment
2161                        } else {
2162                            Au::zero()
2163                        }
2164                    },
2165                    _ => Au::zero(),
2166                }
2167            };
2168        outer_cross_start + margin.cross_start + self.border.cross_start + self.padding.cross_start
2169    }
2170
2171    #[inline]
2172    fn inline_content_sizes(&self, flex_context: &FlexContext, block_size: Au) -> ContentSizes {
2173        self.box_.inline_content_sizes(
2174            flex_context,
2175            SizeConstraint::Definite(block_size),
2176            self.preferred_aspect_ratio,
2177        )
2178    }
2179
2180    /// The used cross size of this item in a flex line with the given cross size.
2181    /// <https://drafts.csswg.org/css-flexbox/#algo-stretch>
2182    fn used_cross_size(
2183        &self,
2184        cross_axis: LogicalAxis,
2185        line_cross_size: Au,
2186        get_content_size: impl FnOnce() -> ContentSizes,
2187    ) -> Au {
2188        self.content_cross_sizes.resolve(
2189            cross_axis,
2190            self.automatic_cross_size,
2191            Au::zero,
2192            Some(Au::zero().max(line_cross_size - self.pbm_auto_is_zero.cross)),
2193            get_content_size,
2194            // Tables have a special sizing in the block axis in that handles collapsed rows,
2195            // but it would prevent stretching. So we only recognize tables in the inline axis.
2196            // The interaction of collapsed table tracks and the flexbox algorithms is unclear,
2197            // see https://github.com/w3c/csswg-drafts/issues/11408.
2198            self.box_.independent_formatting_context.is_table() &&
2199                cross_axis == LogicalAxis::Inline,
2200        )
2201    }
2202
2203    /// The used cross size of this item in a flex line with the given cross size, if it can
2204    /// be determined without laying out the item.
2205    fn used_cross_size_before_layout(
2206        &self,
2207        flex_context: &FlexContext,
2208        used_main_size: Au,
2209        line_cross_size: Au,
2210    ) -> Option<Au> {
2211        match flex_context.config.flex_axis {
2212            FlexAxis::Column => Some(self.used_cross_size(
2213                LogicalAxis::Inline,
2214                line_cross_size,
2215                || self.inline_content_sizes(flex_context, used_main_size),
2216            )),
2217            // The content size in the block axis is only known after laying out the item.
2218            // This is the same resolution as after the layout, so unlike an extrinsic
2219            // resolution, it's exact when intrinsic minimum or maximum sizes are involved.
2220            FlexAxis::Row => {
2221                let mut needs_content_size = false;
2222                let used_cross_size =
2223                    self.used_cross_size(LogicalAxis::Block, line_cross_size, || {
2224                        needs_content_size = true;
2225                        ContentSizes::default()
2226                    });
2227                (!needs_content_size).then_some(used_cross_size)
2228            },
2229        }
2230    }
2231}
2232
2233impl FlexItemBox {
2234    fn to_flex_item<'a>(
2235        &self,
2236        layout_context: &LayoutContext,
2237        containing_block: &IndefiniteContainingBlock,
2238        content_box_sizes_and_pbm: &ContentBoxSizesAndPBM,
2239        config: &FlexContainerConfig,
2240        flex_context_getter: &impl Fn() -> &'a FlexContext<'a>,
2241    ) -> FlexItem<'_> {
2242        let flex_axis = config.flex_axis;
2243        let style = self.style();
2244        let cross_axis_is_item_block_axis = cross_axis_is_item_block_axis(
2245            containing_block.style.writing_mode.is_horizontal(),
2246            style.writing_mode.is_horizontal(),
2247            flex_axis,
2248        );
2249        let main_axis = if cross_axis_is_item_block_axis {
2250            LogicalAxis::Inline
2251        } else {
2252            LogicalAxis::Block
2253        };
2254        let align_self = AlignItems(config.resolve_align_self_for_child(style));
2255
2256        let ContentBoxSizesAndPBM {
2257            content_box_sizes,
2258            pbm,
2259            depends_on_block_constraints,
2260            preferred_size_computes_to_auto,
2261        } = content_box_sizes_and_pbm;
2262
2263        let preferred_aspect_ratio = self
2264            .independent_formatting_context
2265            .preferred_aspect_ratio(&pbm.padding_border_sums);
2266        let padding = config.sides_to_flex_relative(pbm.padding);
2267        let border = config.sides_to_flex_relative(pbm.border);
2268        let margin = config.sides_to_flex_relative(pbm.margin);
2269        let padding_border = padding.sum_by_axis() + border.sum_by_axis();
2270        let margin_auto_is_zero = config.sides_to_flex_relative(pbm.margin.auto_is(Au::zero));
2271        let pbm_auto_is_zero = FlexRelativeVec2 {
2272            main: padding_border.main,
2273            cross: padding_border.cross,
2274        } + margin_auto_is_zero.sum_by_axis();
2275        let (content_main_sizes, content_cross_sizes, cross_size_computes_to_auto) = match flex_axis
2276        {
2277            FlexAxis::Row => (
2278                &content_box_sizes.inline,
2279                &content_box_sizes.block,
2280                preferred_size_computes_to_auto.block,
2281            ),
2282            FlexAxis::Column => (
2283                &content_box_sizes.block,
2284                &content_box_sizes.inline,
2285                preferred_size_computes_to_auto.inline,
2286            ),
2287        };
2288        let automatic_cross_size = if cross_size_computes_to_auto &&
2289            item_with_auto_cross_size_stretches_to_line_size(align_self, &margin)
2290        {
2291            Size::Stretch
2292        } else {
2293            Size::FitContent
2294        };
2295        let automatic_cross_size_for_intrinsic_sizing = if config.container_is_single_line {
2296            automatic_cross_size
2297        } else {
2298            Size::FitContent
2299        };
2300        debug_assert!(!containing_block.has_quirky_block_size());
2301        let containing_block_size =
2302            flex_axis.vec2_to_flex_relative(containing_block.size.as_logical_vec2());
2303        let stretch_size = FlexRelativeVec2 {
2304            main: containing_block_size
2305                .main
2306                .map(|v| Au::zero().max(v - pbm_auto_is_zero.main)),
2307            cross: containing_block_size
2308                .cross
2309                .map(|v| Au::zero().max(v - pbm_auto_is_zero.cross)),
2310        };
2311
2312        let is_table = self.independent_formatting_context.is_table();
2313        let tentative_cross_content_size = if cross_axis_is_item_block_axis {
2314            self.independent_formatting_context
2315                .tentative_block_content_size(preferred_aspect_ratio, stretch_size.main)
2316        } else {
2317            None
2318        };
2319        let (preferred_cross_size, min_cross_size, max_cross_size) =
2320            if let Some(cross_content_size) = tentative_cross_content_size {
2321                let (preferred, min, max) = content_cross_sizes.resolve_each(
2322                    automatic_cross_size_for_intrinsic_sizing,
2323                    Au::zero,
2324                    stretch_size.cross,
2325                    || cross_content_size,
2326                    is_table,
2327                );
2328                (Some(preferred), min, max)
2329            } else {
2330                content_cross_sizes.resolve_each_extrinsic(
2331                    automatic_cross_size_for_intrinsic_sizing,
2332                    Au::zero(),
2333                    stretch_size.cross,
2334                )
2335            };
2336        let cross_size = SizeConstraint::new(preferred_cross_size, min_cross_size, max_cross_size);
2337
2338        // <https://drafts.csswg.org/css-flexbox/#transferred-size-suggestion>
2339        // > If the item has a preferred aspect ratio and its preferred cross size is definite, then the
2340        // > transferred size suggestion is that size (clamped by its minimum and maximum cross sizes if they
2341        // > are definite), converted through the aspect ratio. It is otherwise undefined.
2342        let transferred_size_suggestion =
2343            LazyCell::new(|| match (preferred_aspect_ratio, cross_size) {
2344                (Some(ratio), SizeConstraint::Definite(cross_size)) => {
2345                    Some(ratio.compute_dependent_size(main_axis, cross_size))
2346                },
2347                _ => None,
2348            });
2349
2350        // <https://drafts.csswg.org/css-flexbox/#algo-main-item>
2351        let flex_base_size_is_definite = Cell::new(true);
2352        let main_content_sizes = LazyCell::new(|| {
2353            let flex_item = &self.independent_formatting_context;
2354            // > B: If the flex item has ...
2355            // >   - a preferred aspect ratio,
2356            // >   - a used flex basis of content, and
2357            // >   - a definite cross size,
2358            // > then the flex base size is calculated from its used cross size and the flex item’s aspect ratio.
2359            if let Some(transferred_size_suggestion) = *transferred_size_suggestion {
2360                return transferred_size_suggestion.into();
2361            }
2362
2363            flex_base_size_is_definite.set(false);
2364
2365            // FIXME: implement cases C, D.
2366
2367            // > E. Otherwise, size the item into the available space using its used flex basis in place of
2368            // > its main size, treating a value of content as max-content. If a cross size is needed to
2369            // > determine the main size (e.g. when the flex item’s main size is in its block axis, or when
2370            // > it has a preferred aspect ratio) and the flex item’s cross size is auto and not definite,
2371            // > in this calculation use fit-content as the flex item’s cross size. The flex base size is
2372            // > the item’s resulting main size.
2373            if cross_axis_is_item_block_axis {
2374                // The main axis is the inline axis, so we can get the content size from the normal
2375                // preferred widths calculation.
2376                let constraint_space =
2377                    ConstraintSpace::new(cross_size, style, preferred_aspect_ratio);
2378                let content_sizes = flex_item
2379                    .inline_content_sizes(layout_context, &constraint_space)
2380                    .sizes;
2381                if let Some(ratio) = preferred_aspect_ratio {
2382                    let transferred_min = ratio.compute_dependent_size(main_axis, min_cross_size);
2383                    let transferred_max =
2384                        max_cross_size.map(|v| ratio.compute_dependent_size(main_axis, v));
2385                    content_sizes
2386                        .map(|size| size.clamp_between_extremums(transferred_min, transferred_max))
2387                } else {
2388                    content_sizes
2389                }
2390            } else {
2391                self.layout_for_block_content_size(
2392                    flex_context_getter(),
2393                    &pbm_auto_is_zero,
2394                    content_box_sizes,
2395                    preferred_aspect_ratio,
2396                    automatic_cross_size_for_intrinsic_sizing,
2397                    IntrinsicSizingMode::Size,
2398                )
2399                .into()
2400            }
2401        });
2402
2403        let flex_base_size = self
2404            .flex_basis(
2405                containing_block_size.main,
2406                content_main_sizes.preferred,
2407                padding_border.main,
2408            )
2409            .resolve_for_preferred(Size::MaxContent, stretch_size.main, &main_content_sizes);
2410        let flex_base_size_is_definite = flex_base_size_is_definite.take();
2411
2412        let content_max_main_size = content_main_sizes
2413            .max
2414            .resolve_for_max(stretch_size.main, &main_content_sizes);
2415
2416        let get_automatic_minimum_size = || {
2417            // This is an implementation of <https://drafts.csswg.org/css-flexbox/#min-size-auto>.
2418            if style.establishes_scroll_container(self.base_fragment_info().flags) {
2419                return Au::zero();
2420            }
2421
2422            // > **specified size suggestion**
2423            // > If the item’s preferred main size is definite and not automatic, then the specified
2424            // > size suggestion is that size. It is otherwise undefined.
2425            let specified_size_suggestion = content_main_sizes
2426                .preferred
2427                .maybe_resolve_extrinsic(stretch_size.main);
2428
2429            let is_replaced = self.independent_formatting_context.is_replaced();
2430
2431            // > **content size suggestion**
2432            // > The content size suggestion is the min-content size in the main axis, clamped, if it has a
2433            // > preferred aspect ratio, by any definite minimum and maximum cross sizes converted through the
2434            // > aspect ratio.
2435            let content_size_suggestion = match preferred_aspect_ratio {
2436                Some(ratio) => main_content_sizes.min_content.clamp_between_extremums(
2437                    ratio.compute_dependent_size(main_axis, min_cross_size),
2438                    max_cross_size.map(|l| ratio.compute_dependent_size(main_axis, l)),
2439                ),
2440                None => main_content_sizes.min_content,
2441            };
2442
2443            // > The content-based minimum size of a flex item is the smaller of its specified size
2444            // > suggestion and its content size suggestion if its specified size suggestion exists;
2445            // > otherwise, the smaller of its transferred size suggestion and its content size
2446            // > suggestion if the element is replaced and its transferred size suggestion exists;
2447            // > otherwise its content size suggestion. In all cases, the size is clamped by the maximum
2448            // > main size if it’s definite.
2449            match (specified_size_suggestion, *transferred_size_suggestion) {
2450                (Some(specified), _) => specified.min(content_size_suggestion),
2451                (_, Some(transferred)) if is_replaced => transferred.min(content_size_suggestion),
2452                _ => content_size_suggestion,
2453            }
2454            .clamp_below_max(content_max_main_size)
2455        };
2456        let content_min_main_size = content_main_sizes.min.resolve_for_min(
2457            get_automatic_minimum_size,
2458            stretch_size.main,
2459            &main_content_sizes,
2460            is_table,
2461        );
2462
2463        FlexItem {
2464            box_: self,
2465            content_cross_sizes: content_cross_sizes.clone(),
2466            padding,
2467            border,
2468            margin: config.sides_to_flex_relative(pbm.margin),
2469            pbm_auto_is_zero,
2470            flex_base_size,
2471            flex_base_size_is_definite,
2472            hypothetical_main_size: flex_base_size
2473                .clamp_between_extremums(content_min_main_size, content_max_main_size),
2474            content_min_main_size,
2475            content_max_main_size,
2476            align_self,
2477            depends_on_block_constraints: *depends_on_block_constraints,
2478            preferred_aspect_ratio,
2479            automatic_cross_size,
2480            automatic_cross_size_for_intrinsic_sizing,
2481        }
2482    }
2483
2484    fn main_content_size_info<'a>(
2485        &self,
2486        layout_context: &LayoutContext,
2487        containing_block: &IndefiniteContainingBlock,
2488        config: &FlexContainerConfig,
2489        flex_context_getter: &impl Fn() -> &'a FlexContext<'a>,
2490    ) -> FlexItemBoxInlineContentSizesInfo {
2491        let content_box_sizes_and_pbm = self
2492            .independent_formatting_context
2493            .layout_style()
2494            .content_box_sizes_and_padding_border_margin(containing_block);
2495
2496        // TODO: when laying out a column container with an indefinite main size,
2497        // we compute the base sizes of the items twice. We should consider caching.
2498        let FlexItem {
2499            flex_base_size,
2500            content_min_main_size,
2501            content_max_main_size,
2502            pbm_auto_is_zero,
2503            preferred_aspect_ratio,
2504            automatic_cross_size_for_intrinsic_sizing,
2505            ..
2506        } = self.to_flex_item(
2507            layout_context,
2508            containing_block,
2509            &content_box_sizes_and_pbm,
2510            config,
2511            flex_context_getter,
2512        );
2513
2514        // Compute the min-content and max-content contributions of the item.
2515        // <https://drafts.csswg.org/css-flexbox/#intrinsic-item-contributions>
2516        let (content_contribution_sizes, depends_on_block_constraints) = match config.flex_axis {
2517            FlexAxis::Row => {
2518                let auto_minimum = LogicalVec2 {
2519                    inline: content_min_main_size,
2520                    block: Au::zero(),
2521                };
2522                let InlineContentSizesResult {
2523                    sizes,
2524                    depends_on_block_constraints,
2525                } = self
2526                    .independent_formatting_context
2527                    .outer_inline_content_sizes(
2528                        layout_context,
2529                        containing_block,
2530                        &auto_minimum,
2531                        automatic_cross_size_for_intrinsic_sizing == Size::Stretch,
2532                        false, /* skippable_for_block_percentage_quirk */
2533                    );
2534                (sizes, depends_on_block_constraints)
2535            },
2536            FlexAxis::Column => {
2537                let size = self.layout_for_block_content_size(
2538                    flex_context_getter(),
2539                    &pbm_auto_is_zero,
2540                    &content_box_sizes_and_pbm.content_box_sizes,
2541                    preferred_aspect_ratio,
2542                    automatic_cross_size_for_intrinsic_sizing,
2543                    IntrinsicSizingMode::Contribution,
2544                );
2545                (size.into(), true)
2546            },
2547        };
2548
2549        let outer_flex_base_size = flex_base_size + pbm_auto_is_zero.main;
2550        let outer_min_main_size = content_min_main_size + pbm_auto_is_zero.main;
2551        let outer_max_main_size = content_max_main_size.map(|v| v + pbm_auto_is_zero.main);
2552        let max_flex_factors = self.desired_flex_factors_for_preferred_width(
2553            content_contribution_sizes.max_content,
2554            flex_base_size,
2555            outer_flex_base_size,
2556        );
2557
2558        // > The min-content main size of a single-line flex container is calculated
2559        // > identically to the max-content main size, except that the flex items’
2560        // > min-content contributions are used instead of their max-content contributions.
2561        let min_flex_factors = self.desired_flex_factors_for_preferred_width(
2562            content_contribution_sizes.min_content,
2563            flex_base_size,
2564            outer_flex_base_size,
2565        );
2566
2567        // > However, for a multi-line container, the min-content main size is simply the
2568        // > largest min-content contribution of all the non-collapsed flex items in the
2569        // > flex container. For this purpose, each item’s contribution is capped by the
2570        // > item’s flex base size if the item is not growable, floored by the item’s flex
2571        // > base size if the item is not shrinkable, and then further clamped by the item’s
2572        // > min and max main sizes.
2573        let mut min_content_main_size_for_multiline_container =
2574            content_contribution_sizes.min_content;
2575        let style_position = &self.style().get_position();
2576        if style_position.flex_grow.is_zero() {
2577            min_content_main_size_for_multiline_container.min_assign(outer_flex_base_size);
2578        }
2579        if style_position.flex_shrink.is_zero() {
2580            min_content_main_size_for_multiline_container.max_assign(outer_flex_base_size);
2581        }
2582        min_content_main_size_for_multiline_container =
2583            min_content_main_size_for_multiline_container
2584                .clamp_between_extremums(outer_min_main_size, outer_max_main_size);
2585
2586        FlexItemBoxInlineContentSizesInfo {
2587            outer_flex_base_size,
2588            outer_min_main_size,
2589            outer_max_main_size,
2590            min_flex_factors,
2591            max_flex_factors,
2592            min_content_main_size_for_multiline_container,
2593            depends_on_block_constraints,
2594        }
2595    }
2596
2597    fn desired_flex_factors_for_preferred_width(
2598        &self,
2599        preferred_width: Au,
2600        flex_base_size: Au,
2601        outer_flex_base_size: Au,
2602    ) -> DesiredFlexFractionAndGrowOrShrinkFactor {
2603        let difference = (preferred_width - outer_flex_base_size).to_f32_px();
2604        let (flex_grow_or_scaled_flex_shrink_factor, desired_flex_fraction) = if difference > 0.0 {
2605            // > If that result is positive, divide it by the item’s flex
2606            // > grow factor if the flex grow > factor is ≥ 1, or multiply
2607            // > it by the flex grow factor if the flex grow factor is < 1;
2608            let flex_grow_factor = self.style().get_position().flex_grow.0;
2609
2610            (
2611                flex_grow_factor,
2612                if flex_grow_factor >= 1.0 {
2613                    difference / flex_grow_factor
2614                } else {
2615                    difference * flex_grow_factor
2616                },
2617            )
2618        } else if difference < 0.0 {
2619            // > if the result is negative, divide it by the item’s scaled
2620            // > flex shrink factor (if dividing > by zero, treat the result
2621            // > as negative infinity).
2622            let flex_shrink_factor = self.style().get_position().flex_shrink.0;
2623            let scaled_flex_shrink_factor = flex_shrink_factor * flex_base_size.to_f32_px();
2624
2625            (
2626                scaled_flex_shrink_factor,
2627                if scaled_flex_shrink_factor != 0.0 {
2628                    difference / scaled_flex_shrink_factor
2629                } else {
2630                    f32::NEG_INFINITY
2631                },
2632            )
2633        } else {
2634            (0.0, 0.0)
2635        };
2636
2637        DesiredFlexFractionAndGrowOrShrinkFactor {
2638            desired_flex_fraction,
2639            flex_grow_or_shrink_factor: flex_grow_or_scaled_flex_shrink_factor,
2640        }
2641    }
2642
2643    /// <https://drafts.csswg.org/css-flexbox-1/#flex-basis-property>
2644    /// Returns the used value of the `flex-basis` property, after resolving percentages,
2645    /// resolving `auto`, and taking `box-sizing` into account.
2646    /// Note that a return value of `Size::Initial` represents `flex-basis: content`,
2647    /// not `flex-basis: auto`, since the latter always resolves to something else.
2648    fn flex_basis(
2649        &self,
2650        container_definite_main_size: Option<Au>,
2651        main_preferred_size: Size<Au>,
2652        main_padding_border_sum: Au,
2653    ) -> Size<Au> {
2654        let style_position = &self.independent_formatting_context.style().get_position();
2655        match &style_position.flex_basis {
2656            // https://drafts.csswg.org/css-flexbox-1/#valdef-flex-basis-content
2657            // > Indicates an automatic size based on the flex item’s content.
2658            FlexBasis::Content => Size::Initial,
2659
2660            FlexBasis::Size(size) => match Size::<LengthPercentage>::from(size) {
2661                // https://drafts.csswg.org/css-flexbox-1/#valdef-flex-basis-auto
2662                // > When specified on a flex item, the `auto` keyword retrieves
2663                // > the value of the main size property as the used `flex-basis`.
2664                Size::Initial => main_preferred_size,
2665
2666                // https://drafts.csswg.org/css-flexbox-1/#flex-basis-property
2667                // > For all values other than `auto` and `content` (defined above),
2668                // > `flex-basis` is resolved the same way as `width` in horizontal
2669                // > writing modes, except that if a value would resolve to `auto`
2670                // > for `width`, it instead resolves to `content` for `flex-basis`.
2671                // > For example, percentage values of `flex-basis` are resolved
2672                // > against the flex item’s containing block (i.e. its flex container);
2673                // > and if that containing block’s size is indefinite,
2674                // > the used value for `flex-basis` is `content`.
2675                size => {
2676                    let apply_box_sizing = |length: Au| {
2677                        match style_position.box_sizing {
2678                            BoxSizing::ContentBox => length,
2679                            // This may make `length` negative,
2680                            // but it will be clamped in the hypothetical main size
2681                            BoxSizing::BorderBox => length - main_padding_border_sum,
2682                        }
2683                    };
2684                    size.resolve_percentages_for_preferred(container_definite_main_size)
2685                        .map(apply_box_sizing)
2686                },
2687            },
2688        }
2689    }
2690
2691    #[servo_tracing::instrument(name = "FlexContainer::layout_for_block_content_size", skip_all)]
2692    fn layout_for_block_content_size(
2693        &self,
2694        flex_context: &FlexContext,
2695        pbm_auto_is_zero: &FlexRelativeVec2<Au>,
2696        content_box_sizes: &LogicalVec2<Sizes>,
2697        preferred_aspect_ratio: Option<AspectRatio>,
2698        automatic_inline_size: Size<Au>,
2699        intrinsic_sizing_mode: IntrinsicSizingMode,
2700    ) -> Au {
2701        let content_block_size = || {
2702            let mut positioning_context = PositioningContext::default();
2703
2704            // We are computing the intrinsic block size, so the tentative block size that we use
2705            // as an input to the intrinsic inline sizes needs to ignore the values of the sizing
2706            // properties in the block axis.
2707            let tentative_block_size = SizeConstraint::default();
2708
2709            // TODO: This is wrong if the item writing mode is different from the flex
2710            // container's writing mode.
2711            let inline_size = {
2712                let stretch_size = flex_context
2713                    .containing_block
2714                    .inline_stretch_size(pbm_auto_is_zero.cross);
2715                let get_content_size = || {
2716                    self.inline_content_sizes(
2717                        flex_context,
2718                        tentative_block_size,
2719                        preferred_aspect_ratio,
2720                    )
2721                };
2722                content_box_sizes.inline.resolve(
2723                    LogicalAxis::Inline,
2724                    automatic_inline_size,
2725                    Au::zero,
2726                    stretch_size,
2727                    get_content_size,
2728                    false,
2729                )
2730            };
2731
2732            self.independent_formatting_context
2733                .content_block_size_under_default_constraint(
2734                    flex_context.layout_context,
2735                    &mut positioning_context,
2736                    inline_size,
2737                    flex_context.containing_block,
2738                    preferred_aspect_ratio,
2739                    &LazySize::intrinsic(),
2740                )
2741        };
2742        match intrinsic_sizing_mode {
2743            IntrinsicSizingMode::Contribution => {
2744                let stretch_size = flex_context
2745                    .containing_block
2746                    .block_stretch_size(pbm_auto_is_zero.main);
2747                let inner_block_size = content_box_sizes.block.resolve(
2748                    LogicalAxis::Block,
2749                    Size::FitContent,
2750                    Au::zero,
2751                    stretch_size,
2752                    || ContentSizes::from(content_block_size()),
2753                    // Tables have a special sizing in the block axis that handles collapsed rows
2754                    // by ignoring the sizing properties and instead relying on the content block size,
2755                    // which should indirectly take sizing properties into account.
2756                    // However, above we laid out the table with a SizeConstraint::default() block size,
2757                    // so the content block size doesn't take sizing properties into account.
2758                    // Therefore, pretending that it's never a table tends to provide a better result.
2759                    false, /* is_table */
2760                );
2761                inner_block_size + pbm_auto_is_zero.main
2762            },
2763            IntrinsicSizingMode::Size => content_block_size(),
2764        }
2765    }
2766
2767    fn inline_content_sizes(
2768        &self,
2769        flex_context: &FlexContext,
2770        block_size: SizeConstraint,
2771        preferred_aspect_ratio: Option<AspectRatio>,
2772    ) -> ContentSizes {
2773        let style = self.independent_formatting_context.style();
2774        let constraint_space = ConstraintSpace::new(block_size, style, preferred_aspect_ratio);
2775        self.independent_formatting_context
2776            .inline_content_sizes(flex_context.layout_context, &constraint_space)
2777            .sizes
2778    }
2779}